cefce88abca32ac69c6ecba5aae559f64b7496e2
[libav.git] / libavformat / utils.c
1 /*
2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19 #include "avformat.h"
20 #include "allformats.h"
21
22 #undef NDEBUG
23 #include <assert.h>
24
25 /**
26 * @file libavformat/utils.c
27 * Various utility functions for using ffmpeg library.
28 */
29
30 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
31 static void av_frac_add(AVFrac *f, int64_t incr);
32 static void av_frac_set(AVFrac *f, int64_t val);
33
34 /** head of registered input format linked list. */
35 AVInputFormat *first_iformat = NULL;
36 /** head of registered output format linked list. */
37 AVOutputFormat *first_oformat = NULL;
38 /** head of registered image format linked list. */
39 AVImageFormat *first_image_format = NULL;
40
41 void av_register_input_format(AVInputFormat *format)
42 {
43 AVInputFormat **p;
44 p = &first_iformat;
45 while (*p != NULL) p = &(*p)->next;
46 *p = format;
47 format->next = NULL;
48 }
49
50 void av_register_output_format(AVOutputFormat *format)
51 {
52 AVOutputFormat **p;
53 p = &first_oformat;
54 while (*p != NULL) p = &(*p)->next;
55 *p = format;
56 format->next = NULL;
57 }
58
59 int match_ext(const char *filename, const char *extensions)
60 {
61 const char *ext, *p;
62 char ext1[32], *q;
63
64 if(!filename)
65 return 0;
66
67 ext = strrchr(filename, '.');
68 if (ext) {
69 ext++;
70 p = extensions;
71 for(;;) {
72 q = ext1;
73 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
74 *q++ = *p++;
75 *q = '\0';
76 if (!strcasecmp(ext1, ext))
77 return 1;
78 if (*p == '\0')
79 break;
80 p++;
81 }
82 }
83 return 0;
84 }
85
86 AVOutputFormat *guess_format(const char *short_name, const char *filename,
87 const char *mime_type)
88 {
89 AVOutputFormat *fmt, *fmt_found;
90 int score_max, score;
91
92 /* specific test for image sequences */
93 #ifdef CONFIG_IMAGE2_MUXER
94 if (!short_name && filename &&
95 filename_number_test(filename) >= 0 &&
96 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
97 return guess_format("image2", NULL, NULL);
98 }
99 #endif
100 if (!short_name && filename &&
101 filename_number_test(filename) >= 0 &&
102 guess_image_format(filename)) {
103 return guess_format("image", NULL, NULL);
104 }
105
106 /* find the proper file type */
107 fmt_found = NULL;
108 score_max = 0;
109 fmt = first_oformat;
110 while (fmt != NULL) {
111 score = 0;
112 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
113 score += 100;
114 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
115 score += 10;
116 if (filename && fmt->extensions &&
117 match_ext(filename, fmt->extensions)) {
118 score += 5;
119 }
120 if (score > score_max) {
121 score_max = score;
122 fmt_found = fmt;
123 }
124 fmt = fmt->next;
125 }
126 return fmt_found;
127 }
128
129 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
130 const char *mime_type)
131 {
132 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
133
134 if (fmt) {
135 AVOutputFormat *stream_fmt;
136 char stream_format_name[64];
137
138 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
139 stream_fmt = guess_format(stream_format_name, NULL, NULL);
140
141 if (stream_fmt)
142 fmt = stream_fmt;
143 }
144
145 return fmt;
146 }
147
148 /**
149 * Guesses the codec id based upon muxer and filename.
150 */
151 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
152 const char *filename, const char *mime_type, enum CodecType type){
153 if(type == CODEC_TYPE_VIDEO){
154 enum CodecID codec_id= CODEC_ID_NONE;
155
156 #ifdef CONFIG_IMAGE2_MUXER
157 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
158 codec_id= av_guess_image2_codec(filename);
159 }
160 #endif
161 if(codec_id == CODEC_ID_NONE)
162 codec_id= fmt->video_codec;
163 return codec_id;
164 }else if(type == CODEC_TYPE_AUDIO)
165 return fmt->audio_codec;
166 else
167 return CODEC_ID_NONE;
168 }
169
170 /**
171 * finds AVInputFormat based on input format's short name.
172 */
173 AVInputFormat *av_find_input_format(const char *short_name)
174 {
175 AVInputFormat *fmt;
176 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
177 if (!strcmp(fmt->name, short_name))
178 return fmt;
179 }
180 return NULL;
181 }
182
183 /* memory handling */
184
185 /**
186 * Default packet destructor.
187 */
188 void av_destruct_packet(AVPacket *pkt)
189 {
190 av_free(pkt->data);
191 pkt->data = NULL; pkt->size = 0;
192 }
193
194 /**
195 * Allocate the payload of a packet and intialized its fields to default values.
196 *
197 * @param pkt packet
198 * @param size wanted payload size
199 * @return 0 if OK. AVERROR_xxx otherwise.
200 */
201 int av_new_packet(AVPacket *pkt, int size)
202 {
203 void *data;
204 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
205 return AVERROR_NOMEM;
206 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
207 if (!data)
208 return AVERROR_NOMEM;
209 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
210
211 av_init_packet(pkt);
212 pkt->data = data;
213 pkt->size = size;
214 pkt->destruct = av_destruct_packet;
215 return 0;
216 }
217
218 /**
219 * Allocate and read the payload of a packet and intialized its fields to default values.
220 *
221 * @param pkt packet
222 * @param size wanted payload size
223 * @return >0 (read size) if OK. AVERROR_xxx otherwise.
224 */
225 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
226 {
227 int ret= av_new_packet(pkt, size);
228
229 if(ret<0)
230 return ret;
231
232 pkt->pos= url_ftell(s);
233
234 ret= get_buffer(s, pkt->data, size);
235 if(ret<=0)
236 av_free_packet(pkt);
237 else
238 pkt->size= ret;
239
240 return ret;
241 }
242
243 /* This is a hack - the packet memory allocation stuff is broken. The
244 packet is allocated if it was not really allocated */
245 int av_dup_packet(AVPacket *pkt)
246 {
247 if (pkt->destruct != av_destruct_packet) {
248 uint8_t *data;
249 /* we duplicate the packet and don't forget to put the padding
250 again */
251 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
252 return AVERROR_NOMEM;
253 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
254 if (!data) {
255 return AVERROR_NOMEM;
256 }
257 memcpy(data, pkt->data, pkt->size);
258 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
259 pkt->data = data;
260 pkt->destruct = av_destruct_packet;
261 }
262 return 0;
263 }
264
265 /* fifo handling */
266
267 int fifo_init(FifoBuffer *f, int size)
268 {
269 f->buffer = av_malloc(size);
270 if (!f->buffer)
271 return -1;
272 f->end = f->buffer + size;
273 f->wptr = f->rptr = f->buffer;
274 return 0;
275 }
276
277 void fifo_free(FifoBuffer *f)
278 {
279 av_free(f->buffer);
280 }
281
282 int fifo_size(FifoBuffer *f, uint8_t *rptr)
283 {
284 int size;
285
286 if(!rptr)
287 rptr= f->rptr;
288
289 if (f->wptr >= rptr) {
290 size = f->wptr - rptr;
291 } else {
292 size = (f->end - rptr) + (f->wptr - f->buffer);
293 }
294 return size;
295 }
296
297 /**
298 * Get data from the fifo (returns -1 if not enough data).
299 */
300 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
301 {
302 uint8_t *rptr;
303 int size, len;
304
305 if(!rptr_ptr)
306 rptr_ptr= &f->rptr;
307 rptr = *rptr_ptr;
308
309 if (f->wptr >= rptr) {
310 size = f->wptr - rptr;
311 } else {
312 size = (f->end - rptr) + (f->wptr - f->buffer);
313 }
314
315 if (size < buf_size)
316 return -1;
317 while (buf_size > 0) {
318 len = f->end - rptr;
319 if (len > buf_size)
320 len = buf_size;
321 memcpy(buf, rptr, len);
322 buf += len;
323 rptr += len;
324 if (rptr >= f->end)
325 rptr = f->buffer;
326 buf_size -= len;
327 }
328 *rptr_ptr = rptr;
329 return 0;
330 }
331
332 /**
333 * Resizes a FIFO.
334 */
335 void fifo_realloc(FifoBuffer *f, unsigned int new_size){
336 unsigned int old_size= f->end - f->buffer;
337
338 if(old_size < new_size){
339 uint8_t *old= f->buffer;
340
341 f->buffer= av_realloc(f->buffer, new_size);
342
343 f->rptr += f->buffer - old;
344 f->wptr += f->buffer - old;
345
346 if(f->wptr < f->rptr){
347 memmove(f->rptr + new_size - old_size, f->rptr, f->buffer + old_size - f->rptr);
348 f->rptr += new_size - old_size;
349 }
350 f->end= f->buffer + new_size;
351 }
352 }
353
354 void fifo_write(FifoBuffer *f, const uint8_t *buf, int size, uint8_t **wptr_ptr)
355 {
356 int len;
357 uint8_t *wptr;
358
359 if(!wptr_ptr)
360 wptr_ptr= &f->wptr;
361 wptr = *wptr_ptr;
362
363 while (size > 0) {
364 len = f->end - wptr;
365 if (len > size)
366 len = size;
367 memcpy(wptr, buf, len);
368 wptr += len;
369 if (wptr >= f->end)
370 wptr = f->buffer;
371 buf += len;
372 size -= len;
373 }
374 *wptr_ptr = wptr;
375 }
376
377 /* get data from the fifo (return -1 if not enough data) */
378 int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
379 {
380 uint8_t *rptr = *rptr_ptr;
381 int size, len;
382
383 if (f->wptr >= rptr) {
384 size = f->wptr - rptr;
385 } else {
386 size = (f->end - rptr) + (f->wptr - f->buffer);
387 }
388
389 if (size < buf_size)
390 return -1;
391 while (buf_size > 0) {
392 len = f->end - rptr;
393 if (len > buf_size)
394 len = buf_size;
395 put_buffer(pb, rptr, len);
396 rptr += len;
397 if (rptr >= f->end)
398 rptr = f->buffer;
399 buf_size -= len;
400 }
401 *rptr_ptr = rptr;
402 return 0;
403 }
404
405 int filename_number_test(const char *filename)
406 {
407 char buf[1024];
408 if(!filename)
409 return -1;
410 return get_frame_filename(buf, sizeof(buf), filename, 1);
411 }
412
413 /**
414 * Guess file format.
415 */
416 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
417 {
418 AVInputFormat *fmt1, *fmt;
419 int score, score_max;
420
421 fmt = NULL;
422 score_max = 0;
423 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
424 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
425 continue;
426 score = 0;
427 if (fmt1->read_probe) {
428 score = fmt1->read_probe(pd);
429 } else if (fmt1->extensions) {
430 if (match_ext(pd->filename, fmt1->extensions)) {
431 score = 50;
432 }
433 }
434 if (score > score_max) {
435 score_max = score;
436 fmt = fmt1;
437 }
438 }
439 return fmt;
440 }
441
442 /************************************************************/
443 /* input media file */
444
445 /**
446 * Open a media file from an IO stream. 'fmt' must be specified.
447 */
448 static const char* format_to_name(void* ptr)
449 {
450 AVFormatContext* fc = (AVFormatContext*) ptr;
451 if(fc->iformat) return fc->iformat->name;
452 else if(fc->oformat) return fc->oformat->name;
453 else return "NULL";
454 }
455
456 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
457
458 AVFormatContext *av_alloc_format_context(void)
459 {
460 AVFormatContext *ic;
461 ic = av_mallocz(sizeof(AVFormatContext));
462 if (!ic) return ic;
463 ic->av_class = &av_format_context_class;
464 return ic;
465 }
466
467 /**
468 * Allocates all the structures needed to read an input stream.
469 * This does not open the needed codecs for decoding the stream[s].
470 */
471 int av_open_input_stream(AVFormatContext **ic_ptr,
472 ByteIOContext *pb, const char *filename,
473 AVInputFormat *fmt, AVFormatParameters *ap)
474 {
475 int err;
476 AVFormatContext *ic;
477 AVFormatParameters default_ap;
478
479 if(!ap){
480 ap=&default_ap;
481 memset(ap, 0, sizeof(default_ap));
482 }
483
484 ic = av_alloc_format_context();
485 if (!ic) {
486 err = AVERROR_NOMEM;
487 goto fail;
488 }
489 ic->iformat = fmt;
490 if (pb)
491 ic->pb = *pb;
492 ic->duration = AV_NOPTS_VALUE;
493 ic->start_time = AV_NOPTS_VALUE;
494 pstrcpy(ic->filename, sizeof(ic->filename), filename);
495
496 /* allocate private data */
497 if (fmt->priv_data_size > 0) {
498 ic->priv_data = av_mallocz(fmt->priv_data_size);
499 if (!ic->priv_data) {
500 err = AVERROR_NOMEM;
501 goto fail;
502 }
503 } else {
504 ic->priv_data = NULL;
505 }
506
507 err = ic->iformat->read_header(ic, ap);
508 if (err < 0)
509 goto fail;
510
511 if (pb)
512 ic->data_offset = url_ftell(&ic->pb);
513
514 *ic_ptr = ic;
515 return 0;
516 fail:
517 if (ic) {
518 av_freep(&ic->priv_data);
519 }
520 av_free(ic);
521 *ic_ptr = NULL;
522 return err;
523 }
524
525 /** Size of probe buffer, for guessing file type from file contents. */
526 #define PROBE_BUF_MIN 2048
527 #define PROBE_BUF_MAX (1<<20)
528
529 /**
530 * Open a media file as input. The codec are not opened. Only the file
531 * header (if present) is read.
532 *
533 * @param ic_ptr the opened media file handle is put here
534 * @param filename filename to open.
535 * @param fmt if non NULL, force the file format to use
536 * @param buf_size optional buffer size (zero if default is OK)
537 * @param ap additionnal parameters needed when opening the file (NULL if default)
538 * @return 0 if OK. AVERROR_xxx otherwise.
539 */
540 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
541 AVInputFormat *fmt,
542 int buf_size,
543 AVFormatParameters *ap)
544 {
545 int err, must_open_file, file_opened, probe_size;
546 AVProbeData probe_data, *pd = &probe_data;
547 ByteIOContext pb1, *pb = &pb1;
548
549 file_opened = 0;
550 pd->filename = "";
551 if (filename)
552 pd->filename = filename;
553 pd->buf = NULL;
554 pd->buf_size = 0;
555
556 if (!fmt) {
557 /* guess format if no file can be opened */
558 fmt = av_probe_input_format(pd, 0);
559 }
560
561 /* do not open file if the format does not need it. XXX: specific
562 hack needed to handle RTSP/TCP */
563 must_open_file = 1;
564 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
565 must_open_file = 0;
566 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
567 }
568
569 if (!fmt || must_open_file) {
570 /* if no file needed do not try to open one */
571 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
572 err = AVERROR_IO;
573 goto fail;
574 }
575 file_opened = 1;
576 if (buf_size > 0) {
577 url_setbufsize(pb, buf_size);
578 }
579
580 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
581 /* read probe data */
582 pd->buf= av_realloc(pd->buf, probe_size);
583 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
584 if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
585 url_fclose(pb);
586 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
587 file_opened = 0;
588 err = AVERROR_IO;
589 goto fail;
590 }
591 }
592 /* guess file format */
593 fmt = av_probe_input_format(pd, 1);
594 }
595 av_freep(&pd->buf);
596 }
597
598 /* if still no format found, error */
599 if (!fmt) {
600 err = AVERROR_NOFMT;
601 goto fail;
602 }
603
604 /* XXX: suppress this hack for redirectors */
605 #ifdef CONFIG_NETWORK
606 if (fmt == &redir_demuxer) {
607 err = redir_open(ic_ptr, pb);
608 url_fclose(pb);
609 return err;
610 }
611 #endif
612
613 /* check filename in case of an image number is expected */
614 if (fmt->flags & AVFMT_NEEDNUMBER) {
615 if (filename_number_test(filename) < 0) {
616 err = AVERROR_NUMEXPECTED;
617 goto fail;
618 }
619 }
620 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
621 if (err)
622 goto fail;
623 return 0;
624 fail:
625 av_freep(&pd->buf);
626 if (file_opened)
627 url_fclose(pb);
628 *ic_ptr = NULL;
629 return err;
630
631 }
632
633 /*******************************************************/
634
635 /**
636 * Read a transport packet from a media file.
637 *
638 * This function is absolete and should never be used.
639 * Use av_read_frame() instead.
640 *
641 * @param s media file handle
642 * @param pkt is filled
643 * @return 0 if OK. AVERROR_xxx if error.
644 */
645 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
646 {
647 return s->iformat->read_packet(s, pkt);
648 }
649
650 /**********************************************************/
651
652 /**
653 * Get the number of samples of an audio frame. Return (-1) if error.
654 */
655 static int get_audio_frame_size(AVCodecContext *enc, int size)
656 {
657 int frame_size;
658
659 if (enc->frame_size <= 1) {
660 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
661
662 if (bits_per_sample) {
663 if (enc->channels == 0)
664 return -1;
665 frame_size = (size << 3) / (bits_per_sample * enc->channels);
666 } else {
667 /* used for example by ADPCM codecs */
668 if (enc->bit_rate == 0)
669 return -1;
670 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
671 }
672 } else {
673 frame_size = enc->frame_size;
674 }
675 return frame_size;
676 }
677
678
679 /**
680 * Return the frame duration in seconds, return 0 if not available.
681 */
682 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
683 AVCodecParserContext *pc, AVPacket *pkt)
684 {
685 int frame_size;
686
687 *pnum = 0;
688 *pden = 0;
689 switch(st->codec->codec_type) {
690 case CODEC_TYPE_VIDEO:
691 if(st->time_base.num*1000LL > st->time_base.den){
692 *pnum = st->time_base.num;
693 *pden = st->time_base.den;
694 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
695 *pnum = st->codec->time_base.num;
696 *pden = st->codec->time_base.den;
697 if (pc && pc->repeat_pict) {
698 *pden *= 2;
699 *pnum = (*pnum) * (2 + pc->repeat_pict);
700 }
701 }
702 break;
703 case CODEC_TYPE_AUDIO:
704 frame_size = get_audio_frame_size(st->codec, pkt->size);
705 if (frame_size < 0)
706 break;
707 *pnum = frame_size;
708 *pden = st->codec->sample_rate;
709 break;
710 default:
711 break;
712 }
713 }
714
715 static int is_intra_only(AVCodecContext *enc){
716 if(enc->codec_type == CODEC_TYPE_AUDIO){
717 return 1;
718 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
719 switch(enc->codec_id){
720 case CODEC_ID_MJPEG:
721 case CODEC_ID_MJPEGB:
722 case CODEC_ID_LJPEG:
723 case CODEC_ID_RAWVIDEO:
724 case CODEC_ID_DVVIDEO:
725 case CODEC_ID_HUFFYUV:
726 case CODEC_ID_FFVHUFF:
727 case CODEC_ID_ASV1:
728 case CODEC_ID_ASV2:
729 case CODEC_ID_VCR1:
730 return 1;
731 default: break;
732 }
733 }
734 return 0;
735 }
736
737 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
738 int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
739 int64_t delta= last_ts - mask/2;
740 return ((lsb - delta)&mask) + delta;
741 }
742
743 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
744 AVCodecParserContext *pc, AVPacket *pkt)
745 {
746 int num, den, presentation_delayed;
747 /* handle wrapping */
748 if(st->cur_dts != AV_NOPTS_VALUE){
749 if(pkt->pts != AV_NOPTS_VALUE)
750 pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
751 if(pkt->dts != AV_NOPTS_VALUE)
752 pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
753 }
754
755 if (pkt->duration == 0) {
756 compute_frame_duration(&num, &den, st, pc, pkt);
757 if (den && num) {
758 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
759 }
760 }
761
762 if(is_intra_only(st->codec))
763 pkt->flags |= PKT_FLAG_KEY;
764
765 /* do we have a video B frame ? */
766 presentation_delayed = 0;
767 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
768 /* XXX: need has_b_frame, but cannot get it if the codec is
769 not initialized */
770 if (( st->codec->codec_id == CODEC_ID_H264
771 || st->codec->has_b_frames) &&
772 pc && pc->pict_type != FF_B_TYPE)
773 presentation_delayed = 1;
774 /* this may be redundant, but it shouldnt hurt */
775 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776 presentation_delayed = 1;
777 }
778
779 if(st->cur_dts == AV_NOPTS_VALUE){
780 if(presentation_delayed) st->cur_dts = -pkt->duration;
781 else st->cur_dts = 0;
782 }
783
784 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
785 /* interpolate PTS and DTS if they are not present */
786 if (presentation_delayed) {
787 /* DTS = decompression time stamp */
788 /* PTS = presentation time stamp */
789 if (pkt->dts == AV_NOPTS_VALUE) {
790 /* if we know the last pts, use it */
791 if(st->last_IP_pts != AV_NOPTS_VALUE)
792 st->cur_dts = pkt->dts = st->last_IP_pts;
793 else
794 pkt->dts = st->cur_dts;
795 } else {
796 st->cur_dts = pkt->dts;
797 }
798 /* this is tricky: the dts must be incremented by the duration
799 of the frame we are displaying, i.e. the last I or P frame */
800 if (st->last_IP_duration == 0)
801 st->cur_dts += pkt->duration;
802 else
803 st->cur_dts += st->last_IP_duration;
804 st->last_IP_duration = pkt->duration;
805 st->last_IP_pts= pkt->pts;
806 /* cannot compute PTS if not present (we can compute it only
807 by knowing the futur */
808 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
809 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
810 int64_t old_diff= ABS(st->cur_dts - pkt->duration - pkt->pts);
811 int64_t new_diff= ABS(st->cur_dts - pkt->pts);
812 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
813 pkt->pts += pkt->duration;
814 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%Ld new:%Ld dur:%d cur:%Ld size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
815 }
816 }
817
818 /* presentation is not delayed : PTS and DTS are the same */
819 if (pkt->pts == AV_NOPTS_VALUE) {
820 if (pkt->dts == AV_NOPTS_VALUE) {
821 pkt->pts = st->cur_dts;
822 pkt->dts = st->cur_dts;
823 }
824 else {
825 st->cur_dts = pkt->dts;
826 pkt->pts = pkt->dts;
827 }
828 } else {
829 st->cur_dts = pkt->pts;
830 pkt->dts = pkt->pts;
831 }
832 st->cur_dts += pkt->duration;
833 }
834 // av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
835
836 /* update flags */
837 if (pc) {
838 pkt->flags = 0;
839 /* key frame computation */
840 switch(st->codec->codec_type) {
841 case CODEC_TYPE_VIDEO:
842 if (pc->pict_type == FF_I_TYPE)
843 pkt->flags |= PKT_FLAG_KEY;
844 break;
845 case CODEC_TYPE_AUDIO:
846 pkt->flags |= PKT_FLAG_KEY;
847 break;
848 default:
849 break;
850 }
851 }
852 }
853
854 void av_destruct_packet_nofree(AVPacket *pkt)
855 {
856 pkt->data = NULL; pkt->size = 0;
857 }
858
859 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
860 {
861 AVStream *st;
862 int len, ret, i;
863
864 for(;;) {
865 /* select current input stream component */
866 st = s->cur_st;
867 if (st) {
868 if (!st->need_parsing || !st->parser) {
869 /* no parsing needed: we just output the packet as is */
870 /* raw data support */
871 *pkt = s->cur_pkt;
872 compute_pkt_fields(s, st, NULL, pkt);
873 s->cur_st = NULL;
874 return 0;
875 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
876 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
877 s->cur_ptr, s->cur_len,
878 s->cur_pkt.pts, s->cur_pkt.dts);
879 s->cur_pkt.pts = AV_NOPTS_VALUE;
880 s->cur_pkt.dts = AV_NOPTS_VALUE;
881 /* increment read pointer */
882 s->cur_ptr += len;
883 s->cur_len -= len;
884
885 /* return packet if any */
886 if (pkt->size) {
887 got_packet:
888 pkt->duration = 0;
889 pkt->stream_index = st->index;
890 pkt->pts = st->parser->pts;
891 pkt->dts = st->parser->dts;
892 pkt->destruct = av_destruct_packet_nofree;
893 compute_pkt_fields(s, st, st->parser, pkt);
894 return 0;
895 }
896 } else {
897 /* free packet */
898 av_free_packet(&s->cur_pkt);
899 s->cur_st = NULL;
900 }
901 } else {
902 /* read next packet */
903 ret = av_read_packet(s, &s->cur_pkt);
904 if (ret < 0) {
905 if (ret == -EAGAIN)
906 return ret;
907 /* return the last frames, if any */
908 for(i = 0; i < s->nb_streams; i++) {
909 st = s->streams[i];
910 if (st->parser && st->need_parsing) {
911 av_parser_parse(st->parser, st->codec,
912 &pkt->data, &pkt->size,
913 NULL, 0,
914 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
915 if (pkt->size)
916 goto got_packet;
917 }
918 }
919 /* no more packets: really terminates parsing */
920 return ret;
921 }
922
923 st = s->streams[s->cur_pkt.stream_index];
924
925 s->cur_st = st;
926 s->cur_ptr = s->cur_pkt.data;
927 s->cur_len = s->cur_pkt.size;
928 if (st->need_parsing && !st->parser) {
929 st->parser = av_parser_init(st->codec->codec_id);
930 if (!st->parser) {
931 /* no parser available : just output the raw packets */
932 st->need_parsing = 0;
933 }else if(st->need_parsing == 2){
934 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
935 }
936 }
937 }
938 }
939 }
940
941 /**
942 * Return the next frame of a stream.
943 *
944 * The returned packet is valid
945 * until the next av_read_frame() or until av_close_input_file() and
946 * must be freed with av_free_packet. For video, the packet contains
947 * exactly one frame. For audio, it contains an integer number of
948 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
949 * data). If the audio frames have a variable size (e.g. MPEG audio),
950 * then it contains one frame.
951 *
952 * pkt->pts, pkt->dts and pkt->duration are always set to correct
953 * values in AV_TIME_BASE unit (and guessed if the format cannot
954 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
955 * has B frames, so it is better to rely on pkt->dts if you do not
956 * decompress the payload.
957 *
958 * @return 0 if OK, < 0 if error or end of file.
959 */
960 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
961 {
962 AVPacketList *pktl;
963 int eof=0;
964 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
965
966 for(;;){
967 pktl = s->packet_buffer;
968 if (pktl) {
969 AVPacket *next_pkt= &pktl->pkt;
970
971 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
972 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
973 if( pktl->pkt.stream_index == next_pkt->stream_index
974 && next_pkt->dts < pktl->pkt.dts
975 && pktl->pkt.pts != pktl->pkt.dts //not b frame
976 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
977 next_pkt->pts= pktl->pkt.dts;
978 }
979 pktl= pktl->next;
980 }
981 pktl = s->packet_buffer;
982 }
983
984 if( next_pkt->pts != AV_NOPTS_VALUE
985 || next_pkt->dts == AV_NOPTS_VALUE
986 || !genpts || eof){
987 /* read packet from packet buffer, if there is data */
988 *pkt = *next_pkt;
989 s->packet_buffer = pktl->next;
990 av_free(pktl);
991 return 0;
992 }
993 }
994 if(genpts){
995 AVPacketList **plast_pktl= &s->packet_buffer;
996 int ret= av_read_frame_internal(s, pkt);
997 if(ret<0){
998 if(pktl && ret != -EAGAIN){
999 eof=1;
1000 continue;
1001 }else
1002 return ret;
1003 }
1004
1005 /* duplicate the packet */
1006 if (av_dup_packet(pkt) < 0)
1007 return AVERROR_NOMEM;
1008
1009 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
1010
1011 pktl = av_mallocz(sizeof(AVPacketList));
1012 if (!pktl)
1013 return AVERROR_NOMEM;
1014
1015 /* add the packet in the buffered packet list */
1016 *plast_pktl = pktl;
1017 pktl->pkt= *pkt;
1018 }else{
1019 assert(!s->packet_buffer);
1020 return av_read_frame_internal(s, pkt);
1021 }
1022 }
1023 }
1024
1025 /* XXX: suppress the packet queue */
1026 static void flush_packet_queue(AVFormatContext *s)
1027 {
1028 AVPacketList *pktl;
1029
1030 for(;;) {
1031 pktl = s->packet_buffer;
1032 if (!pktl)
1033 break;
1034 s->packet_buffer = pktl->next;
1035 av_free_packet(&pktl->pkt);
1036 av_free(pktl);
1037 }
1038 }
1039
1040 /*******************************************************/
1041 /* seek support */
1042
1043 int av_find_default_stream_index(AVFormatContext *s)
1044 {
1045 int i;
1046 AVStream *st;
1047
1048 if (s->nb_streams <= 0)
1049 return -1;
1050 for(i = 0; i < s->nb_streams; i++) {
1051 st = s->streams[i];
1052 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1053 return i;
1054 }
1055 }
1056 return 0;
1057 }
1058
1059 /**
1060 * Flush the frame reader.
1061 */
1062 static void av_read_frame_flush(AVFormatContext *s)
1063 {
1064 AVStream *st;
1065 int i;
1066
1067 flush_packet_queue(s);
1068
1069 /* free previous packet */
1070 if (s->cur_st) {
1071 if (s->cur_st->parser)
1072 av_free_packet(&s->cur_pkt);
1073 s->cur_st = NULL;
1074 }
1075 /* fail safe */
1076 s->cur_ptr = NULL;
1077 s->cur_len = 0;
1078
1079 /* for each stream, reset read state */
1080 for(i = 0; i < s->nb_streams; i++) {
1081 st = s->streams[i];
1082
1083 if (st->parser) {
1084 av_parser_close(st->parser);
1085 st->parser = NULL;
1086 }
1087 st->last_IP_pts = AV_NOPTS_VALUE;
1088 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
1089 }
1090 }
1091
1092 /**
1093 * Updates cur_dts of all streams based on given timestamp and AVStream.
1094 *
1095 * Stream ref_st unchanged, others set cur_dts in their native timebase
1096 * only needed for timestamp wrapping or if (dts not set and pts!=dts)
1097 * @param timestamp new dts expressed in time_base of param ref_st
1098 * @param ref_st reference stream giving time_base of param timestamp
1099 */
1100 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1101 int i;
1102
1103 for(i = 0; i < s->nb_streams; i++) {
1104 AVStream *st = s->streams[i];
1105
1106 st->cur_dts = av_rescale(timestamp,
1107 st->time_base.den * (int64_t)ref_st->time_base.num,
1108 st->time_base.num * (int64_t)ref_st->time_base.den);
1109 }
1110 }
1111
1112 /**
1113 * Add a index entry into a sorted list updateing if it is already there.
1114 *
1115 * @param timestamp timestamp in the timebase of the given stream
1116 */
1117 int av_add_index_entry(AVStream *st,
1118 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1119 {
1120 AVIndexEntry *entries, *ie;
1121 int index;
1122
1123 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1124 return -1;
1125
1126 entries = av_fast_realloc(st->index_entries,
1127 &st->index_entries_allocated_size,
1128 (st->nb_index_entries + 1) *
1129 sizeof(AVIndexEntry));
1130 if(!entries)
1131 return -1;
1132
1133 st->index_entries= entries;
1134
1135 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1136
1137 if(index<0){
1138 index= st->nb_index_entries++;
1139 ie= &entries[index];
1140 assert(index==0 || ie[-1].timestamp < timestamp);
1141 }else{
1142 ie= &entries[index];
1143 if(ie->timestamp != timestamp){
1144 if(ie->timestamp <= timestamp)
1145 return -1;
1146 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1147 st->nb_index_entries++;
1148 }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
1149 distance= ie->min_distance;
1150 }
1151
1152 ie->pos = pos;
1153 ie->timestamp = timestamp;
1154 ie->min_distance= distance;
1155 ie->size= size;
1156 ie->flags = flags;
1157
1158 return index;
1159 }
1160
1161 /**
1162 * build an index for raw streams using a parser.
1163 */
1164 static void av_build_index_raw(AVFormatContext *s)
1165 {
1166 AVPacket pkt1, *pkt = &pkt1;
1167 int ret;
1168 AVStream *st;
1169
1170 st = s->streams[0];
1171 av_read_frame_flush(s);
1172 url_fseek(&s->pb, s->data_offset, SEEK_SET);
1173
1174 for(;;) {
1175 ret = av_read_frame(s, pkt);
1176 if (ret < 0)
1177 break;
1178 if (pkt->stream_index == 0 && st->parser &&
1179 (pkt->flags & PKT_FLAG_KEY)) {
1180 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1181 0, 0, AVINDEX_KEYFRAME);
1182 }
1183 av_free_packet(pkt);
1184 }
1185 }
1186
1187 /**
1188 * Returns TRUE if we deal with a raw stream.
1189 *
1190 * Raw codec data and parsing needed.
1191 */
1192 static int is_raw_stream(AVFormatContext *s)
1193 {
1194 AVStream *st;
1195
1196 if (s->nb_streams != 1)
1197 return 0;
1198 st = s->streams[0];
1199 if (!st->need_parsing)
1200 return 0;
1201 return 1;
1202 }
1203
1204 /**
1205 * Gets the index for a specific timestamp.
1206 * @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond to
1207 * the timestamp which is <= the requested one, if backward is 0
1208 * then it will be >=
1209 * if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
1210 * @return < 0 if no such timestamp could be found
1211 */
1212 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1213 int flags)
1214 {
1215 AVIndexEntry *entries= st->index_entries;
1216 int nb_entries= st->nb_index_entries;
1217 int a, b, m;
1218 int64_t timestamp;
1219
1220 a = - 1;
1221 b = nb_entries;
1222
1223 while (b - a > 1) {
1224 m = (a + b) >> 1;
1225 timestamp = entries[m].timestamp;
1226 if(timestamp >= wanted_timestamp)
1227 b = m;
1228 if(timestamp <= wanted_timestamp)
1229 a = m;
1230 }
1231 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1232
1233 if(!(flags & AVSEEK_FLAG_ANY)){
1234 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1235 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1236 }
1237 }
1238
1239 if(m == nb_entries)
1240 return -1;
1241 return m;
1242 }
1243
1244 #define DEBUG_SEEK
1245
1246 /**
1247 * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1248 * this isnt supposed to be called directly by a user application, but by demuxers
1249 * @param target_ts target timestamp in the time base of the given stream
1250 * @param stream_index stream number
1251 */
1252 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1253 AVInputFormat *avif= s->iformat;
1254 int64_t pos_min, pos_max, pos, pos_limit;
1255 int64_t ts_min, ts_max, ts;
1256 int64_t start_pos, filesize;
1257 int index, no_change;
1258 AVStream *st;
1259
1260 if (stream_index < 0)
1261 return -1;
1262
1263 #ifdef DEBUG_SEEK
1264 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1265 #endif
1266
1267 ts_max=
1268 ts_min= AV_NOPTS_VALUE;
1269 pos_limit= -1; //gcc falsely says it may be uninitalized
1270
1271 st= s->streams[stream_index];
1272 if(st->index_entries){
1273 AVIndexEntry *e;
1274
1275 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non keyframe entries in index case, especially read_timestamp()
1276 index= FFMAX(index, 0);
1277 e= &st->index_entries[index];
1278
1279 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1280 pos_min= e->pos;
1281 ts_min= e->timestamp;
1282 #ifdef DEBUG_SEEK
1283 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1284 pos_min,ts_min);
1285 #endif
1286 }else{
1287 assert(index==0);
1288 }
1289
1290 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1291 assert(index < st->nb_index_entries);
1292 if(index >= 0){
1293 e= &st->index_entries[index];
1294 assert(e->timestamp >= target_ts);
1295 pos_max= e->pos;
1296 ts_max= e->timestamp;
1297 pos_limit= pos_max - e->min_distance;
1298 #ifdef DEBUG_SEEK
1299 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1300 pos_max,pos_limit, ts_max);
1301 #endif
1302 }
1303 }
1304
1305 if(ts_min == AV_NOPTS_VALUE){
1306 pos_min = s->data_offset;
1307 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1308 if (ts_min == AV_NOPTS_VALUE)
1309 return -1;
1310 }
1311
1312 if(ts_max == AV_NOPTS_VALUE){
1313 int step= 1024;
1314 filesize = url_fsize(&s->pb);
1315 pos_max = filesize - 1;
1316 do{
1317 pos_max -= step;
1318 ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1319 step += step;
1320 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1321 if (ts_max == AV_NOPTS_VALUE)
1322 return -1;
1323
1324 for(;;){
1325 int64_t tmp_pos= pos_max + 1;
1326 int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1327 if(tmp_ts == AV_NOPTS_VALUE)
1328 break;
1329 ts_max= tmp_ts;
1330 pos_max= tmp_pos;
1331 if(tmp_pos >= filesize)
1332 break;
1333 }
1334 pos_limit= pos_max;
1335 }
1336
1337 if(ts_min > ts_max){
1338 return -1;
1339 }else if(ts_min == ts_max){
1340 pos_limit= pos_min;
1341 }
1342
1343 no_change=0;
1344 while (pos_min < pos_limit) {
1345 #ifdef DEBUG_SEEK
1346 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1347 pos_min, pos_max,
1348 ts_min, ts_max);
1349 #endif
1350 assert(pos_limit <= pos_max);
1351
1352 if(no_change==0){
1353 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1354 // interpolate position (better than dichotomy)
1355 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1356 + pos_min - approximate_keyframe_distance;
1357 }else if(no_change==1){
1358 // bisection, if interpolation failed to change min or max pos last time
1359 pos = (pos_min + pos_limit)>>1;
1360 }else{
1361 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1362 pos=pos_min;
1363 }
1364 if(pos <= pos_min)
1365 pos= pos_min + 1;
1366 else if(pos > pos_limit)
1367 pos= pos_limit;
1368 start_pos= pos;
1369
1370 ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1371 if(pos == pos_max)
1372 no_change++;
1373 else
1374 no_change=0;
1375 #ifdef DEBUG_SEEK
1376 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1377 #endif
1378 assert(ts != AV_NOPTS_VALUE);
1379 if (target_ts <= ts) {
1380 pos_limit = start_pos - 1;
1381 pos_max = pos;
1382 ts_max = ts;
1383 }
1384 if (target_ts >= ts) {
1385 pos_min = pos;
1386 ts_min = ts;
1387 }
1388 }
1389
1390 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1391 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1392 #ifdef DEBUG_SEEK
1393 pos_min = pos;
1394 ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1395 pos_min++;
1396 ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1397 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1398 pos, ts_min, target_ts, ts_max);
1399 #endif
1400 /* do the seek */
1401 url_fseek(&s->pb, pos, SEEK_SET);
1402
1403 av_update_cur_dts(s, st, ts);
1404
1405 return 0;
1406 }
1407
1408 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1409 int64_t pos_min, pos_max;
1410 #if 0
1411 AVStream *st;
1412
1413 if (stream_index < 0)
1414 return -1;
1415
1416 st= s->streams[stream_index];
1417 #endif
1418
1419 pos_min = s->data_offset;
1420 pos_max = url_fsize(&s->pb) - 1;
1421
1422 if (pos < pos_min) pos= pos_min;
1423 else if(pos > pos_max) pos= pos_max;
1424
1425 url_fseek(&s->pb, pos, SEEK_SET);
1426
1427 #if 0
1428 av_update_cur_dts(s, st, ts);
1429 #endif
1430 return 0;
1431 }
1432
1433 static int av_seek_frame_generic(AVFormatContext *s,
1434 int stream_index, int64_t timestamp, int flags)
1435 {
1436 int index;
1437 AVStream *st;
1438 AVIndexEntry *ie;
1439
1440 if (!s->index_built) {
1441 if (is_raw_stream(s)) {
1442 av_build_index_raw(s);
1443 } else {
1444 return -1;
1445 }
1446 s->index_built = 1;
1447 }
1448
1449 st = s->streams[stream_index];
1450 index = av_index_search_timestamp(st, timestamp, flags);
1451 if (index < 0)
1452 return -1;
1453
1454 /* now we have found the index, we can seek */
1455 ie = &st->index_entries[index];
1456 av_read_frame_flush(s);
1457 url_fseek(&s->pb, ie->pos, SEEK_SET);
1458
1459 av_update_cur_dts(s, st, ie->timestamp);
1460
1461 return 0;
1462 }
1463
1464 /**
1465 * Seek to the key frame at timestamp.
1466 * 'timestamp' in 'stream_index'.
1467 * @param stream_index If stream_index is (-1), a default
1468 * stream is selected, and timestamp is automatically converted
1469 * from AV_TIME_BASE units to the stream specific time_base.
1470 * @param timestamp timestamp in AVStream.time_base units
1471 * or if there is no stream specified then in AV_TIME_BASE units
1472 * @param flags flags which select direction and seeking mode
1473 * @return >= 0 on success
1474 */
1475 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1476 {
1477 int ret;
1478 AVStream *st;
1479
1480 av_read_frame_flush(s);
1481
1482 if(flags & AVSEEK_FLAG_BYTE)
1483 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1484
1485 if(stream_index < 0){
1486 stream_index= av_find_default_stream_index(s);
1487 if(stream_index < 0)
1488 return -1;
1489
1490 st= s->streams[stream_index];
1491 /* timestamp for default must be expressed in AV_TIME_BASE units */
1492 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1493 }
1494 st= s->streams[stream_index];
1495
1496 /* first, we try the format specific seek */
1497 if (s->iformat->read_seek)
1498 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1499 else
1500 ret = -1;
1501 if (ret >= 0) {
1502 return 0;
1503 }
1504
1505 if(s->iformat->read_timestamp)
1506 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1507 else
1508 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1509 }
1510
1511 /*******************************************************/
1512
1513 /**
1514 * Returns TRUE if the stream has accurate timings in any stream.
1515 *
1516 * @return TRUE if the stream has accurate timings for at least one component.
1517 */
1518 static int av_has_timings(AVFormatContext *ic)
1519 {
1520 int i;
1521 AVStream *st;
1522
1523 for(i = 0;i < ic->nb_streams; i++) {
1524 st = ic->streams[i];
1525 if (st->start_time != AV_NOPTS_VALUE &&
1526 st->duration != AV_NOPTS_VALUE)
1527 return 1;
1528 }
1529 return 0;
1530 }
1531
1532 /**
1533 * Estimate the stream timings from the one of each components.
1534 *
1535 * Also computes the global bitrate if possible.
1536 */
1537 static void av_update_stream_timings(AVFormatContext *ic)
1538 {
1539 int64_t start_time, start_time1, end_time, end_time1;
1540 int i;
1541 AVStream *st;
1542
1543 start_time = MAXINT64;
1544 end_time = MININT64;
1545 for(i = 0;i < ic->nb_streams; i++) {
1546 st = ic->streams[i];
1547 if (st->start_time != AV_NOPTS_VALUE) {
1548 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1549 if (start_time1 < start_time)
1550 start_time = start_time1;
1551 if (st->duration != AV_NOPTS_VALUE) {
1552 end_time1 = start_time1
1553 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1554 if (end_time1 > end_time)
1555 end_time = end_time1;
1556 }
1557 }
1558 }
1559 if (start_time != MAXINT64) {
1560 ic->start_time = start_time;
1561 if (end_time != MININT64) {
1562 ic->duration = end_time - start_time;
1563 if (ic->file_size > 0) {
1564 /* compute the bit rate */
1565 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1566 (double)ic->duration;
1567 }
1568 }
1569 }
1570
1571 }
1572
1573 static void fill_all_stream_timings(AVFormatContext *ic)
1574 {
1575 int i;
1576 AVStream *st;
1577
1578 av_update_stream_timings(ic);
1579 for(i = 0;i < ic->nb_streams; i++) {
1580 st = ic->streams[i];
1581 if (st->start_time == AV_NOPTS_VALUE) {
1582 if(ic->start_time != AV_NOPTS_VALUE)
1583 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1584 if(ic->duration != AV_NOPTS_VALUE)
1585 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1586 }
1587 }
1588 }
1589
1590 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1591 {
1592 int64_t filesize, duration;
1593 int bit_rate, i;
1594 AVStream *st;
1595
1596 /* if bit_rate is already set, we believe it */
1597 if (ic->bit_rate == 0) {
1598 bit_rate = 0;
1599 for(i=0;i<ic->nb_streams;i++) {
1600 st = ic->streams[i];
1601 bit_rate += st->codec->bit_rate;
1602 }
1603 ic->bit_rate = bit_rate;
1604 }
1605
1606 /* if duration is already set, we believe it */
1607 if (ic->duration == AV_NOPTS_VALUE &&
1608 ic->bit_rate != 0 &&
1609 ic->file_size != 0) {
1610 filesize = ic->file_size;
1611 if (filesize > 0) {
1612 for(i = 0; i < ic->nb_streams; i++) {
1613 st = ic->streams[i];
1614 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1615 if (st->start_time == AV_NOPTS_VALUE ||
1616 st->duration == AV_NOPTS_VALUE) {
1617 st->start_time = 0;
1618 st->duration = duration;
1619 }
1620 }
1621 }
1622 }
1623 }
1624
1625 #define DURATION_MAX_READ_SIZE 250000
1626
1627 /* only usable for MPEG-PS streams */
1628 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1629 {
1630 AVPacket pkt1, *pkt = &pkt1;
1631 AVStream *st;
1632 int read_size, i, ret;
1633 int64_t end_time;
1634 int64_t filesize, offset, duration;
1635
1636 /* free previous packet */
1637 if (ic->cur_st && ic->cur_st->parser)
1638 av_free_packet(&ic->cur_pkt);
1639 ic->cur_st = NULL;
1640
1641 /* flush packet queue */
1642 flush_packet_queue(ic);
1643
1644 for(i=0;i<ic->nb_streams;i++) {
1645 st = ic->streams[i];
1646 if (st->parser) {
1647 av_parser_close(st->parser);
1648 st->parser= NULL;
1649 }
1650 }
1651
1652 /* we read the first packets to get the first PTS (not fully
1653 accurate, but it is enough now) */
1654 url_fseek(&ic->pb, 0, SEEK_SET);
1655 read_size = 0;
1656 for(;;) {
1657 if (read_size >= DURATION_MAX_READ_SIZE)
1658 break;
1659 /* if all info is available, we can stop */
1660 for(i = 0;i < ic->nb_streams; i++) {
1661 st = ic->streams[i];
1662 if (st->start_time == AV_NOPTS_VALUE)
1663 break;
1664 }
1665 if (i == ic->nb_streams)
1666 break;
1667
1668 ret = av_read_packet(ic, pkt);
1669 if (ret != 0)
1670 break;
1671 read_size += pkt->size;
1672 st = ic->streams[pkt->stream_index];
1673 if (pkt->pts != AV_NOPTS_VALUE) {
1674 if (st->start_time == AV_NOPTS_VALUE)
1675 st->start_time = pkt->pts;
1676 }
1677 av_free_packet(pkt);
1678 }
1679
1680 /* estimate the end time (duration) */
1681 /* XXX: may need to support wrapping */
1682 filesize = ic->file_size;
1683 offset = filesize - DURATION_MAX_READ_SIZE;
1684 if (offset < 0)
1685 offset = 0;
1686
1687 url_fseek(&ic->pb, offset, SEEK_SET);
1688 read_size = 0;
1689 for(;;) {
1690 if (read_size >= DURATION_MAX_READ_SIZE)
1691 break;
1692 /* if all info is available, we can stop */
1693 for(i = 0;i < ic->nb_streams; i++) {
1694 st = ic->streams[i];
1695 if (st->duration == AV_NOPTS_VALUE)
1696 break;
1697 }
1698 if (i == ic->nb_streams)
1699 break;
1700
1701 ret = av_read_packet(ic, pkt);
1702 if (ret != 0)
1703 break;
1704 read_size += pkt->size;
1705 st = ic->streams[pkt->stream_index];
1706 if (pkt->pts != AV_NOPTS_VALUE) {
1707 end_time = pkt->pts;
1708 duration = end_time - st->start_time;
1709 if (duration > 0) {
1710 if (st->duration == AV_NOPTS_VALUE ||
1711 st->duration < duration)
1712 st->duration = duration;
1713 }
1714 }
1715 av_free_packet(pkt);
1716 }
1717
1718 fill_all_stream_timings(ic);
1719
1720 url_fseek(&ic->pb, 0, SEEK_SET);
1721 }
1722
1723 static void av_estimate_timings(AVFormatContext *ic)
1724 {
1725 int64_t file_size;
1726
1727 /* get the file size, if possible */
1728 if (ic->iformat->flags & AVFMT_NOFILE) {
1729 file_size = 0;
1730 } else {
1731 file_size = url_fsize(&ic->pb);
1732 if (file_size < 0)
1733 file_size = 0;
1734 }
1735 ic->file_size = file_size;
1736
1737 if ((!strcmp(ic->iformat->name, "mpeg") ||
1738 !strcmp(ic->iformat->name, "mpegts")) &&
1739 file_size && !ic->pb.is_streamed) {
1740 /* get accurate estimate from the PTSes */
1741 av_estimate_timings_from_pts(ic);
1742 } else if (av_has_timings(ic)) {
1743 /* at least one components has timings - we use them for all
1744 the components */
1745 fill_all_stream_timings(ic);
1746 } else {
1747 /* less precise: use bit rate info */
1748 av_estimate_timings_from_bit_rate(ic);
1749 }
1750 av_update_stream_timings(ic);
1751
1752 #if 0
1753 {
1754 int i;
1755 AVStream *st;
1756 for(i = 0;i < ic->nb_streams; i++) {
1757 st = ic->streams[i];
1758 printf("%d: start_time: %0.3f duration: %0.3f\n",
1759 i, (double)st->start_time / AV_TIME_BASE,
1760 (double)st->duration / AV_TIME_BASE);
1761 }
1762 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1763 (double)ic->start_time / AV_TIME_BASE,
1764 (double)ic->duration / AV_TIME_BASE,
1765 ic->bit_rate / 1000);
1766 }
1767 #endif
1768 }
1769
1770 static int has_codec_parameters(AVCodecContext *enc)
1771 {
1772 int val;
1773 switch(enc->codec_type) {
1774 case CODEC_TYPE_AUDIO:
1775 val = enc->sample_rate;
1776 break;
1777 case CODEC_TYPE_VIDEO:
1778 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1779 break;
1780 default:
1781 val = 1;
1782 break;
1783 }
1784 return (val != 0);
1785 }
1786
1787 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1788 {
1789 int16_t *samples;
1790 AVCodec *codec;
1791 int got_picture, ret=0;
1792 AVFrame picture;
1793
1794 if(!st->codec->codec){
1795 codec = avcodec_find_decoder(st->codec->codec_id);
1796 if (!codec)
1797 return -1;
1798 ret = avcodec_open(st->codec, codec);
1799 if (ret < 0)
1800 return ret;
1801 }
1802
1803 if(!has_codec_parameters(st->codec)){
1804 switch(st->codec->codec_type) {
1805 case CODEC_TYPE_VIDEO:
1806 ret = avcodec_decode_video(st->codec, &picture,
1807 &got_picture, (uint8_t *)data, size);
1808 break;
1809 case CODEC_TYPE_AUDIO:
1810 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1811 if (!samples)
1812 goto fail;
1813 ret = avcodec_decode_audio(st->codec, samples,
1814 &got_picture, (uint8_t *)data, size);
1815 av_free(samples);
1816 break;
1817 default:
1818 break;
1819 }
1820 }
1821 fail:
1822 return ret;
1823 }
1824
1825 /* absolute maximum size we read until we abort */
1826 #define MAX_READ_SIZE 5000000
1827
1828 /* maximum duration until we stop analysing the stream */
1829 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 3.0))
1830
1831 /**
1832 * Read the beginning of a media file to get stream information. This
1833 * is useful for file formats with no headers such as MPEG. This
1834 * function also compute the real frame rate in case of mpeg2 repeat
1835 * frame mode.
1836 *
1837 * @param ic media file handle
1838 * @return >=0 if OK. AVERROR_xxx if error.
1839 * @todo let user decide somehow what information is needed so we dont waste time geting stuff the user doesnt need
1840 */
1841 int av_find_stream_info(AVFormatContext *ic)
1842 {
1843 int i, count, ret, read_size, j;
1844 AVStream *st;
1845 AVPacket pkt1, *pkt;
1846 AVPacketList *pktl=NULL, **ppktl;
1847 int64_t last_dts[MAX_STREAMS];
1848 int64_t duration_sum[MAX_STREAMS];
1849 int duration_count[MAX_STREAMS]={0};
1850
1851 for(i=0;i<ic->nb_streams;i++) {
1852 st = ic->streams[i];
1853 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1854 /* if(!st->time_base.num)
1855 st->time_base= */
1856 if(!st->codec->time_base.num)
1857 st->codec->time_base= st->time_base;
1858 }
1859 //only for the split stuff
1860 if (!st->parser) {
1861 st->parser = av_parser_init(st->codec->codec_id);
1862 if(st->need_parsing == 2 && st->parser){
1863 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1864 }
1865 }
1866 }
1867
1868 for(i=0;i<MAX_STREAMS;i++){
1869 last_dts[i]= AV_NOPTS_VALUE;
1870 duration_sum[i]= INT64_MAX;
1871 }
1872
1873 count = 0;
1874 read_size = 0;
1875 ppktl = &ic->packet_buffer;
1876 for(;;) {
1877 /* check if one codec still needs to be handled */
1878 for(i=0;i<ic->nb_streams;i++) {
1879 st = ic->streams[i];
1880 if (!has_codec_parameters(st->codec))
1881 break;
1882 /* variable fps and no guess at the real fps */
1883 if( st->codec->time_base.den >= 101LL*st->codec->time_base.num
1884 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1885 break;
1886 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1887 break;
1888 }
1889 if (i == ic->nb_streams) {
1890 /* NOTE: if the format has no header, then we need to read
1891 some packets to get most of the streams, so we cannot
1892 stop here */
1893 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1894 /* if we found the info for all the codecs, we can stop */
1895 ret = count;
1896 break;
1897 }
1898 } else {
1899 /* we did not get all the codec info, but we read too much data */
1900 if (read_size >= MAX_READ_SIZE) {
1901 ret = count;
1902 break;
1903 }
1904 }
1905
1906 /* NOTE: a new stream can be added there if no header in file
1907 (AVFMTCTX_NOHEADER) */
1908 ret = av_read_frame_internal(ic, &pkt1);
1909 if (ret < 0) {
1910 /* EOF or error */
1911 ret = -1; /* we could not have all the codec parameters before EOF */
1912 for(i=0;i<ic->nb_streams;i++) {
1913 st = ic->streams[i];
1914 if (!has_codec_parameters(st->codec)){
1915 char buf[256];
1916 avcodec_string(buf, sizeof(buf), st->codec, 0);
1917 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1918 } else {
1919 ret = 0;
1920 }
1921 }
1922 break;
1923 }
1924
1925 pktl = av_mallocz(sizeof(AVPacketList));
1926 if (!pktl) {
1927 ret = AVERROR_NOMEM;
1928 break;
1929 }
1930
1931 /* add the packet in the buffered packet list */
1932 *ppktl = pktl;
1933 ppktl = &pktl->next;
1934
1935 pkt = &pktl->pkt;
1936 *pkt = pkt1;
1937
1938 /* duplicate the packet */
1939 if (av_dup_packet(pkt) < 0) {
1940 ret = AVERROR_NOMEM;
1941 break;
1942 }
1943
1944 read_size += pkt->size;
1945
1946 st = ic->streams[pkt->stream_index];
1947 st->codec_info_duration += pkt->duration;
1948 if (pkt->duration != 0)
1949 st->codec_info_nb_frames++;
1950
1951 {
1952 int index= pkt->stream_index;
1953 int64_t last= last_dts[index];
1954 int64_t duration= pkt->dts - last;
1955
1956 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1957 if(duration*duration_count[index]*10/9 < duration_sum[index]){
1958 duration_sum[index]= duration;
1959 duration_count[index]=1;
1960 }else{
1961 int factor= av_rescale(duration, duration_count[index], duration_sum[index]);
1962 duration_sum[index] += duration;
1963 duration_count[index]+= factor;
1964 }
1965 if(st->codec_info_nb_frames == 0 && 0)
1966 st->codec_info_duration += duration;
1967 }
1968 last_dts[pkt->stream_index]= pkt->dts;
1969 }
1970 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1971 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1972 if(i){
1973 st->codec->extradata_size= i;
1974 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1975 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1976 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1977 }
1978 }
1979
1980 /* if still no information, we try to open the codec and to
1981 decompress the frame. We try to avoid that in most cases as
1982 it takes longer and uses more memory. For MPEG4, we need to
1983 decompress for Quicktime. */
1984 if (!has_codec_parameters(st->codec) /*&&
1985 (st->codec->codec_id == CODEC_ID_FLV1 ||
1986 st->codec->codec_id == CODEC_ID_H264 ||
1987 st->codec->codec_id == CODEC_ID_H263 ||
1988 st->codec->codec_id == CODEC_ID_H261 ||
1989 st->codec->codec_id == CODEC_ID_VORBIS ||
1990 st->codec->codec_id == CODEC_ID_MJPEG ||
1991 st->codec->codec_id == CODEC_ID_PNG ||
1992 st->codec->codec_id == CODEC_ID_PAM ||
1993 st->codec->codec_id == CODEC_ID_PGM ||
1994 st->codec->codec_id == CODEC_ID_PGMYUV ||
1995 st->codec->codec_id == CODEC_ID_PBM ||
1996 st->codec->codec_id == CODEC_ID_PPM ||
1997 st->codec->codec_id == CODEC_ID_SHORTEN ||
1998 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1999 try_decode_frame(st, pkt->data, pkt->size);
2000
2001 if (av_rescale_q(st->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= MAX_STREAM_DURATION) {
2002 break;
2003 }
2004 count++;
2005 }
2006
2007 // close codecs which where opened in try_decode_frame()
2008 for(i=0;i<ic->nb_streams;i++) {
2009 st = ic->streams[i];
2010 if(st->codec->codec)
2011 avcodec_close(st->codec);
2012 }
2013 for(i=0;i<ic->nb_streams;i++) {
2014 st = ic->streams[i];
2015 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2016 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2017 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2018
2019 if(duration_count[i] && st->codec->time_base.num*101LL <= st->codec->time_base.den &&
2020 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den){
2021 int64_t num, den, error, best_error;
2022
2023 num= st->time_base.den*duration_count[i];
2024 den= st->time_base.num*duration_sum[i];
2025
2026 best_error= INT64_MAX;
2027 for(j=1; j<60*12; j++){
2028 error= ABS(1001*12*num - 1001*j*den);
2029 if(error < best_error){
2030 best_error= error;
2031 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j, 12, INT_MAX);
2032 }
2033 }
2034 for(j=24; j<=30; j+=6){
2035 error= ABS(1001*12*num - 1000*12*j*den);
2036 if(error < best_error){
2037 best_error= error;
2038 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, j*1000, 1001, INT_MAX);
2039 }
2040 }
2041 }
2042
2043 /* set real frame rate info */
2044 /* compute the real frame rate for telecine */
2045 if ((st->codec->codec_id == CODEC_ID_MPEG1VIDEO ||
2046 st->codec->codec_id == CODEC_ID_MPEG2VIDEO) &&
2047 st->codec->sub_id == 2) {
2048 if (st->codec_info_nb_frames >= 20) {
2049 float coded_frame_rate, est_frame_rate;
2050 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
2051 (double)st->codec_info_duration ;
2052 coded_frame_rate = 1.0/av_q2d(st->codec->time_base);
2053 #if 0
2054 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
2055 coded_frame_rate, est_frame_rate);
2056 #endif
2057 /* if we detect that it could be a telecine, we
2058 signal it. It would be better to do it at a
2059 higher level as it can change in a film */
2060 if (coded_frame_rate >= 24.97 &&
2061 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
2062 st->r_frame_rate = (AVRational){24000, 1001};
2063 }
2064 }
2065 }
2066 /* if no real frame rate, use the codec one */
2067 if (!st->r_frame_rate.num){
2068 st->r_frame_rate.num = st->codec->time_base.den;
2069 st->r_frame_rate.den = st->codec->time_base.num;
2070 }
2071 }
2072 }
2073
2074 av_estimate_timings(ic);
2075 #if 0
2076 /* correct DTS for b frame streams with no timestamps */
2077 for(i=0;i<ic->nb_streams;i++) {
2078 st = ic->streams[i];
2079 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2080 if(b-frames){
2081 ppktl = &ic->packet_buffer;
2082 while(ppkt1){
2083 if(ppkt1->stream_index != i)
2084 continue;
2085 if(ppkt1->pkt->dts < 0)
2086 break;
2087 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2088 break;
2089 ppkt1->pkt->dts -= delta;
2090 ppkt1= ppkt1->next;
2091 }
2092 if(ppkt1)
2093 continue;
2094 st->cur_dts -= delta;
2095 }
2096 }
2097 }
2098 #endif
2099 return ret;
2100 }
2101
2102 /*******************************************************/
2103
2104 /**
2105 * start playing a network based stream (e.g. RTSP stream) at the
2106 * current position
2107 */
2108 int av_read_play(AVFormatContext *s)
2109 {
2110 if (!s->iformat->read_play)
2111 return AVERROR_NOTSUPP;
2112 return s->iformat->read_play(s);
2113 }
2114
2115 /**
2116 * Pause a network based stream (e.g. RTSP stream).
2117 *
2118 * Use av_read_play() to resume it.
2119 */
2120 int av_read_pause(AVFormatContext *s)
2121 {
2122 if (!s->iformat->read_pause)
2123 return AVERROR_NOTSUPP;
2124 return s->iformat->read_pause(s);
2125 }
2126
2127 /**
2128 * Close a media file (but not its codecs).
2129 *
2130 * @param s media file handle
2131 */
2132 void av_close_input_file(AVFormatContext *s)
2133 {
2134 int i, must_open_file;
2135 AVStream *st;
2136
2137 /* free previous packet */
2138 if (s->cur_st && s->cur_st->parser)
2139 av_free_packet(&s->cur_pkt);
2140
2141 if (s->iformat->read_close)
2142 s->iformat->read_close(s);
2143 for(i=0;i<s->nb_streams;i++) {
2144 /* free all data in a stream component */
2145 st = s->streams[i];
2146 if (st->parser) {
2147 av_parser_close(st->parser);
2148 }
2149 av_free(st->index_entries);
2150 av_free(st->codec->extradata);
2151 av_free(st->codec);
2152 av_free(st);
2153 }
2154 flush_packet_queue(s);
2155 must_open_file = 1;
2156 if (s->iformat->flags & AVFMT_NOFILE) {
2157 must_open_file = 0;
2158 }
2159 if (must_open_file) {
2160 url_fclose(&s->pb);
2161 }
2162 av_freep(&s->priv_data);
2163 av_free(s);
2164 }
2165
2166 /**
2167 * Add a new stream to a media file.
2168 *
2169 * Can only be called in the read_header() function. If the flag
2170 * AVFMTCTX_NOHEADER is in the format context, then new streams
2171 * can be added in read_packet too.
2172 *
2173 * @param s media file handle
2174 * @param id file format dependent stream id
2175 */
2176 AVStream *av_new_stream(AVFormatContext *s, int id)
2177 {
2178 AVStream *st;
2179
2180 if (s->nb_streams >= MAX_STREAMS)
2181 return NULL;
2182
2183 st = av_mallocz(sizeof(AVStream));
2184 if (!st)
2185 return NULL;
2186
2187 st->codec= avcodec_alloc_context();
2188 if (s->iformat) {
2189 /* no default bitrate if decoding */
2190 st->codec->bit_rate = 0;
2191 }
2192 st->index = s->nb_streams;
2193 st->id = id;
2194 st->start_time = AV_NOPTS_VALUE;
2195 st->duration = AV_NOPTS_VALUE;
2196 st->cur_dts = AV_NOPTS_VALUE;
2197
2198 /* default pts settings is MPEG like */
2199 av_set_pts_info(st, 33, 1, 90000);
2200 st->last_IP_pts = AV_NOPTS_VALUE;
2201
2202 s->streams[s->nb_streams++] = st;
2203 return st;
2204 }
2205
2206 /************************************************************/
2207 /* output media file */
2208
2209 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2210 {
2211 int ret;
2212
2213 if (s->oformat->priv_data_size > 0) {
2214 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2215 if (!s->priv_data)
2216 return AVERROR_NOMEM;
2217 } else
2218 s->priv_data = NULL;
2219
2220 if (s->oformat->set_parameters) {
2221 ret = s->oformat->set_parameters(s, ap);
2222 if (ret < 0)
2223 return ret;
2224 }
2225 return 0;
2226 }
2227
2228 /**
2229 * allocate the stream private data and write the stream header to an
2230 * output media file
2231 *
2232 * @param s media file handle
2233 * @return 0 if OK. AVERROR_xxx if error.
2234 */
2235 int av_write_header(AVFormatContext *s)
2236 {
2237 int ret, i;
2238 AVStream *st;
2239
2240 // some sanity checks
2241 for(i=0;i<s->nb_streams;i++) {
2242 st = s->streams[i];
2243
2244 switch (st->codec->codec_type) {
2245 case CODEC_TYPE_AUDIO:
2246 if(st->codec->sample_rate<=0){
2247 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2248 return -1;
2249 }
2250 break;
2251 case CODEC_TYPE_VIDEO:
2252 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2253 av_log(s, AV_LOG_ERROR, "time base not set\n");
2254 return -1;
2255 }
2256 if(st->codec->width<=0 || st->codec->height<=0){
2257 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2258 return -1;
2259 }
2260 break;
2261 }
2262 }
2263
2264 if(s->oformat->write_header){
2265 ret = s->oformat->write_header(s);
2266 if (ret < 0)
2267 return ret;
2268 }
2269
2270 /* init PTS generation */
2271 for(i=0;i<s->nb_streams;i++) {
2272 int64_t den = AV_NOPTS_VALUE;
2273 st = s->streams[i];
2274
2275 switch (st->codec->codec_type) {
2276 case CODEC_TYPE_AUDIO:
2277 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2278 break;
2279 case CODEC_TYPE_VIDEO:
2280 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2281 break;
2282 default:
2283 break;
2284 }
2285 if (den != AV_NOPTS_VALUE) {
2286 if (den <= 0)
2287 return AVERROR_INVALIDDATA;
2288 av_frac_init(&st->pts, 0, 0, den);
2289 }
2290 }
2291 return 0;
2292 }
2293
2294 //FIXME merge with compute_pkt_fields
2295 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2296 int b_frames = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames);
2297 int num, den, frame_size;
2298
2299 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
2300
2301 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2302 return -1;*/
2303
2304 /* duration field */
2305 if (pkt->duration == 0) {
2306 compute_frame_duration(&num, &den, st, NULL, pkt);
2307 if (den && num) {
2308 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2309 }
2310 }
2311
2312 //XXX/FIXME this is a temporary hack until all encoders output pts
2313 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
2314 pkt->dts=
2315 // pkt->pts= st->cur_dts;
2316 pkt->pts= st->pts.val;
2317 }
2318
2319 //calculate dts from pts
2320 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2321 if(b_frames){
2322 if(st->last_IP_pts == AV_NOPTS_VALUE){
2323 st->last_IP_pts= -pkt->duration;
2324 }
2325 if(st->last_IP_pts < pkt->pts){
2326 pkt->dts= st->last_IP_pts;
2327 st->last_IP_pts= pkt->pts;
2328 }else
2329 pkt->dts= pkt->pts;
2330 }else
2331 pkt->dts= pkt->pts;
2332 }
2333
2334 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2335 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2336 return -1;
2337 }
2338 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2339 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2340 return -1;
2341 }
2342
2343 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
2344 st->cur_dts= pkt->dts;
2345 st->pts.val= pkt->dts;
2346
2347 /* update pts */
2348 switch (st->codec->codec_type) {
2349 case CODEC_TYPE_AUDIO:
2350 frame_size = get_audio_frame_size(st->codec, pkt->size);
2351
2352 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2353 but it would be better if we had the real timestamps from the encoder */
2354 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2355 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2356 }
2357 break;
2358 case CODEC_TYPE_VIDEO:
2359 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2360 break;
2361 default:
2362 break;
2363 }
2364 return 0;
2365 }
2366
2367 static void truncate_ts(AVStream *st, AVPacket *pkt){
2368 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2369
2370 // if(pkt->dts < 0)
2371 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2372
2373 pkt->pts &= pts_mask;
2374 pkt->dts &= pts_mask;
2375 }
2376
2377 /**
2378 * Write a packet to an output media file.
2379 *
2380 * The packet shall contain one audio or video frame.
2381 *
2382 * @param s media file handle
2383 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2384 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2385 */
2386 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2387 {
2388 int ret;
2389
2390 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2391 if(ret<0)
2392 return ret;
2393
2394 truncate_ts(s->streams[pkt->stream_index], pkt);
2395
2396 ret= s->oformat->write_packet(s, pkt);
2397 if(!ret)
2398 ret= url_ferror(&s->pb);
2399 return ret;
2400 }
2401
2402 /**
2403 * interleave_packet implementation which will interleave per DTS.
2404 * packets with pkt->destruct == av_destruct_packet will be freed inside this function.
2405 * so they cannot be used after it, note calling av_free_packet() on them is still safe
2406 */
2407 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2408 AVPacketList *pktl, **next_point, *this_pktl;
2409 int stream_count=0;
2410 int streams[MAX_STREAMS];
2411
2412 if(pkt){
2413 AVStream *st= s->streams[ pkt->stream_index];
2414
2415 // assert(pkt->destruct != av_destruct_packet); //FIXME
2416
2417 this_pktl = av_mallocz(sizeof(AVPacketList));
2418 this_pktl->pkt= *pkt;
2419 if(pkt->destruct == av_destruct_packet)
2420 pkt->destruct= NULL; // non shared -> must keep original from being freed
2421 else
2422 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2423
2424 next_point = &s->packet_buffer;
2425 while(*next_point){
2426 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2427 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2428 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2429 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2430 break;
2431 next_point= &(*next_point)->next;
2432 }
2433 this_pktl->next= *next_point;
2434 *next_point= this_pktl;
2435 }
2436
2437 memset(streams, 0, sizeof(streams));
2438 pktl= s->packet_buffer;
2439 while(pktl){
2440 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2441 if(streams[ pktl->pkt.stream_index ] == 0)
2442 stream_count++;
2443 streams[ pktl->pkt.stream_index ]++;
2444 pktl= pktl->next;
2445 }
2446
2447 if(s->nb_streams == stream_count || (flush && stream_count)){
2448 pktl= s->packet_buffer;
2449 *out= pktl->pkt;
2450
2451 s->packet_buffer= pktl->next;
2452 av_freep(&pktl);
2453 return 1;
2454 }else{
2455 av_init_packet(out);
2456 return 0;
2457 }
2458 }
2459
2460 /**
2461 * Interleaves a AVPacket correctly so it can be muxed.
2462 * @param out the interleaved packet will be output here
2463 * @param in the input packet
2464 * @param flush 1 if no further packets are available as input and all
2465 * remaining packets should be output
2466 * @return 1 if a packet was output, 0 if no packet could be output,
2467 * < 0 if an error occured
2468 */
2469 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2470 if(s->oformat->interleave_packet)
2471 return s->oformat->interleave_packet(s, out, in, flush);
2472 else
2473 return av_interleave_packet_per_dts(s, out, in, flush);
2474 }
2475
2476 /**
2477 * Writes a packet to an output media file ensuring correct interleaving.
2478 *
2479 * The packet must contain one audio or video frame.
2480 * If the packets are already correctly interleaved the application should
2481 * call av_write_frame() instead as its slightly faster, its also important
2482 * to keep in mind that completly non interleaved input will need huge amounts
2483 * of memory to interleave with this, so its prefereable to interleave at the
2484 * demuxer level
2485 *
2486 * @param s media file handle
2487 * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2488 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2489 */
2490 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2491 AVStream *st= s->streams[ pkt->stream_index];
2492
2493 //FIXME/XXX/HACK drop zero sized packets
2494 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2495 return 0;
2496
2497 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %Ld %Ld\n", pkt->size, pkt->dts, pkt->pts);
2498 if(compute_pkt_fields2(st, pkt) < 0)
2499 return -1;
2500
2501 if(pkt->dts == AV_NOPTS_VALUE)
2502 return -1;
2503
2504 for(;;){
2505 AVPacket opkt;
2506 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2507 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2508 return ret;
2509
2510 truncate_ts(s->streams[opkt.stream_index], &opkt);
2511 ret= s->oformat->write_packet(s, &opkt);
2512
2513 av_free_packet(&opkt);
2514 pkt= NULL;
2515
2516 if(ret<0)
2517 return ret;
2518 if(url_ferror(&s->pb))
2519 return url_ferror(&s->pb);
2520 }
2521 }
2522
2523 /**
2524 * @brief Write the stream trailer to an output media file and
2525 * free the file private data.
2526 *
2527 * @param s media file handle
2528 * @return 0 if OK. AVERROR_xxx if error.
2529 */
2530 int av_write_trailer(AVFormatContext *s)
2531 {
2532 int ret, i;
2533
2534 for(;;){
2535 AVPacket pkt;
2536 ret= av_interleave_packet(s, &pkt, NULL, 1);
2537 if(ret<0) //FIXME cleanup needed for ret<0 ?
2538 goto fail;
2539 if(!ret)
2540 break;
2541
2542 truncate_ts(s->streams[pkt.stream_index], &pkt);
2543 ret= s->oformat->write_packet(s, &pkt);
2544
2545 av_free_packet(&pkt);
2546
2547 if(ret<0)
2548 goto fail;
2549 if(url_ferror(&s->pb))
2550 goto fail;
2551 }
2552
2553 if(s->oformat->write_trailer)
2554 ret = s->oformat->write_trailer(s);
2555 fail:
2556 if(ret == 0)
2557 ret=url_ferror(&s->pb);
2558 for(i=0;i<s->nb_streams;i++)
2559 av_freep(&s->streams[i]->priv_data);
2560 av_freep(&s->priv_data);
2561 return ret;
2562 }
2563
2564 /* "user interface" functions */
2565
2566 void dump_format(AVFormatContext *ic,
2567 int index,
2568 const char *url,
2569 int is_output)
2570 {
2571 int i, flags;
2572 char buf[256];
2573
2574 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2575 is_output ? "Output" : "Input",
2576 index,
2577 is_output ? ic->oformat->name : ic->iformat->name,
2578 is_output ? "to" : "from", url);
2579 if (!is_output) {
2580 av_log(NULL, AV_LOG_INFO, " Duration: ");
2581 if (ic->duration != AV_NOPTS_VALUE) {
2582 int hours, mins, secs, us;
2583 secs = ic->duration / AV_TIME_BASE;
2584 us = ic->duration % AV_TIME_BASE;
2585 mins = secs / 60;
2586 secs %= 60;
2587 hours = mins / 60;
2588 mins %= 60;
2589 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2590 (10 * us) / AV_TIME_BASE);
2591 } else {
2592 av_log(NULL, AV_LOG_INFO, "N/A");
2593 }
2594 if (ic->start_time != AV_NOPTS_VALUE) {
2595 int secs, us;
2596 av_log(NULL, AV_LOG_INFO, ", start: ");
2597 secs = ic->start_time / AV_TIME_BASE;
2598 us = ic->start_time % AV_TIME_BASE;
2599 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2600 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2601 }
2602 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2603 if (ic->bit_rate) {
2604 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2605 } else {
2606 av_log(NULL, AV_LOG_INFO, "N/A");
2607 }
2608 av_log(NULL, AV_LOG_INFO, "\n");
2609 }
2610 for(i=0;i<ic->nb_streams;i++) {
2611 AVStream *st = ic->streams[i];
2612 int g= ff_gcd(st->time_base.num, st->time_base.den);
2613 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2614 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2615 /* the pid is an important information, so we display it */
2616 /* XXX: add a generic system */
2617 if (is_output)
2618 flags = ic->oformat->flags;
2619 else
2620 flags = ic->iformat->flags;
2621 if (flags & AVFMT_SHOW_IDS) {
2622 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2623 }
2624 if (strlen(st->language) > 0) {
2625 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2626 }
2627 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2628 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2629 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2630 if(st->r_frame_rate.den && st->r_frame_rate.num)
2631 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2632 /* else if(st->time_base.den && st->time_base.num)
2633 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2634 else
2635 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2636 }
2637 av_log(NULL, AV_LOG_INFO, "\n");
2638 }
2639 }
2640
2641 typedef struct {
2642 const char *abv;
2643 int width, height;
2644 int frame_rate, frame_rate_base;
2645 } AbvEntry;
2646
2647 static AbvEntry frame_abvs[] = {
2648 { "ntsc", 720, 480, 30000, 1001 },
2649 { "pal", 720, 576, 25, 1 },
2650 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2651 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
2652 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
2653 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
2654 { "film", 352, 240, 24, 1 },
2655 { "ntsc-film", 352, 240, 24000, 1001 },
2656 { "sqcif", 128, 96, 0, 0 },
2657 { "qcif", 176, 144, 0, 0 },
2658 { "cif", 352, 288, 0, 0 },
2659 { "4cif", 704, 576, 0, 0 },
2660 };
2661
2662 /**
2663 * parses width and height out of string str.
2664 */
2665 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2666 {
2667 int i;
2668 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2669 const char *p;
2670 int frame_width = 0, frame_height = 0;
2671
2672 for(i=0;i<n;i++) {
2673 if (!strcmp(frame_abvs[i].abv, str)) {
2674 frame_width = frame_abvs[i].width;
2675 frame_height = frame_abvs[i].height;
2676 break;
2677 }
2678 }
2679 if (i == n) {
2680 p = str;
2681 frame_width = strtol(p, (char **)&p, 10);
2682 if (*p)
2683 p++;
2684 frame_height = strtol(p, (char **)&p, 10);
2685 }
2686 if (frame_width <= 0 || frame_height <= 0)
2687 return -1;
2688 *width_ptr = frame_width;
2689 *height_ptr = frame_height;
2690 return 0;
2691 }
2692
2693 /**
2694 * Converts frame rate from string to a fraction.
2695 *
2696 * First we try to get an exact integer or fractional frame rate.
2697 * If this fails we convert the frame rate to a double and return
2698 * an approximate fraction using the DEFAULT_FRAME_RATE_BASE.
2699 */
2700 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2701 {
2702 int i;
2703 char* cp;
2704
2705 /* First, we check our abbreviation table */
2706 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2707 if (!strcmp(frame_abvs[i].abv, arg)) {
2708 *frame_rate = frame_abvs[i].frame_rate;
2709 *frame_rate_base = frame_abvs[i].frame_rate_base;
2710 return 0;
2711 }
2712
2713 /* Then, we try to parse it as fraction */
2714 cp = strchr(arg, '/');
2715 if (!cp)
2716 cp = strchr(arg, ':');
2717 if (cp) {
2718 char* cpp;
2719 *frame_rate = strtol(arg, &cpp, 10);
2720 if (cpp != arg || cpp == cp)
2721 *frame_rate_base = strtol(cp+1, &cpp, 10);
2722 else
2723 *frame_rate = 0;
2724 }
2725 else {
2726 /* Finally we give up and parse it as double */
2727 AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2728 *frame_rate_base = time_base.den;
2729 *frame_rate = time_base.num;
2730 }
2731 if (!*frame_rate || !*frame_rate_base)
2732 return -1;
2733 else
2734 return 0;
2735 }
2736
2737 /**
2738 * Converts date string to number of seconds since Jan 1st, 1970.
2739 *
2740 * @code
2741 * Syntax:
2742 * - If not a duration:
2743 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2744 * Time is localtime unless Z is suffixed to the end. In this case GMT
2745 * Return the date in micro seconds since 1970
2746 *
2747 * - If a duration:
2748 * HH[:MM[:SS[.m...]]]
2749 * S+[.m...]
2750 * @endcode
2751 */
2752 #ifndef CONFIG_WINCE
2753 int64_t parse_date(const char *datestr, int duration)
2754 {
2755 const char *p;
2756 int64_t t;
2757 struct tm dt;
2758 int i;
2759 static const char *date_fmt[] = {
2760 "%Y-%m-%d",
2761 "%Y%m%d",
2762 };
2763 static const char *time_fmt[] = {
2764 "%H:%M:%S",
2765 "%H%M%S",
2766 };
2767 const char *q;
2768 int is_utc, len;
2769 char lastch;
2770 int negative = 0;
2771
2772 #undef time
2773 time_t now = time(0);
2774
2775 len = strlen(datestr);
2776 if (len > 0)
2777 lastch = datestr[len - 1];
2778 else
2779 lastch = '\0';
2780 is_utc = (lastch == 'z' || lastch == 'Z');
2781
2782 memset(&dt, 0, sizeof(dt));
2783
2784 p = datestr;
2785 q = NULL;
2786 if (!duration) {
2787 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2788 q = small_strptime(p, date_fmt[i], &dt);
2789 if (q) {
2790 break;
2791 }
2792 }
2793
2794 if (!q) {
2795 if (is_utc) {
2796 dt = *gmtime(&now);
2797 } else {
2798 dt = *localtime(&now);
2799 }
2800 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2801 } else {
2802 p = q;
2803 }
2804
2805 if (*p == 'T' || *p == 't' || *p == ' ')
2806 p++;
2807
2808 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2809 q = small_strptime(p, time_fmt[i], &dt);
2810 if (q) {
2811 break;
2812 }
2813 }
2814 } else {
2815 if (p[0] == '-') {
2816 negative = 1;
2817 ++p;
2818 }
2819 q = small_strptime(p, time_fmt[0], &dt);
2820 if (!q) {
2821 dt.tm_sec = strtol(p, (char **)&q, 10);
2822 dt.tm_min = 0;
2823 dt.tm_hour = 0;
2824 }
2825 }
2826
2827 /* Now we have all the fields that we can get */
2828 if (!q) {
2829 if (duration)
2830 return 0;
2831 else
2832 return now * int64_t_C(1000000);
2833 }
2834
2835 if (duration) {
2836 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2837 } else {
2838 dt.tm_isdst = -1; /* unknown */
2839 if (is_utc) {
2840 t = mktimegm(&dt);
2841 } else {
2842 t = mktime(&dt);
2843 }
2844 }
2845
2846 t *= 1000000;
2847
2848 if (*q == '.') {
2849 int val, n;
2850 q++;
2851 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2852 if (!isdigit(*q))
2853 break;
2854 val += n * (*q - '0');
2855 }
2856 t += val;
2857 }
2858 return negative ? -t : t;
2859 }
2860 #endif /* CONFIG_WINCE */
2861
2862 /**
2863 * Attempts to find a specific tag in a URL.
2864 *
2865 * syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done.
2866 * Return 1 if found.
2867 */
2868 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2869 {
2870 const char *p;
2871 char tag[128], *q;
2872
2873 p = info;
2874 if (*p == '?')
2875 p++;
2876 for(;;) {
2877 q = tag;
2878 while (*p != '\0' && *p != '=' && *p != '&') {
2879 if ((q - tag) < sizeof(tag) - 1)
2880 *q++ = *p;
2881 p++;
2882 }
2883 *q = '\0';
2884 q = arg;
2885 if (*p == '=') {
2886 p++;
2887 while (*p != '&' && *p != '\0') {
2888 if ((q - arg) < arg_size - 1) {
2889 if (*p == '+')
2890 *q++ = ' ';
2891 else
2892 *q++ = *p;
2893 }
2894 p++;
2895 }
2896 *q = '\0';
2897 }
2898 if (!strcmp(tag, tag1))
2899 return 1;
2900 if (*p != '&')
2901 break;
2902 p++;
2903 }
2904 return 0;
2905 }
2906
2907 /**
2908 * Returns in 'buf' the path with '%d' replaced by number.
2909 *
2910 * Also handles the '%0nd' format where 'n' is the total number
2911 * of digits and '%%'. Return 0 if OK, and -1 if format error.
2912 */
2913 int get_frame_filename(char *buf, int buf_size,
2914 const char *path, int number)
2915 {
2916 const char *p;
2917 char *q, buf1[20], c;
2918 int nd, len, percentd_found;
2919
2920 q = buf;
2921 p = path;
2922 percentd_found = 0;
2923 for(;;) {
2924 c = *p++;
2925 if (c == '\0')
2926 break;
2927 if (c == '%') {
2928 do {
2929 nd = 0;
2930 while (isdigit(*p)) {
2931 nd = nd * 10 + *p++ - '0';
2932 }
2933 c = *p++;
2934 } while (isdigit(c));
2935
2936 switch(c) {
2937 case '%':
2938 goto addchar;
2939 case 'd':
2940 if (percentd_found)
2941 goto fail;
2942 percentd_found = 1;
2943 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2944 len = strlen(buf1);
2945 if ((q - buf + len) > buf_size - 1)
2946 goto fail;
2947 memcpy(q, buf1, len);
2948 q += len;
2949 break;
2950 default:
2951 goto fail;
2952 }
2953 } else {
2954 addchar:
2955 if ((q - buf) < buf_size - 1)
2956 *q++ = c;
2957 }
2958 }
2959 if (!percentd_found)
2960 goto fail;
2961 *q = '\0';
2962 return 0;
2963 fail:
2964 *q = '\0';
2965 return -1;
2966 }
2967
2968 /**
2969 * Print nice hexa dump of a buffer
2970 * @param f stream for output
2971 * @param buf buffer
2972 * @param size buffer size
2973 */
2974 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2975 {
2976 int len, i, j, c;
2977
2978 for(i=0;i<size;i+=16) {
2979 len = size - i;
2980 if (len > 16)
2981 len = 16;
2982 fprintf(f, "%08x ", i);
2983 for(j=0;j<16;j++) {
2984 if (j < len)
2985 fprintf(f, " %02x", buf[i+j]);
2986 else
2987 fprintf(f, " ");
2988 }
2989 fprintf(f, " ");
2990 for(j=0;j<len;j++) {
2991 c = buf[i+j];
2992 if (c < ' ' || c > '~')
2993 c = '.';
2994 fprintf(f, "%c", c);
2995 }
2996 fprintf(f, "\n");
2997 }
2998 }
2999
3000 /**
3001 * Print on 'f' a nice dump of a packet
3002 * @param f stream for output
3003 * @param pkt packet to dump
3004 * @param dump_payload true if the payload must be displayed too
3005 */
3006 //FIXME needs to know the time_base
3007 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3008 {
3009 fprintf(f, "stream #%d:\n", pkt->stream_index);
3010 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3011 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3012 /* DTS is _always_ valid after av_read_frame() */
3013 fprintf(f, " dts=");
3014 if (pkt->dts == AV_NOPTS_VALUE)
3015 fprintf(f, "N/A");
3016 else
3017 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
3018 /* PTS may be not known if B frames are present */
3019 fprintf(f, " pts=");
3020 if (pkt->pts == AV_NOPTS_VALUE)
3021 fprintf(f, "N/A");
3022 else
3023 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
3024 fprintf(f, "\n");
3025 fprintf(f, " size=%d\n", pkt->size);
3026 if (dump_payload)
3027 av_hex_dump(f, pkt->data, pkt->size);
3028 }
3029
3030 void url_split(char *proto, int proto_size,
3031 char *authorization, int authorization_size,
3032 char *hostname, int hostname_size,
3033 int *port_ptr,
3034 char *path, int path_size,
3035 const char *url)
3036 {
3037 const char *p;
3038 char *q;
3039 int port;
3040
3041 port = -1;
3042
3043 p = url;
3044 q = proto;
3045 while (*p != ':' && *p != '\0') {
3046 if ((q - proto) < proto_size - 1)
3047 *q++ = *p;
3048 p++;
3049 }
3050 if (proto_size > 0)
3051 *q = '\0';
3052 if (authorization_size > 0)
3053 authorization[0] = '\0';
3054 if (*p == '\0') {
3055 if (proto_size > 0)
3056 proto[0] = '\0';
3057 if (hostname_size > 0)
3058 hostname[0] = '\0';
3059 p = url;
3060 } else {
3061 char *at,*slash; // PETR: position of '@' character and '/' character
3062
3063 p++;
3064 if (*p == '/')
3065 p++;
3066 if (*p == '/')
3067 p++;
3068 at = strchr(p,'@'); // PETR: get the position of '@'
3069 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
3070 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
3071
3072 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
3073
3074 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
3075 if (*p == '@') { // PETR: passed '@'
3076 if (authorization_size > 0)
3077 *q = '\0';
3078 q = hostname;
3079 at = NULL;
3080 } else if (!at) { // PETR: hostname
3081 if ((q - hostname) < hostname_size - 1)
3082 *q++ = *p;
3083 } else {
3084 if ((q - authorization) < authorization_size - 1)
3085 *q++ = *p;
3086 }
3087 p++;
3088 }
3089 if (hostname_size > 0)
3090 *q = '\0';
3091 if (*p == ':') {
3092 p++;
3093 port = strtoul(p, (char **)&p, 10);
3094 }
3095 }
3096 if (port_ptr)
3097 *port_ptr = port;
3098 pstrcpy(path, path_size, p);
3099 }
3100
3101 /**
3102 * Set the pts for a given stream.
3103 *
3104 * @param s stream
3105 * @param pts_wrap_bits number of bits effectively used by the pts
3106 * (used for wrap control, 33 is the value for MPEG)
3107 * @param pts_num numerator to convert to seconds (MPEG: 1)
3108 * @param pts_den denominator to convert to seconds (MPEG: 90000)
3109 */
3110 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3111 int pts_num, int pts_den)
3112 {
3113 s->pts_wrap_bits = pts_wrap_bits;
3114 s->time_base.num = pts_num;
3115 s->time_base.den = pts_den;
3116 }
3117
3118 /* fraction handling */
3119
3120 /**
3121 * f = val + (num / den) + 0.5.
3122 *
3123 * 'num' is normalized so that it is such as 0 <= num < den.
3124 *
3125 * @param f fractional number
3126 * @param val integer value
3127 * @param num must be >= 0
3128 * @param den must be >= 1
3129 */
3130 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3131 {
3132 num += (den >> 1);
3133 if (num >= den) {
3134 val += num / den;
3135 num = num % den;
3136 }
3137 f->val = val;
3138 f->num = num;
3139 f->den = den;
3140 }
3141
3142 /**
3143 * Set f to (val + 0.5).
3144 */
3145 static void av_frac_set(AVFrac *f, int64_t val)
3146 {
3147 f->val = val;
3148 f->num = f->den >> 1;
3149 }
3150
3151 /**
3152 * Fractionnal addition to f: f = f + (incr / f->den).
3153 *
3154 * @param f fractional number
3155 * @param incr increment, can be positive or negative
3156 */
3157 static void av_frac_add(AVFrac *f, int64_t incr)
3158 {
3159 int64_t num, den;
3160
3161 num = f->num + incr;
3162 den = f->den;
3163 if (num < 0) {
3164 f->val += num / den;
3165 num = num % den;
3166 if (num < 0) {
3167 num += den;
3168 f->val--;
3169 }
3170 } else if (num >= den) {
3171 f->val += num / den;
3172 num = num % den;
3173 }
3174 f->num = num;
3175 }
3176
3177 /**
3178 * register a new image format
3179 * @param img_fmt Image format descriptor
3180 */
3181 void av_register_image_format(AVImageFormat *img_fmt)
3182 {
3183 AVImageFormat **p;
3184
3185 p = &first_image_format;
3186 while (*p != NULL) p = &(*p)->next;
3187 *p = img_fmt;
3188 img_fmt->next = NULL;
3189 }
3190
3191 /**
3192 * Guesses image format based on data in the image.
3193 */
3194 AVImageFormat *av_probe_image_format(AVProbeData *pd)
3195 {
3196 AVImageFormat *fmt1, *fmt;
3197 int score, score_max;
3198
3199 fmt = NULL;
3200 score_max = 0;
3201 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3202 if (fmt1->img_probe) {
3203 score = fmt1->img_probe(pd);
3204 if (score > score_max) {
3205 score_max = score;
3206 fmt = fmt1;
3207 }
3208 }
3209 }
3210 return fmt;
3211 }
3212
3213 /**
3214 * Guesses image format based on file name extensions.
3215 */
3216 AVImageFormat *guess_image_format(const char *filename)
3217 {
3218 AVImageFormat *fmt1;
3219
3220 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
3221 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
3222 return fmt1;
3223 }
3224 return NULL;
3225 }
3226
3227 /**
3228 * Read an image from a stream.
3229 * @param gb byte stream containing the image
3230 * @param fmt image format, NULL if probing is required
3231 */
3232 int av_read_image(ByteIOContext *pb, const char *filename,
3233 AVImageFormat *fmt,
3234 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
3235 {
3236 uint8_t buf[PROBE_BUF_MIN];
3237 AVProbeData probe_data, *pd = &probe_data;
3238 offset_t pos;
3239 int ret;
3240
3241 if (!fmt) {
3242 pd->filename = filename;
3243 pd->buf = buf;
3244 pos = url_ftell(pb);
3245 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_MIN);
3246 url_fseek(pb, pos, SEEK_SET);
3247 fmt = av_probe_image_format(pd);
3248 }
3249 if (!fmt)
3250 return AVERROR_NOFMT;
3251 ret = fmt->img_read(pb, alloc_cb, opaque);
3252 return ret;
3253 }
3254
3255 /**
3256 * Write an image to a stream.
3257 * @param pb byte stream for the image output
3258 * @param fmt image format
3259 * @param img image data and informations
3260 */
3261 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
3262 {
3263 return fmt->img_write(pb, img);
3264 }
3265