lavf: Detect discontinuities in timestamps for framerate/analyzeduration calculation
[libav.git] / libavformat / utils.c
1 /*
2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 /* #define DEBUG */
23
24 #include "avformat.h"
25 #include "avio_internal.h"
26 #include "internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/bytestream.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/pixdesc.h"
32 #include "metadata.h"
33 #include "id3v2.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/time.h"
39 #include "riff.h"
40 #include "audiointerleave.h"
41 #include "url.h"
42 #include <stdarg.h>
43 #if CONFIG_NETWORK
44 #include "network.h"
45 #endif
46
47 #undef NDEBUG
48 #include <assert.h>
49
50 /**
51 * @file
52 * various utility functions for use within Libav
53 */
54
55 unsigned avformat_version(void)
56 {
57 return LIBAVFORMAT_VERSION_INT;
58 }
59
60 const char *avformat_configuration(void)
61 {
62 return LIBAV_CONFIGURATION;
63 }
64
65 const char *avformat_license(void)
66 {
67 #define LICENSE_PREFIX "libavformat license: "
68 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
69 }
70
71 /* fraction handling */
72
73 /**
74 * f = val + (num / den) + 0.5.
75 *
76 * 'num' is normalized so that it is such as 0 <= num < den.
77 *
78 * @param f fractional number
79 * @param val integer value
80 * @param num must be >= 0
81 * @param den must be >= 1
82 */
83 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
84 {
85 num += (den >> 1);
86 if (num >= den) {
87 val += num / den;
88 num = num % den;
89 }
90 f->val = val;
91 f->num = num;
92 f->den = den;
93 }
94
95 /**
96 * Fractional addition to f: f = f + (incr / f->den).
97 *
98 * @param f fractional number
99 * @param incr increment, can be positive or negative
100 */
101 static void frac_add(AVFrac *f, int64_t incr)
102 {
103 int64_t num, den;
104
105 num = f->num + incr;
106 den = f->den;
107 if (num < 0) {
108 f->val += num / den;
109 num = num % den;
110 if (num < 0) {
111 num += den;
112 f->val--;
113 }
114 } else if (num >= den) {
115 f->val += num / den;
116 num = num % den;
117 }
118 f->num = num;
119 }
120
121 /** head of registered input format linked list */
122 static AVInputFormat *first_iformat = NULL;
123 /** head of registered output format linked list */
124 static AVOutputFormat *first_oformat = NULL;
125
126 AVInputFormat *av_iformat_next(AVInputFormat *f)
127 {
128 if(f) return f->next;
129 else return first_iformat;
130 }
131
132 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
133 {
134 if(f) return f->next;
135 else return first_oformat;
136 }
137
138 void av_register_input_format(AVInputFormat *format)
139 {
140 AVInputFormat **p;
141 p = &first_iformat;
142 while (*p != NULL) p = &(*p)->next;
143 *p = format;
144 format->next = NULL;
145 }
146
147 void av_register_output_format(AVOutputFormat *format)
148 {
149 AVOutputFormat **p;
150 p = &first_oformat;
151 while (*p != NULL) p = &(*p)->next;
152 *p = format;
153 format->next = NULL;
154 }
155
156 int av_match_ext(const char *filename, const char *extensions)
157 {
158 const char *ext, *p;
159 char ext1[32], *q;
160
161 if(!filename)
162 return 0;
163
164 ext = strrchr(filename, '.');
165 if (ext) {
166 ext++;
167 p = extensions;
168 for(;;) {
169 q = ext1;
170 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
171 *q++ = *p++;
172 *q = '\0';
173 if (!av_strcasecmp(ext1, ext))
174 return 1;
175 if (*p == '\0')
176 break;
177 p++;
178 }
179 }
180 return 0;
181 }
182
183 static int match_format(const char *name, const char *names)
184 {
185 const char *p;
186 int len, namelen;
187
188 if (!name || !names)
189 return 0;
190
191 namelen = strlen(name);
192 while ((p = strchr(names, ','))) {
193 len = FFMAX(p - names, namelen);
194 if (!av_strncasecmp(name, names, len))
195 return 1;
196 names = p+1;
197 }
198 return !av_strcasecmp(name, names);
199 }
200
201 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
202 const char *mime_type)
203 {
204 AVOutputFormat *fmt = NULL, *fmt_found;
205 int score_max, score;
206
207 /* specific test for image sequences */
208 #if CONFIG_IMAGE2_MUXER
209 if (!short_name && filename &&
210 av_filename_number_test(filename) &&
211 ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
212 return av_guess_format("image2", NULL, NULL);
213 }
214 #endif
215 /* Find the proper file type. */
216 fmt_found = NULL;
217 score_max = 0;
218 while ((fmt = av_oformat_next(fmt))) {
219 score = 0;
220 if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
221 score += 100;
222 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223 score += 10;
224 if (filename && fmt->extensions &&
225 av_match_ext(filename, fmt->extensions)) {
226 score += 5;
227 }
228 if (score > score_max) {
229 score_max = score;
230 fmt_found = fmt;
231 }
232 }
233 return fmt_found;
234 }
235
236 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
237 const char *filename, const char *mime_type, enum AVMediaType type){
238 if(type == AVMEDIA_TYPE_VIDEO){
239 enum AVCodecID codec_id= AV_CODEC_ID_NONE;
240
241 #if CONFIG_IMAGE2_MUXER
242 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
243 codec_id= ff_guess_image2_codec(filename);
244 }
245 #endif
246 if(codec_id == AV_CODEC_ID_NONE)
247 codec_id= fmt->video_codec;
248 return codec_id;
249 }else if(type == AVMEDIA_TYPE_AUDIO)
250 return fmt->audio_codec;
251 else if (type == AVMEDIA_TYPE_SUBTITLE)
252 return fmt->subtitle_codec;
253 else
254 return AV_CODEC_ID_NONE;
255 }
256
257 AVInputFormat *av_find_input_format(const char *short_name)
258 {
259 AVInputFormat *fmt = NULL;
260 while ((fmt = av_iformat_next(fmt))) {
261 if (match_format(short_name, fmt->name))
262 return fmt;
263 }
264 return NULL;
265 }
266
267
268 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
269 {
270 int ret= av_new_packet(pkt, size);
271
272 if(ret<0)
273 return ret;
274
275 pkt->pos= avio_tell(s);
276
277 ret= avio_read(s, pkt->data, size);
278 if(ret<=0)
279 av_free_packet(pkt);
280 else
281 av_shrink_packet(pkt, ret);
282
283 return ret;
284 }
285
286 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
287 {
288 int ret;
289 int old_size;
290 if (!pkt->size)
291 return av_get_packet(s, pkt, size);
292 old_size = pkt->size;
293 ret = av_grow_packet(pkt, size);
294 if (ret < 0)
295 return ret;
296 ret = avio_read(s, pkt->data + old_size, size);
297 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
298 return ret;
299 }
300
301
302 int av_filename_number_test(const char *filename)
303 {
304 char buf[1024];
305 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
306 }
307
308 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
309 {
310 AVProbeData lpd = *pd;
311 AVInputFormat *fmt1 = NULL, *fmt;
312 int score, id3 = 0;
313
314 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
315 int id3len = ff_id3v2_tag_len(lpd.buf);
316 if (lpd.buf_size > id3len + 16) {
317 lpd.buf += id3len;
318 lpd.buf_size -= id3len;
319 }
320 id3 = 1;
321 }
322
323 fmt = NULL;
324 while ((fmt1 = av_iformat_next(fmt1))) {
325 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
326 continue;
327 score = 0;
328 if (fmt1->read_probe) {
329 score = fmt1->read_probe(&lpd);
330 } else if (fmt1->extensions) {
331 if (av_match_ext(lpd.filename, fmt1->extensions)) {
332 score = 50;
333 }
334 }
335 if (score > *score_max) {
336 *score_max = score;
337 fmt = fmt1;
338 }else if (score == *score_max)
339 fmt = NULL;
340 }
341
342 /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
343 if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
344 while ((fmt = av_iformat_next(fmt)))
345 if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
346 *score_max = AVPROBE_SCORE_MAX/4;
347 break;
348 }
349 }
350
351 if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
352 while ((fmt = av_iformat_next(fmt)))
353 if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
354 *score_max = AVPROBE_SCORE_MAX/4-1;
355 break;
356 }
357 }
358
359 return fmt;
360 }
361
362 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
363 int score=0;
364 return av_probe_input_format2(pd, is_opened, &score);
365 }
366
367 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
368 {
369 static const struct {
370 const char *name; enum AVCodecID id; enum AVMediaType type;
371 } fmt_id_type[] = {
372 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
373 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
374 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
375 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
376 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
377 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
378 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
379 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
380 { 0 }
381 };
382 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
383
384 if (fmt) {
385 int i;
386 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
387 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
388 for (i = 0; fmt_id_type[i].name; i++) {
389 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
390 st->codec->codec_id = fmt_id_type[i].id;
391 st->codec->codec_type = fmt_id_type[i].type;
392 break;
393 }
394 }
395 }
396 return !!fmt;
397 }
398
399 /************************************************************/
400 /* input media file */
401
402 /** size of probe buffer, for guessing file type from file contents */
403 #define PROBE_BUF_MIN 2048
404 #define PROBE_BUF_MAX (1<<20)
405
406 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
407 const char *filename, void *logctx,
408 unsigned int offset, unsigned int max_probe_size)
409 {
410 AVProbeData pd = { filename ? filename : "", NULL, -offset };
411 unsigned char *buf = NULL;
412 int ret = 0, probe_size;
413
414 if (!max_probe_size) {
415 max_probe_size = PROBE_BUF_MAX;
416 } else if (max_probe_size > PROBE_BUF_MAX) {
417 max_probe_size = PROBE_BUF_MAX;
418 } else if (max_probe_size < PROBE_BUF_MIN) {
419 return AVERROR(EINVAL);
420 }
421
422 if (offset >= max_probe_size) {
423 return AVERROR(EINVAL);
424 }
425
426 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
427 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
428 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
429 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
430
431 if (probe_size < offset) {
432 continue;
433 }
434
435 /* read probe data */
436 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
437 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
438 /* fail if error was not end of file, otherwise, lower score */
439 if (ret != AVERROR_EOF) {
440 av_free(buf);
441 return ret;
442 }
443 score = 0;
444 ret = 0; /* error was end of file, nothing read */
445 }
446 pd.buf_size += ret;
447 pd.buf = &buf[offset];
448
449 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
450
451 /* guess file format */
452 *fmt = av_probe_input_format2(&pd, 1, &score);
453 if(*fmt){
454 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
455 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
456 }else
457 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
458 }
459 }
460
461 if (!*fmt) {
462 av_free(buf);
463 return AVERROR_INVALIDDATA;
464 }
465
466 /* rewind. reuse probe buffer to avoid seeking */
467 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
468 av_free(buf);
469
470 return ret;
471 }
472
473 /* open input file and probe the format if necessary */
474 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
475 {
476 int ret;
477 AVProbeData pd = {filename, NULL, 0};
478
479 if (s->pb) {
480 s->flags |= AVFMT_FLAG_CUSTOM_IO;
481 if (!s->iformat)
482 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
483 else if (s->iformat->flags & AVFMT_NOFILE)
484 return AVERROR(EINVAL);
485 return 0;
486 }
487
488 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
489 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
490 return 0;
491
492 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
493 &s->interrupt_callback, options)) < 0)
494 return ret;
495 if (s->iformat)
496 return 0;
497 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
498 }
499
500 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
501 AVPacketList **plast_pktl){
502 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
503 if (!pktl)
504 return NULL;
505
506 if (*packet_buffer)
507 (*plast_pktl)->next = pktl;
508 else
509 *packet_buffer = pktl;
510
511 /* add the packet in the buffered packet list */
512 *plast_pktl = pktl;
513 pktl->pkt= *pkt;
514 return &pktl->pkt;
515 }
516
517 static void queue_attached_pictures(AVFormatContext *s)
518 {
519 int i;
520 for (i = 0; i < s->nb_streams; i++)
521 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
522 s->streams[i]->discard < AVDISCARD_ALL) {
523 AVPacket copy = s->streams[i]->attached_pic;
524 copy.destruct = NULL;
525 add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
526 }
527 }
528
529 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
530 {
531 AVFormatContext *s = *ps;
532 int ret = 0;
533 AVDictionary *tmp = NULL;
534 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
535
536 if (!s && !(s = avformat_alloc_context()))
537 return AVERROR(ENOMEM);
538 if (fmt)
539 s->iformat = fmt;
540
541 if (options)
542 av_dict_copy(&tmp, *options, 0);
543
544 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
545 goto fail;
546
547 if ((ret = init_input(s, filename, &tmp)) < 0)
548 goto fail;
549
550 /* check filename in case an image number is expected */
551 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
552 if (!av_filename_number_test(filename)) {
553 ret = AVERROR(EINVAL);
554 goto fail;
555 }
556 }
557
558 s->duration = s->start_time = AV_NOPTS_VALUE;
559 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
560
561 /* allocate private data */
562 if (s->iformat->priv_data_size > 0) {
563 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
564 ret = AVERROR(ENOMEM);
565 goto fail;
566 }
567 if (s->iformat->priv_class) {
568 *(const AVClass**)s->priv_data = s->iformat->priv_class;
569 av_opt_set_defaults(s->priv_data);
570 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
571 goto fail;
572 }
573 }
574
575 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
576 if (s->pb)
577 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
578
579 if (s->iformat->read_header)
580 if ((ret = s->iformat->read_header(s)) < 0)
581 goto fail;
582
583 if (id3v2_extra_meta &&
584 (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
585 goto fail;
586 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
587
588 queue_attached_pictures(s);
589
590 if (s->pb && !s->data_offset)
591 s->data_offset = avio_tell(s->pb);
592
593 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
594
595 if (options) {
596 av_dict_free(options);
597 *options = tmp;
598 }
599 *ps = s;
600 return 0;
601
602 fail:
603 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
604 av_dict_free(&tmp);
605 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
606 avio_close(s->pb);
607 avformat_free_context(s);
608 *ps = NULL;
609 return ret;
610 }
611
612 /*******************************************************/
613
614 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
615 {
616 if(st->codec->codec_id == AV_CODEC_ID_PROBE){
617 AVProbeData *pd = &st->probe_data;
618 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
619 --st->probe_packets;
620
621 if (pkt) {
622 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
623 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
624 pd->buf_size += pkt->size;
625 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
626 } else {
627 st->probe_packets = 0;
628 }
629
630 if (!st->probe_packets ||
631 av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
632 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
633 if(st->codec->codec_id != AV_CODEC_ID_PROBE){
634 pd->buf_size=0;
635 av_freep(&pd->buf);
636 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
637 }
638 }
639 }
640 }
641
642 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
643 {
644 int ret, i;
645 AVStream *st;
646
647 for(;;){
648 AVPacketList *pktl = s->raw_packet_buffer;
649
650 if (pktl) {
651 *pkt = pktl->pkt;
652 st = s->streams[pkt->stream_index];
653 if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
654 s->raw_packet_buffer_remaining_size < pkt->size) {
655 AVProbeData *pd;
656 if (st->probe_packets) {
657 probe_codec(s, st, NULL);
658 }
659 pd = &st->probe_data;
660 av_freep(&pd->buf);
661 pd->buf_size = 0;
662 s->raw_packet_buffer = pktl->next;
663 s->raw_packet_buffer_remaining_size += pkt->size;
664 av_free(pktl);
665 return 0;
666 }
667 }
668
669 av_init_packet(pkt);
670 ret= s->iformat->read_packet(s, pkt);
671 if (ret < 0) {
672 if (!pktl || ret == AVERROR(EAGAIN))
673 return ret;
674 for (i = 0; i < s->nb_streams; i++) {
675 st = s->streams[i];
676 if (st->probe_packets) {
677 probe_codec(s, st, NULL);
678 }
679 }
680 continue;
681 }
682
683 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
684 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
685 av_log(s, AV_LOG_WARNING,
686 "Dropped corrupted packet (stream = %d)\n",
687 pkt->stream_index);
688 av_free_packet(pkt);
689 continue;
690 }
691
692 st= s->streams[pkt->stream_index];
693
694 switch(st->codec->codec_type){
695 case AVMEDIA_TYPE_VIDEO:
696 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
697 break;
698 case AVMEDIA_TYPE_AUDIO:
699 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
700 break;
701 case AVMEDIA_TYPE_SUBTITLE:
702 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
703 break;
704 }
705
706 if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
707 !st->probe_packets))
708 return ret;
709
710 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
711 s->raw_packet_buffer_remaining_size -= pkt->size;
712
713 probe_codec(s, st, pkt);
714 }
715 }
716
717 #if FF_API_READ_PACKET
718 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
719 {
720 return ff_read_packet(s, pkt);
721 }
722 #endif
723
724
725 /**********************************************************/
726
727 /**
728 * Get the number of samples of an audio frame. Return -1 on error.
729 */
730 static int get_audio_frame_size(AVCodecContext *enc, int size, int mux)
731 {
732 int frame_size;
733
734 /* give frame_size priority if demuxing */
735 if (!mux && enc->frame_size > 1)
736 return enc->frame_size;
737
738 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
739 return frame_size;
740
741 /* fallback to using frame_size if muxing */
742 if (enc->frame_size > 1)
743 return enc->frame_size;
744
745 return -1;
746 }
747
748
749 /**
750 * Return the frame duration in seconds. Return 0 if not available.
751 */
752 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
753 AVCodecParserContext *pc, AVPacket *pkt)
754 {
755 int frame_size;
756
757 *pnum = 0;
758 *pden = 0;
759 switch(st->codec->codec_type) {
760 case AVMEDIA_TYPE_VIDEO:
761 if (st->avg_frame_rate.num) {
762 *pnum = st->avg_frame_rate.den;
763 *pden = st->avg_frame_rate.num;
764 } else if(st->time_base.num*1000LL > st->time_base.den) {
765 *pnum = st->time_base.num;
766 *pden = st->time_base.den;
767 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
768 *pnum = st->codec->time_base.num;
769 *pden = st->codec->time_base.den;
770 if (pc && pc->repeat_pict) {
771 *pnum = (*pnum) * (1 + pc->repeat_pict);
772 }
773 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
774 //Thus if we have no parser in such case leave duration undefined.
775 if(st->codec->ticks_per_frame>1 && !pc){
776 *pnum = *pden = 0;
777 }
778 }
779 break;
780 case AVMEDIA_TYPE_AUDIO:
781 frame_size = get_audio_frame_size(st->codec, pkt->size, 0);
782 if (frame_size <= 0 || st->codec->sample_rate <= 0)
783 break;
784 *pnum = frame_size;
785 *pden = st->codec->sample_rate;
786 break;
787 default:
788 break;
789 }
790 }
791
792 static int is_intra_only(enum AVCodecID id)
793 {
794 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
795 if (!d)
796 return 0;
797 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
798 return 0;
799 return 1;
800 }
801
802 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
803 int64_t dts, int64_t pts)
804 {
805 AVStream *st= s->streams[stream_index];
806 AVPacketList *pktl= s->packet_buffer;
807
808 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
809 return;
810
811 st->first_dts= dts - st->cur_dts;
812 st->cur_dts= dts;
813
814 for(; pktl; pktl= pktl->next){
815 if(pktl->pkt.stream_index != stream_index)
816 continue;
817 //FIXME think more about this check
818 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
819 pktl->pkt.pts += st->first_dts;
820
821 if(pktl->pkt.dts != AV_NOPTS_VALUE)
822 pktl->pkt.dts += st->first_dts;
823
824 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
825 st->start_time= pktl->pkt.pts;
826 }
827 if (st->start_time == AV_NOPTS_VALUE)
828 st->start_time = pts;
829 }
830
831 static void update_initial_durations(AVFormatContext *s, AVStream *st,
832 int stream_index, int duration)
833 {
834 AVPacketList *pktl= s->packet_buffer;
835 int64_t cur_dts= 0;
836
837 if(st->first_dts != AV_NOPTS_VALUE){
838 cur_dts= st->first_dts;
839 for(; pktl; pktl= pktl->next){
840 if(pktl->pkt.stream_index == stream_index){
841 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
842 break;
843 cur_dts -= duration;
844 }
845 }
846 pktl= s->packet_buffer;
847 st->first_dts = cur_dts;
848 }else if(st->cur_dts)
849 return;
850
851 for(; pktl; pktl= pktl->next){
852 if(pktl->pkt.stream_index != stream_index)
853 continue;
854 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
855 && !pktl->pkt.duration){
856 pktl->pkt.dts= cur_dts;
857 if(!st->codec->has_b_frames)
858 pktl->pkt.pts= cur_dts;
859 cur_dts += duration;
860 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
861 pktl->pkt.duration = duration;
862 }else
863 break;
864 }
865 if(st->first_dts == AV_NOPTS_VALUE)
866 st->cur_dts= cur_dts;
867 }
868
869 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
870 AVCodecParserContext *pc, AVPacket *pkt)
871 {
872 int num, den, presentation_delayed, delay, i;
873 int64_t offset;
874
875 if (s->flags & AVFMT_FLAG_NOFILLIN)
876 return;
877
878 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
879 pkt->dts= AV_NOPTS_VALUE;
880
881 /* do we have a video B-frame ? */
882 delay= st->codec->has_b_frames;
883 presentation_delayed = 0;
884
885 /* XXX: need has_b_frame, but cannot get it if the codec is
886 not initialized */
887 if (delay &&
888 pc && pc->pict_type != AV_PICTURE_TYPE_B)
889 presentation_delayed = 1;
890
891 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
892 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
893 pkt->dts -= 1LL<<st->pts_wrap_bits;
894 }
895
896 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
897 // we take the conservative approach and discard both
898 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
899 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
900 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
901 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
902 }
903
904 if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
905 compute_frame_duration(&num, &den, st, pc, pkt);
906 if (den && num) {
907 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
908
909 if(pkt->duration != 0 && s->packet_buffer)
910 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
911 }
912 }
913
914 /* correct timestamps with byte offset if demuxers only have timestamps
915 on packet boundaries */
916 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
917 /* this will estimate bitrate based on this frame's duration and size */
918 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
919 if(pkt->pts != AV_NOPTS_VALUE)
920 pkt->pts += offset;
921 if(pkt->dts != AV_NOPTS_VALUE)
922 pkt->dts += offset;
923 }
924
925 if (pc && pc->dts_sync_point >= 0) {
926 // we have synchronization info from the parser
927 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
928 if (den > 0) {
929 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
930 if (pkt->dts != AV_NOPTS_VALUE) {
931 // got DTS from the stream, update reference timestamp
932 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
933 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
934 } else if (st->reference_dts != AV_NOPTS_VALUE) {
935 // compute DTS based on reference timestamp
936 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
937 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
938 }
939 if (pc->dts_sync_point > 0)
940 st->reference_dts = pkt->dts; // new reference
941 }
942 }
943
944 /* This may be redundant, but it should not hurt. */
945 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
946 presentation_delayed = 1;
947
948 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
949 /* interpolate PTS and DTS if they are not present */
950 //We skip H264 currently because delay and has_b_frames are not reliably set
951 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
952 if (presentation_delayed) {
953 /* DTS = decompression timestamp */
954 /* PTS = presentation timestamp */
955 if (pkt->dts == AV_NOPTS_VALUE)
956 pkt->dts = st->last_IP_pts;
957 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
958 if (pkt->dts == AV_NOPTS_VALUE)
959 pkt->dts = st->cur_dts;
960
961 /* this is tricky: the dts must be incremented by the duration
962 of the frame we are displaying, i.e. the last I- or P-frame */
963 if (st->last_IP_duration == 0)
964 st->last_IP_duration = pkt->duration;
965 if(pkt->dts != AV_NOPTS_VALUE)
966 st->cur_dts = pkt->dts + st->last_IP_duration;
967 st->last_IP_duration = pkt->duration;
968 st->last_IP_pts= pkt->pts;
969 /* cannot compute PTS if not present (we can compute it only
970 by knowing the future */
971 } else if (pkt->pts != AV_NOPTS_VALUE ||
972 pkt->dts != AV_NOPTS_VALUE ||
973 pkt->duration ||
974 st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
975 int duration = pkt->duration;
976 if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
977 compute_frame_duration(&num, &den, st, pc, pkt);
978 if (den && num) {
979 duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
980 den * (int64_t)st->time_base.num,
981 AV_ROUND_DOWN);
982 if (duration != 0 && s->packet_buffer) {
983 update_initial_durations(s, st, pkt->stream_index,
984 duration);
985 }
986 }
987 }
988
989 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
990 duration) {
991 /* presentation is not delayed : PTS and DTS are the same */
992 if (pkt->pts == AV_NOPTS_VALUE)
993 pkt->pts = pkt->dts;
994 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
995 pkt->pts);
996 if (pkt->pts == AV_NOPTS_VALUE)
997 pkt->pts = st->cur_dts;
998 pkt->dts = pkt->pts;
999 if (pkt->pts != AV_NOPTS_VALUE)
1000 st->cur_dts = pkt->pts + duration;
1001 }
1002 }
1003 }
1004
1005 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1006 st->pts_buffer[0]= pkt->pts;
1007 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1008 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1009 if(pkt->dts == AV_NOPTS_VALUE)
1010 pkt->dts= st->pts_buffer[0];
1011 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1012 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1013 }
1014 if(pkt->dts > st->cur_dts)
1015 st->cur_dts = pkt->dts;
1016 }
1017
1018 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1019
1020 /* update flags */
1021 if (is_intra_only(st->codec->codec_id))
1022 pkt->flags |= AV_PKT_FLAG_KEY;
1023 if (pc)
1024 pkt->convergence_duration = pc->convergence_duration;
1025 }
1026
1027 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1028 {
1029 while (*pkt_buf) {
1030 AVPacketList *pktl = *pkt_buf;
1031 *pkt_buf = pktl->next;
1032 av_free_packet(&pktl->pkt);
1033 av_freep(&pktl);
1034 }
1035 *pkt_buf_end = NULL;
1036 }
1037
1038 /**
1039 * Parse a packet, add all split parts to parse_queue
1040 *
1041 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1042 */
1043 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1044 {
1045 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1046 AVStream *st = s->streams[stream_index];
1047 uint8_t *data = pkt ? pkt->data : NULL;
1048 int size = pkt ? pkt->size : 0;
1049 int ret = 0, got_output = 0;
1050
1051 if (!pkt) {
1052 av_init_packet(&flush_pkt);
1053 pkt = &flush_pkt;
1054 got_output = 1;
1055 }
1056
1057 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1058 int len;
1059
1060 av_init_packet(&out_pkt);
1061 len = av_parser_parse2(st->parser, st->codec,
1062 &out_pkt.data, &out_pkt.size, data, size,
1063 pkt->pts, pkt->dts, pkt->pos);
1064
1065 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1066 /* increment read pointer */
1067 data += len;
1068 size -= len;
1069
1070 got_output = !!out_pkt.size;
1071
1072 if (!out_pkt.size)
1073 continue;
1074
1075 /* set the duration */
1076 out_pkt.duration = 0;
1077 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1078 if (st->codec->sample_rate > 0) {
1079 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1080 (AVRational){ 1, st->codec->sample_rate },
1081 st->time_base,
1082 AV_ROUND_DOWN);
1083 }
1084 } else if (st->codec->time_base.num != 0 &&
1085 st->codec->time_base.den != 0) {
1086 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1087 st->codec->time_base,
1088 st->time_base,
1089 AV_ROUND_DOWN);
1090 }
1091
1092 out_pkt.stream_index = st->index;
1093 out_pkt.pts = st->parser->pts;
1094 out_pkt.dts = st->parser->dts;
1095 out_pkt.pos = st->parser->pos;
1096
1097 if (st->parser->key_frame == 1 ||
1098 (st->parser->key_frame == -1 &&
1099 st->parser->pict_type == AV_PICTURE_TYPE_I))
1100 out_pkt.flags |= AV_PKT_FLAG_KEY;
1101
1102 compute_pkt_fields(s, st, st->parser, &out_pkt);
1103
1104 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1105 out_pkt.flags & AV_PKT_FLAG_KEY) {
1106 ff_reduce_index(s, st->index);
1107 av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
1108 0, 0, AVINDEX_KEYFRAME);
1109 }
1110
1111 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1112 out_pkt.destruct = pkt->destruct;
1113 pkt->destruct = NULL;
1114 }
1115 if ((ret = av_dup_packet(&out_pkt)) < 0)
1116 goto fail;
1117
1118 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1119 av_free_packet(&out_pkt);
1120 ret = AVERROR(ENOMEM);
1121 goto fail;
1122 }
1123 }
1124
1125
1126 /* end of the stream => close and free the parser */
1127 if (pkt == &flush_pkt) {
1128 av_parser_close(st->parser);
1129 st->parser = NULL;
1130 }
1131
1132 fail:
1133 av_free_packet(pkt);
1134 return ret;
1135 }
1136
1137 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1138 AVPacketList **pkt_buffer_end,
1139 AVPacket *pkt)
1140 {
1141 AVPacketList *pktl;
1142 av_assert0(*pkt_buffer);
1143 pktl = *pkt_buffer;
1144 *pkt = pktl->pkt;
1145 *pkt_buffer = pktl->next;
1146 if (!pktl->next)
1147 *pkt_buffer_end = NULL;
1148 av_freep(&pktl);
1149 return 0;
1150 }
1151
1152 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1153 {
1154 int ret = 0, i, got_packet = 0;
1155
1156 av_init_packet(pkt);
1157
1158 while (!got_packet && !s->parse_queue) {
1159 AVStream *st;
1160 AVPacket cur_pkt;
1161
1162 /* read next packet */
1163 ret = ff_read_packet(s, &cur_pkt);
1164 if (ret < 0) {
1165 if (ret == AVERROR(EAGAIN))
1166 return ret;
1167 /* flush the parsers */
1168 for(i = 0; i < s->nb_streams; i++) {
1169 st = s->streams[i];
1170 if (st->parser && st->need_parsing)
1171 parse_packet(s, NULL, st->index);
1172 }
1173 /* all remaining packets are now in parse_queue =>
1174 * really terminate parsing */
1175 break;
1176 }
1177 ret = 0;
1178 st = s->streams[cur_pkt.stream_index];
1179
1180 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1181 cur_pkt.dts != AV_NOPTS_VALUE &&
1182 cur_pkt.pts < cur_pkt.dts) {
1183 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1184 cur_pkt.stream_index,
1185 cur_pkt.pts,
1186 cur_pkt.dts,
1187 cur_pkt.size);
1188 }
1189 if (s->debug & FF_FDEBUG_TS)
1190 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1191 cur_pkt.stream_index,
1192 cur_pkt.pts,
1193 cur_pkt.dts,
1194 cur_pkt.size,
1195 cur_pkt.duration,
1196 cur_pkt.flags);
1197
1198 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1199 st->parser = av_parser_init(st->codec->codec_id);
1200 if (!st->parser) {
1201 /* no parser available: just output the raw packets */
1202 st->need_parsing = AVSTREAM_PARSE_NONE;
1203 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1204 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1205 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1206 st->parser->flags |= PARSER_FLAG_ONCE;
1207 }
1208 }
1209
1210 if (!st->need_parsing || !st->parser) {
1211 /* no parsing needed: we just output the packet as is */
1212 *pkt = cur_pkt;
1213 compute_pkt_fields(s, st, NULL, pkt);
1214 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1215 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1216 ff_reduce_index(s, st->index);
1217 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1218 }
1219 got_packet = 1;
1220 } else if (st->discard < AVDISCARD_ALL) {
1221 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1222 return ret;
1223 } else {
1224 /* free packet */
1225 av_free_packet(&cur_pkt);
1226 }
1227 }
1228
1229 if (!got_packet && s->parse_queue)
1230 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1231
1232 if(s->debug & FF_FDEBUG_TS)
1233 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1234 pkt->stream_index,
1235 pkt->pts,
1236 pkt->dts,
1237 pkt->size,
1238 pkt->duration,
1239 pkt->flags);
1240
1241 return ret;
1242 }
1243
1244 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1245 {
1246 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1247 int eof = 0;
1248
1249 if (!genpts)
1250 return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1251 &s->packet_buffer_end,
1252 pkt) :
1253 read_frame_internal(s, pkt);
1254
1255 for (;;) {
1256 int ret;
1257 AVPacketList *pktl = s->packet_buffer;
1258
1259 if (pktl) {
1260 AVPacket *next_pkt = &pktl->pkt;
1261
1262 if (next_pkt->dts != AV_NOPTS_VALUE) {
1263 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1264 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1265 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1266 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1267 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1268 next_pkt->pts = pktl->pkt.dts;
1269 }
1270 pktl = pktl->next;
1271 }
1272 pktl = s->packet_buffer;
1273 }
1274
1275 /* read packet from packet buffer, if there is data */
1276 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1277 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1278 return read_from_packet_buffer(&s->packet_buffer,
1279 &s->packet_buffer_end, pkt);
1280 }
1281
1282 ret = read_frame_internal(s, pkt);
1283 if (ret < 0) {
1284 if (pktl && ret != AVERROR(EAGAIN)) {
1285 eof = 1;
1286 continue;
1287 } else
1288 return ret;
1289 }
1290
1291 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1292 &s->packet_buffer_end)) < 0)
1293 return AVERROR(ENOMEM);
1294 }
1295 }
1296
1297 /* XXX: suppress the packet queue */
1298 static void flush_packet_queue(AVFormatContext *s)
1299 {
1300 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1301 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1302 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1303
1304 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1305 }
1306
1307 /*******************************************************/
1308 /* seek support */
1309
1310 int av_find_default_stream_index(AVFormatContext *s)
1311 {
1312 int first_audio_index = -1;
1313 int i;
1314 AVStream *st;
1315
1316 if (s->nb_streams <= 0)
1317 return -1;
1318 for(i = 0; i < s->nb_streams; i++) {
1319 st = s->streams[i];
1320 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1321 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1322 return i;
1323 }
1324 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1325 first_audio_index = i;
1326 }
1327 return first_audio_index >= 0 ? first_audio_index : 0;
1328 }
1329
1330 /**
1331 * Flush the frame reader.
1332 */
1333 void ff_read_frame_flush(AVFormatContext *s)
1334 {
1335 AVStream *st;
1336 int i, j;
1337
1338 flush_packet_queue(s);
1339
1340 /* for each stream, reset read state */
1341 for(i = 0; i < s->nb_streams; i++) {
1342 st = s->streams[i];
1343
1344 if (st->parser) {
1345 av_parser_close(st->parser);
1346 st->parser = NULL;
1347 }
1348 st->last_IP_pts = AV_NOPTS_VALUE;
1349 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1350 st->reference_dts = AV_NOPTS_VALUE;
1351
1352 st->probe_packets = MAX_PROBE_PACKETS;
1353
1354 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1355 st->pts_buffer[j]= AV_NOPTS_VALUE;
1356 }
1357 }
1358
1359 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1360 {
1361 int i;
1362
1363 for(i = 0; i < s->nb_streams; i++) {
1364 AVStream *st = s->streams[i];
1365
1366 st->cur_dts = av_rescale(timestamp,
1367 st->time_base.den * (int64_t)ref_st->time_base.num,
1368 st->time_base.num * (int64_t)ref_st->time_base.den);
1369 }
1370 }
1371
1372 void ff_reduce_index(AVFormatContext *s, int stream_index)
1373 {
1374 AVStream *st= s->streams[stream_index];
1375 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1376
1377 if((unsigned)st->nb_index_entries >= max_entries){
1378 int i;
1379 for(i=0; 2*i<st->nb_index_entries; i++)
1380 st->index_entries[i]= st->index_entries[2*i];
1381 st->nb_index_entries= i;
1382 }
1383 }
1384
1385 int ff_add_index_entry(AVIndexEntry **index_entries,
1386 int *nb_index_entries,
1387 unsigned int *index_entries_allocated_size,
1388 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1389 {
1390 AVIndexEntry *entries, *ie;
1391 int index;
1392
1393 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1394 return -1;
1395
1396 entries = av_fast_realloc(*index_entries,
1397 index_entries_allocated_size,
1398 (*nb_index_entries + 1) *
1399 sizeof(AVIndexEntry));
1400 if(!entries)
1401 return -1;
1402
1403 *index_entries= entries;
1404
1405 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1406
1407 if(index<0){
1408 index= (*nb_index_entries)++;
1409 ie= &entries[index];
1410 assert(index==0 || ie[-1].timestamp < timestamp);
1411 }else{
1412 ie= &entries[index];
1413 if(ie->timestamp != timestamp){
1414 if(ie->timestamp <= timestamp)
1415 return -1;
1416 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1417 (*nb_index_entries)++;
1418 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1419 distance= ie->min_distance;
1420 }
1421
1422 ie->pos = pos;
1423 ie->timestamp = timestamp;
1424 ie->min_distance= distance;
1425 ie->size= size;
1426 ie->flags = flags;
1427
1428 return index;
1429 }
1430
1431 int av_add_index_entry(AVStream *st,
1432 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1433 {
1434 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1435 &st->index_entries_allocated_size, pos,
1436 timestamp, size, distance, flags);
1437 }
1438
1439 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1440 int64_t wanted_timestamp, int flags)
1441 {
1442 int a, b, m;
1443 int64_t timestamp;
1444
1445 a = - 1;
1446 b = nb_entries;
1447
1448 //optimize appending index entries at the end
1449 if(b && entries[b-1].timestamp < wanted_timestamp)
1450 a= b-1;
1451
1452 while (b - a > 1) {
1453 m = (a + b) >> 1;
1454 timestamp = entries[m].timestamp;
1455 if(timestamp >= wanted_timestamp)
1456 b = m;
1457 if(timestamp <= wanted_timestamp)
1458 a = m;
1459 }
1460 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1461
1462 if(!(flags & AVSEEK_FLAG_ANY)){
1463 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1464 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1465 }
1466 }
1467
1468 if(m == nb_entries)
1469 return -1;
1470 return m;
1471 }
1472
1473 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1474 int flags)
1475 {
1476 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1477 wanted_timestamp, flags);
1478 }
1479
1480 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1481 {
1482 AVInputFormat *avif= s->iformat;
1483 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1484 int64_t ts_min, ts_max, ts;
1485 int index;
1486 int64_t ret;
1487 AVStream *st;
1488
1489 if (stream_index < 0)
1490 return -1;
1491
1492 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1493
1494 ts_max=
1495 ts_min= AV_NOPTS_VALUE;
1496 pos_limit= -1; //gcc falsely says it may be uninitialized
1497
1498 st= s->streams[stream_index];
1499 if(st->index_entries){
1500 AVIndexEntry *e;
1501
1502 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()
1503 index= FFMAX(index, 0);
1504 e= &st->index_entries[index];
1505
1506 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1507 pos_min= e->pos;
1508 ts_min= e->timestamp;
1509 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1510 pos_min,ts_min);
1511 }else{
1512 assert(index==0);
1513 }
1514
1515 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1516 assert(index < st->nb_index_entries);
1517 if(index >= 0){
1518 e= &st->index_entries[index];
1519 assert(e->timestamp >= target_ts);
1520 pos_max= e->pos;
1521 ts_max= e->timestamp;
1522 pos_limit= pos_max - e->min_distance;
1523 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1524 pos_max,pos_limit, ts_max);
1525 }
1526 }
1527
1528 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1529 if(pos<0)
1530 return -1;
1531
1532 /* do the seek */
1533 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1534 return ret;
1535
1536 ff_update_cur_dts(s, st, ts);
1537
1538 return 0;
1539 }
1540
1541 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1542 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1543 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1544 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1545 {
1546 int64_t pos, ts;
1547 int64_t start_pos, filesize;
1548 int no_change;
1549
1550 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1551
1552 if(ts_min == AV_NOPTS_VALUE){
1553 pos_min = s->data_offset;
1554 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1555 if (ts_min == AV_NOPTS_VALUE)
1556 return -1;
1557 }
1558
1559 if(ts_max == AV_NOPTS_VALUE){
1560 int step= 1024;
1561 filesize = avio_size(s->pb);
1562 pos_max = filesize - 1;
1563 do{
1564 pos_max -= step;
1565 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1566 step += step;
1567 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1568 if (ts_max == AV_NOPTS_VALUE)
1569 return -1;
1570
1571 for(;;){
1572 int64_t tmp_pos= pos_max + 1;
1573 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1574 if(tmp_ts == AV_NOPTS_VALUE)
1575 break;
1576 ts_max= tmp_ts;
1577 pos_max= tmp_pos;
1578 if(tmp_pos >= filesize)
1579 break;
1580 }
1581 pos_limit= pos_max;
1582 }
1583
1584 if(ts_min > ts_max){
1585 return -1;
1586 }else if(ts_min == ts_max){
1587 pos_limit= pos_min;
1588 }
1589
1590 no_change=0;
1591 while (pos_min < pos_limit) {
1592 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1593 pos_min, pos_max, ts_min, ts_max);
1594 assert(pos_limit <= pos_max);
1595
1596 if(no_change==0){
1597 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1598 // interpolate position (better than dichotomy)
1599 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1600 + pos_min - approximate_keyframe_distance;
1601 }else if(no_change==1){
1602 // bisection, if interpolation failed to change min or max pos last time
1603 pos = (pos_min + pos_limit)>>1;
1604 }else{
1605 /* linear search if bisection failed, can only happen if there
1606 are very few or no keyframes between min/max */
1607 pos=pos_min;
1608 }
1609 if(pos <= pos_min)
1610 pos= pos_min + 1;
1611 else if(pos > pos_limit)
1612 pos= pos_limit;
1613 start_pos= pos;
1614
1615 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1616 if(pos == pos_max)
1617 no_change++;
1618 else
1619 no_change=0;
1620 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1621 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1622 pos_limit, start_pos, no_change);
1623 if(ts == AV_NOPTS_VALUE){
1624 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1625 return -1;
1626 }
1627 assert(ts != AV_NOPTS_VALUE);
1628 if (target_ts <= ts) {
1629 pos_limit = start_pos - 1;
1630 pos_max = pos;
1631 ts_max = ts;
1632 }
1633 if (target_ts >= ts) {
1634 pos_min = pos;
1635 ts_min = ts;
1636 }
1637 }
1638
1639 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1640 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1641 pos_min = pos;
1642 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1643 pos_min++;
1644 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1645 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1646 pos, ts_min, target_ts, ts_max);
1647 *ts_ret= ts;
1648 return pos;
1649 }
1650
1651 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1652 int64_t pos_min, pos_max;
1653
1654 pos_min = s->data_offset;
1655 pos_max = avio_size(s->pb) - 1;
1656
1657 if (pos < pos_min) pos= pos_min;
1658 else if(pos > pos_max) pos= pos_max;
1659
1660 avio_seek(s->pb, pos, SEEK_SET);
1661
1662 return 0;
1663 }
1664
1665 static int seek_frame_generic(AVFormatContext *s,
1666 int stream_index, int64_t timestamp, int flags)
1667 {
1668 int index;
1669 int64_t ret;
1670 AVStream *st;
1671 AVIndexEntry *ie;
1672
1673 st = s->streams[stream_index];
1674
1675 index = av_index_search_timestamp(st, timestamp, flags);
1676
1677 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1678 return -1;
1679
1680 if(index < 0 || index==st->nb_index_entries-1){
1681 AVPacket pkt;
1682
1683 if(st->nb_index_entries){
1684 assert(st->index_entries);
1685 ie= &st->index_entries[st->nb_index_entries-1];
1686 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1687 return ret;
1688 ff_update_cur_dts(s, st, ie->timestamp);
1689 }else{
1690 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1691 return ret;
1692 }
1693 for (;;) {
1694 int read_status;
1695 do{
1696 read_status = av_read_frame(s, &pkt);
1697 } while (read_status == AVERROR(EAGAIN));
1698 if (read_status < 0)
1699 break;
1700 av_free_packet(&pkt);
1701 if(stream_index == pkt.stream_index){
1702 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1703 break;
1704 }
1705 }
1706 index = av_index_search_timestamp(st, timestamp, flags);
1707 }
1708 if (index < 0)
1709 return -1;
1710
1711 ff_read_frame_flush(s);
1712 if (s->iformat->read_seek){
1713 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1714 return 0;
1715 }
1716 ie = &st->index_entries[index];
1717 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1718 return ret;
1719 ff_update_cur_dts(s, st, ie->timestamp);
1720
1721 return 0;
1722 }
1723
1724 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1725 int64_t timestamp, int flags)
1726 {
1727 int ret;
1728 AVStream *st;
1729
1730 if (flags & AVSEEK_FLAG_BYTE) {
1731 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1732 return -1;
1733 ff_read_frame_flush(s);
1734 return seek_frame_byte(s, stream_index, timestamp, flags);
1735 }
1736
1737 if(stream_index < 0){
1738 stream_index= av_find_default_stream_index(s);
1739 if(stream_index < 0)
1740 return -1;
1741
1742 st= s->streams[stream_index];
1743 /* timestamp for default must be expressed in AV_TIME_BASE units */
1744 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1745 }
1746
1747 /* first, we try the format specific seek */
1748 if (s->iformat->read_seek) {
1749 ff_read_frame_flush(s);
1750 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1751 } else
1752 ret = -1;
1753 if (ret >= 0) {
1754 return 0;
1755 }
1756
1757 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1758 ff_read_frame_flush(s);
1759 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1760 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1761 ff_read_frame_flush(s);
1762 return seek_frame_generic(s, stream_index, timestamp, flags);
1763 }
1764 else
1765 return -1;
1766 }
1767
1768 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1769 {
1770 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1771
1772 if (ret >= 0)
1773 queue_attached_pictures(s);
1774
1775 return ret;
1776 }
1777
1778 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1779 {
1780 if(min_ts > ts || max_ts < ts)
1781 return -1;
1782
1783 if (s->iformat->read_seek2) {
1784 int ret;
1785 ff_read_frame_flush(s);
1786 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1787
1788 if (ret >= 0)
1789 queue_attached_pictures(s);
1790 return ret;
1791 }
1792
1793 if(s->iformat->read_timestamp){
1794 //try to seek via read_timestamp()
1795 }
1796
1797 //Fallback to old API if new is not implemented but old is
1798 //Note the old has somewat different sematics
1799 if(s->iformat->read_seek || 1)
1800 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1801
1802 // try some generic seek like seek_frame_generic() but with new ts semantics
1803 }
1804
1805 /*******************************************************/
1806
1807 /**
1808 * Return TRUE if the stream has accurate duration in any stream.
1809 *
1810 * @return TRUE if the stream has accurate duration for at least one component.
1811 */
1812 static int has_duration(AVFormatContext *ic)
1813 {
1814 int i;
1815 AVStream *st;
1816
1817 for(i = 0;i < ic->nb_streams; i++) {
1818 st = ic->streams[i];
1819 if (st->duration != AV_NOPTS_VALUE)
1820 return 1;
1821 }
1822 if (ic->duration != AV_NOPTS_VALUE)
1823 return 1;
1824 return 0;
1825 }
1826
1827 /**
1828 * Estimate the stream timings from the one of each components.
1829 *
1830 * Also computes the global bitrate if possible.
1831 */
1832 static void update_stream_timings(AVFormatContext *ic)
1833 {
1834 int64_t start_time, start_time1, end_time, end_time1;
1835 int64_t duration, duration1, filesize;
1836 int i;
1837 AVStream *st;
1838
1839 start_time = INT64_MAX;
1840 end_time = INT64_MIN;
1841 duration = INT64_MIN;
1842 for(i = 0;i < ic->nb_streams; i++) {
1843 st = ic->streams[i];
1844 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1845 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1846 start_time = FFMIN(start_time, start_time1);
1847 if (st->duration != AV_NOPTS_VALUE) {
1848 end_time1 = start_time1
1849 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1850 end_time = FFMAX(end_time, end_time1);
1851 }
1852 }
1853 if (st->duration != AV_NOPTS_VALUE) {
1854 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1855 duration = FFMAX(duration, duration1);
1856 }
1857 }
1858 if (start_time != INT64_MAX) {
1859 ic->start_time = start_time;
1860 if (end_time != INT64_MIN)
1861 duration = FFMAX(duration, end_time - start_time);
1862 }
1863 if (duration != INT64_MIN) {
1864 ic->duration = duration;
1865 if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1866 /* compute the bitrate */
1867 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1868 (double)ic->duration;
1869 }
1870 }
1871 }
1872
1873 static void fill_all_stream_timings(AVFormatContext *ic)
1874 {
1875 int i;
1876 AVStream *st;
1877
1878 update_stream_timings(ic);
1879 for(i = 0;i < ic->nb_streams; i++) {
1880 st = ic->streams[i];
1881 if (st->start_time == AV_NOPTS_VALUE) {
1882 if(ic->start_time != AV_NOPTS_VALUE)
1883 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1884 if(ic->duration != AV_NOPTS_VALUE)
1885 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1886 }
1887 }
1888 }
1889
1890 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1891 {
1892 int64_t filesize, duration;
1893 int bit_rate, i;
1894 AVStream *st;
1895
1896 /* if bit_rate is already set, we believe it */
1897 if (ic->bit_rate <= 0) {
1898 bit_rate = 0;
1899 for(i=0;i<ic->nb_streams;i++) {
1900 st = ic->streams[i];
1901 if (st->codec->bit_rate > 0)
1902 bit_rate += st->codec->bit_rate;
1903 }
1904 ic->bit_rate = bit_rate;
1905 }
1906
1907 /* if duration is already set, we believe it */
1908 if (ic->duration == AV_NOPTS_VALUE &&
1909 ic->bit_rate != 0) {
1910 filesize = ic->pb ? avio_size(ic->pb) : 0;
1911 if (filesize > 0) {
1912 for(i = 0; i < ic->nb_streams; i++) {
1913 st = ic->streams[i];
1914 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1915 if (st->duration == AV_NOPTS_VALUE)
1916 st->duration = duration;
1917 }
1918 }
1919 }
1920 }
1921
1922 #define DURATION_MAX_READ_SIZE 250000
1923 #define DURATION_MAX_RETRY 3
1924
1925 /* only usable for MPEG-PS streams */
1926 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1927 {
1928 AVPacket pkt1, *pkt = &pkt1;
1929 AVStream *st;
1930 int read_size, i, ret;
1931 int64_t end_time;
1932 int64_t filesize, offset, duration;
1933 int retry=0;
1934
1935 /* flush packet queue */
1936 flush_packet_queue(ic);
1937
1938 for (i=0; i<ic->nb_streams; i++) {
1939 st = ic->streams[i];
1940 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1941 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1942
1943 if (st->parser) {
1944 av_parser_close(st->parser);
1945 st->parser= NULL;
1946 }
1947 }
1948
1949 /* estimate the end time (duration) */
1950 /* XXX: may need to support wrapping */
1951 filesize = ic->pb ? avio_size(ic->pb) : 0;
1952 end_time = AV_NOPTS_VALUE;
1953 do{
1954 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1955 if (offset < 0)
1956 offset = 0;
1957
1958 avio_seek(ic->pb, offset, SEEK_SET);
1959 read_size = 0;
1960 for(;;) {
1961 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1962 break;
1963
1964 do {
1965 ret = ff_read_packet(ic, pkt);
1966 } while(ret == AVERROR(EAGAIN));
1967 if (ret != 0)
1968 break;
1969 read_size += pkt->size;
1970 st = ic->streams[pkt->stream_index];
1971 if (pkt->pts != AV_NOPTS_VALUE &&
1972 (st->start_time != AV_NOPTS_VALUE ||
1973 st->first_dts != AV_NOPTS_VALUE)) {
1974 duration = end_time = pkt->pts;
1975 if (st->start_time != AV_NOPTS_VALUE)
1976 duration -= st->start_time;
1977 else
1978 duration -= st->first_dts;
1979 if (duration < 0)
1980 duration += 1LL<<st->pts_wrap_bits;
1981 if (duration > 0) {
1982 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1983 st->duration = duration;
1984 }
1985 }
1986 av_free_packet(pkt);
1987 }
1988 }while( end_time==AV_NOPTS_VALUE
1989 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1990 && ++retry <= DURATION_MAX_RETRY);
1991
1992 fill_all_stream_timings(ic);
1993
1994 avio_seek(ic->pb, old_offset, SEEK_SET);
1995 for (i=0; i<ic->nb_streams; i++) {
1996 st= ic->streams[i];
1997 st->cur_dts= st->first_dts;
1998 st->last_IP_pts = AV_NOPTS_VALUE;
1999 st->reference_dts = AV_NOPTS_VALUE;
2000 }
2001 }
2002
2003 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2004 {
2005 int64_t file_size;
2006
2007 /* get the file size, if possible */
2008 if (ic->iformat->flags & AVFMT_NOFILE) {
2009 file_size = 0;
2010 } else {
2011 file_size = avio_size(ic->pb);
2012 file_size = FFMAX(0, file_size);
2013 }
2014
2015 if ((!strcmp(ic->iformat->name, "mpeg") ||
2016 !strcmp(ic->iformat->name, "mpegts")) &&
2017 file_size && ic->pb->seekable) {
2018 /* get accurate estimate from the PTSes */
2019 estimate_timings_from_pts(ic, old_offset);
2020 } else if (has_duration(ic)) {
2021 /* at least one component has timings - we use them for all
2022 the components */
2023 fill_all_stream_timings(ic);
2024 } else {
2025 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2026 /* less precise: use bitrate info */
2027 estimate_timings_from_bit_rate(ic);
2028 }
2029 update_stream_timings(ic);
2030
2031 {
2032 int i;
2033 AVStream av_unused *st;
2034 for(i = 0;i < ic->nb_streams; i++) {
2035 st = ic->streams[i];
2036 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2037 (double) st->start_time / AV_TIME_BASE,
2038 (double) st->duration / AV_TIME_BASE);
2039 }
2040 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2041 (double) ic->start_time / AV_TIME_BASE,
2042 (double) ic->duration / AV_TIME_BASE,
2043 ic->bit_rate / 1000);
2044 }
2045 }
2046
2047 static int has_codec_parameters(AVStream *st)
2048 {
2049 AVCodecContext *avctx = st->codec;
2050 int val;
2051 switch (avctx->codec_type) {
2052 case AVMEDIA_TYPE_AUDIO:
2053 val = avctx->sample_rate && avctx->channels;
2054 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2055 return 0;
2056 break;
2057 case AVMEDIA_TYPE_VIDEO:
2058 val = avctx->width;
2059 if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2060 return 0;
2061 break;
2062 default:
2063 val = 1;
2064 break;
2065 }
2066 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
2067 }
2068
2069 static int has_decode_delay_been_guessed(AVStream *st)
2070 {
2071 return st->codec->codec_id != AV_CODEC_ID_H264 ||
2072 st->info->nb_decoded_frames >= 6;
2073 }
2074
2075 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2076 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2077 {
2078 AVCodec *codec;
2079 int got_picture = 1, ret = 0;
2080 AVFrame picture;
2081 AVPacket pkt = *avpkt;
2082
2083 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2084 AVDictionary *thread_opt = NULL;
2085
2086 codec = st->codec->codec ? st->codec->codec :
2087 avcodec_find_decoder(st->codec->codec_id);
2088
2089 if (!codec) {
2090 st->info->found_decoder = -1;
2091 return -1;
2092 }
2093
2094 /* force thread count to 1 since the h264 decoder will not extract SPS
2095 * and PPS to extradata during multi-threaded decoding */
2096 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2097 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2098 if (!options)
2099 av_dict_free(&thread_opt);
2100 if (ret < 0) {
2101 st->info->found_decoder = -1;
2102 return ret;
2103 }
2104 st->info->found_decoder = 1;
2105 } else if (!st->info->found_decoder)
2106 st->info->found_decoder = 1;
2107
2108 if (st->info->found_decoder < 0)
2109 return -1;
2110
2111 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2112 ret >= 0 &&
2113 (!has_codec_parameters(st) ||
2114 !has_decode_delay_been_guessed(st) ||
2115 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2116 got_picture = 0;
2117 avcodec_get_frame_defaults(&picture);
2118 switch(st->codec->codec_type) {
2119 case AVMEDIA_TYPE_VIDEO:
2120 ret = avcodec_decode_video2(st->codec, &picture,
2121 &got_picture, &pkt);
2122 break;
2123 case AVMEDIA_TYPE_AUDIO:
2124 ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2125 break;
2126 default:
2127 break;
2128 }
2129 if (ret >= 0) {
2130 if (got_picture)
2131 st->info->nb_decoded_frames++;
2132 pkt.data += ret;
2133 pkt.size -= ret;
2134 ret = got_picture;
2135 }
2136 }
2137 return ret;
2138 }
2139
2140 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2141 {
2142 while (tags->id != AV_CODEC_ID_NONE) {
2143 if (tags->id == id)
2144 return tags->tag;
2145 tags++;
2146 }
2147 return 0;
2148 }
2149
2150 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2151 {
2152 int i;
2153 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2154 if(tag == tags[i].tag)
2155 return tags[i].id;
2156 }
2157 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2158 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2159 return tags[i].id;
2160 }
2161 return AV_CODEC_ID_NONE;
2162 }
2163
2164 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2165 {
2166 int i;
2167 for(i=0; tags && tags[i]; i++){
2168 int tag= ff_codec_get_tag(tags[i], id);
2169 if(tag) return tag;
2170 }
2171 return 0;
2172 }
2173
2174 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2175 {
2176 int i;
2177 for(i=0; tags && tags[i]; i++){
2178 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2179 if(id!=AV_CODEC_ID_NONE) return id;
2180 }
2181 return AV_CODEC_ID_NONE;
2182 }
2183
2184 static void compute_chapters_end(AVFormatContext *s)
2185 {
2186 unsigned int i, j;
2187 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2188
2189 for (i = 0; i < s->nb_chapters; i++)
2190 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2191 AVChapter *ch = s->chapters[i];
2192 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2193 : INT64_MAX;
2194
2195 for (j = 0; j < s->nb_chapters; j++) {
2196 AVChapter *ch1 = s->chapters[j];
2197 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2198 if (j != i && next_start > ch->start && next_start < end)
2199 end = next_start;
2200 }
2201 ch->end = (end == INT64_MAX) ? ch->start : end;
2202 }
2203 }
2204
2205 static int get_std_framerate(int i){
2206 if(i<60*12) return i*1001;
2207 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2208 }
2209
2210 /*
2211 * Is the time base unreliable.
2212 * This is a heuristic to balance between quick acceptance of the values in
2213 * the headers vs. some extra checks.
2214 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2215 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2216 * And there are "variable" fps files this needs to detect as well.
2217 */
2218 static int tb_unreliable(AVCodecContext *c){
2219 if( c->time_base.den >= 101L*c->time_base.num
2220 || c->time_base.den < 5L*c->time_base.num
2221 /* || c->codec_tag == AV_RL32("DIVX")
2222 || c->codec_tag == AV_RL32("XVID")*/
2223 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2224 || c->codec_id == AV_CODEC_ID_H264
2225 )
2226 return 1;
2227 return 0;
2228 }
2229
2230 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2231 {
2232 int i, count, ret, read_size, j;
2233 AVStream *st;
2234 AVPacket pkt1, *pkt;
2235 int64_t old_offset = avio_tell(ic->pb);
2236 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2237
2238 for(i=0;i<ic->nb_streams;i++) {
2239 AVCodec *codec;
2240 AVDictionary *thread_opt = NULL;
2241 st = ic->streams[i];
2242
2243 //only for the split stuff
2244 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2245 st->parser = av_parser_init(st->codec->codec_id);
2246 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2247 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2248 }
2249 }
2250 codec = st->codec->codec ? st->codec->codec :
2251 avcodec_find_decoder(st->codec->codec_id);
2252
2253 /* force thread count to 1 since the h264 decoder will not extract SPS
2254 * and PPS to extradata during multi-threaded decoding */
2255 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2256
2257 /* Ensure that subtitle_header is properly set. */
2258 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2259 && codec && !st->codec->codec)
2260 avcodec_open2(st->codec, codec, options ? &options[i]
2261 : &thread_opt);
2262
2263 //try to just open decoders, in case this is enough to get parameters
2264 if (!has_codec_parameters(st)) {
2265 if (codec && !st->codec->codec)
2266 avcodec_open2(st->codec, codec, options ? &options[i]
2267 : &thread_opt);
2268 }
2269 if (!options)
2270 av_dict_free(&thread_opt);
2271 }
2272
2273 for (i=0; i<ic->nb_streams; i++) {
2274 #if FF_API_R_FRAME_RATE
2275 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2276 #endif
2277 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2278 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2279 }
2280
2281 count = 0;
2282 read_size = 0;
2283 for(;;) {
2284 if (ff_check_interrupt(&ic->interrupt_callback)){
2285 ret= AVERROR_EXIT;
2286 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2287 break;
2288 }
2289
2290 /* check if one codec still needs to be handled */
2291 for(i=0;i<ic->nb_streams;i++) {
2292 int fps_analyze_framecount = 20;
2293
2294 st = ic->streams[i];
2295 if (!has_codec_parameters(st))
2296 break;
2297 /* if the timebase is coarse (like the usual millisecond precision
2298 of mkv), we need to analyze more frames to reliably arrive at
2299 the correct fps */
2300 if (av_q2d(st->time_base) > 0.0005)
2301 fps_analyze_framecount *= 2;
2302 if (ic->fps_probe_size >= 0)
2303 fps_analyze_framecount = ic->fps_probe_size;
2304 /* variable fps and no guess at the real fps */
2305 if( tb_unreliable(st->codec) && !st->avg_frame_rate.num
2306 && st->codec_info_nb_frames < fps_analyze_framecount
2307 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2308 break;
2309 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2310 break;
2311 if (st->first_dts == AV_NOPTS_VALUE &&
2312 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2313 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2314 break;
2315 }
2316 if (i == ic->nb_streams) {
2317 /* NOTE: if the format has no header, then we need to read
2318 some packets to get most of the streams, so we cannot
2319 stop here */
2320 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2321 /* if we found the info for all the codecs, we can stop */
2322 ret = count;
2323 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2324 break;
2325 }
2326 }
2327 /* we did not get all the codec info, but we read too much data */
2328 if (read_size >= ic->probesize) {
2329 ret = count;
2330 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2331 break;
2332 }
2333
2334 /* NOTE: a new stream can be added there if no header in file
2335 (AVFMTCTX_NOHEADER) */
2336 ret = read_frame_internal(ic, &pkt1);
2337 if (ret == AVERROR(EAGAIN))
2338 continue;
2339
2340 if (ret < 0) {
2341 /* EOF or error*/
2342 AVPacket empty_pkt = { 0 };
2343 int err = 0;
2344 av_init_packet(&empty_pkt);
2345
2346 ret = -1; /* we could not have all the codec parameters before EOF */
2347 for(i=0;i<ic->nb_streams;i++) {
2348 st = ic->streams[i];
2349
2350 /* flush the decoders */
2351 if (st->info->found_decoder == 1) {
2352 do {
2353 err = try_decode_frame(st, &empty_pkt,
2354 (options && i < orig_nb_streams) ?
2355 &options[i] : NULL);
2356 } while (err > 0 && !has_codec_parameters(st));
2357 }
2358
2359 if (err < 0) {
2360 av_log(ic, AV_LOG_WARNING,
2361 "decoding for stream %d failed\n", st->index);
2362 } else if (!has_codec_parameters(st)) {
2363 char buf[256];
2364 avcodec_string(buf, sizeof(buf), st->codec, 0);
2365 av_log(ic, AV_LOG_WARNING,
2366 "Could not find codec parameters (%s)\n", buf);
2367 } else {
2368 ret = 0;
2369 }
2370 }
2371 break;
2372 }
2373
2374 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2375 pkt = &pkt1;
2376 } else {
2377 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2378 &ic->packet_buffer_end);
2379 if ((ret = av_dup_packet(pkt)) < 0)
2380 goto find_stream_info_err;
2381 }
2382
2383 read_size += pkt->size;
2384
2385 st = ic->streams[pkt->stream_index];
2386 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2387 /* check for non-increasing dts */
2388 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2389 st->info->fps_last_dts >= pkt->dts) {
2390 av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
2391 "packet %d with DTS %"PRId64", packet %d with DTS "
2392 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2393 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2394 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2395 }
2396 /* check for a discontinuity in dts - if the difference in dts
2397 * is more than 1000 times the average packet duration in the sequence,
2398 * we treat it as a discontinuity */
2399 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2400 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2401 (pkt->dts - st->info->fps_last_dts) / 1000 >
2402 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2403 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2404 "packet %d with DTS %"PRId64", packet %d with DTS "
2405 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2406 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2407 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2408 }
2409
2410 /* update stored dts values */
2411 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2412 st->info->fps_first_dts = pkt->dts;
2413 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2414 }
2415 st->info->fps_last_dts = pkt->dts;
2416 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2417
2418 /* check max_analyze_duration */
2419 if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2420 AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2421 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2422 break;
2423 }
2424 }
2425 #if FF_API_R_FRAME_RATE
2426 {
2427 int64_t last = st->info->last_dts;
2428
2429 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2430 int64_t duration= pkt->dts - last;
2431 double dur= duration * av_q2d(st->time_base);
2432
2433 if (st->info->duration_count < 2)
2434 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2435 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2436 int framerate= get_std_framerate(i);
2437 int ticks= lrintf(dur*framerate/(1001*12));
2438 double error = dur - (double)ticks*1001*12 / framerate;
2439 st->info->duration_error[i] += error*error;
2440 }
2441 st->info->duration_count++;
2442 // ignore the first 4 values, they might have some random jitter
2443 if (st->info->duration_count > 3)
2444 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2445 }
2446 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2447 st->info->last_dts = pkt->dts;
2448 }
2449 #endif
2450 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2451 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2452 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2453 st->codec->extradata_size= i;
2454 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2455 if (!st->codec->extradata)
2456 return AVERROR(ENOMEM);
2457 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2458 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2459 }
2460 }
2461
2462 /* if still no information, we try to open the codec and to
2463 decompress the frame. We try to avoid that in most cases as
2464 it takes longer and uses more memory. For MPEG-4, we need to
2465 decompress for QuickTime.
2466
2467 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2468 least one frame of codec data, this makes sure the codec initializes
2469 the channel configuration and does not only trust the values from the container.
2470 */
2471 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2472
2473 st->codec_info_nb_frames++;
2474 count++;
2475 }
2476
2477 // close codecs which were opened in try_decode_frame()
2478 for(i=0;i<ic->nb_streams;i++) {
2479 st = ic->streams[i];
2480 avcodec_close(st->codec);
2481 }
2482 for(i=0;i<ic->nb_streams;i++) {
2483 st = ic->streams[i];
2484 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2485 /* estimate average framerate if not set by demuxer */
2486 if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
2487 int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
2488 int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
2489 int best_fps = 0;
2490 double best_error = 0.01;
2491
2492 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2493 delta_packets*(int64_t)st->time_base.den,
2494 delta_dts*(int64_t)st->time_base.num, 60000);
2495
2496 /* round guessed framerate to a "standard" framerate if it's
2497 * within 1% of the original estimate*/
2498 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2499 AVRational std_fps = { get_std_framerate(j), 12*1001 };
2500 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2501
2502 if (error < best_error) {
2503 best_error = error;
2504 best_fps = std_fps.num;
2505 }
2506 }
2507 if (best_fps) {
2508 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2509 best_fps, 12*1001, INT_MAX);
2510 }
2511 }
2512 #if FF_API_R_FRAME_RATE
2513 // the check for tb_unreliable() is not completely correct, since this is not about handling
2514 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2515 // ipmovie.c produces.
2516 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2517 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2518 if (st->info->duration_count && !st->r_frame_rate.num
2519 && tb_unreliable(st->codec)) {
2520 int num = 0;
2521 double best_error= 2*av_q2d(st->time_base);
2522 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2523
2524 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2525 double error = st->info->duration_error[j] * get_std_framerate(j);
2526 if(error < best_error){
2527 best_error= error;
2528 num = get_std_framerate(j);
2529 }
2530 }
2531 // do not increase frame rate by more than 1 % in order to match a standard rate.
2532 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2533 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2534 }
2535 #endif
2536 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2537 if(!st->codec->bits_per_coded_sample)
2538 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2539 // set stream disposition based on audio service type
2540 switch (st->codec->audio_service_type) {
2541 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2542 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2543 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2544 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2545 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2546 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2547 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2548 st->disposition = AV_DISPOSITION_COMMENT; break;
2549 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2550 st->disposition = AV_DISPOSITION_KARAOKE; break;
2551 }
2552 }
2553 }
2554
2555 estimate_timings(ic, old_offset);
2556
2557 compute_chapters_end(ic);
2558
2559 find_stream_info_err:
2560 for (i=0; i < ic->nb_streams; i++) {
2561 if (ic->streams[i]->codec)
2562 ic->streams[i]->codec->thread_count = 0;
2563 av_freep(&ic->streams[i]->info);
2564 }
2565 return ret;
2566 }
2567
2568 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2569 {
2570 int i, j;
2571
2572 for (i = 0; i < ic->nb_programs; i++)
2573 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2574 if (ic->programs[i]->stream_index[j] == s)
2575 return ic->programs[i];
2576 return NULL;
2577 }
2578
2579 int av_find_best_stream(AVFormatContext *ic,
2580 enum AVMediaType type,
2581 int wanted_stream_nb,
2582 int related_stream,
2583 AVCodec **decoder_ret,
2584 int flags)
2585 {
2586 int i, nb_streams = ic->nb_streams;
2587 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2588 unsigned *program = NULL;
2589 AVCodec *decoder = NULL, *best_decoder = NULL;
2590
2591 if (related_stream >= 0 && wanted_stream_nb < 0) {
2592 AVProgram *p = find_program_from_stream(ic, related_stream);
2593 if (p) {
2594 program = p->stream_index;
2595 nb_streams = p->nb_stream_indexes;
2596 }
2597 }
2598 for (i = 0; i < nb_streams; i++) {
2599 int real_stream_index = program ? program[i] : i;
2600 AVStream *st = ic->streams[real_stream_index];
2601 AVCodecContext *avctx = st->codec;
2602 if (avctx->codec_type != type)
2603 continue;
2604 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2605 continue;
2606 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2607 continue;
2608 if (decoder_ret) {
2609 decoder = avcodec_find_decoder(st->codec->codec_id);
2610 if (!decoder) {
2611 if (ret < 0)
2612 ret = AVERROR_DECODER_NOT_FOUND;
2613 continue;
2614 }
2615 }
2616 if (best_count >= st->codec_info_nb_frames)
2617 continue;
2618 best_count = st->codec_info_nb_frames;
2619 ret = real_stream_index;
2620 best_decoder = decoder;
2621 if (program && i == nb_streams - 1 && ret < 0) {
2622 program = NULL;
2623 nb_streams = ic->nb_streams;
2624 i = 0; /* no related stream found, try again with everything */
2625 }
2626 }
2627 if (decoder_ret)
2628 *decoder_ret = best_decoder;
2629 return ret;
2630 }
2631
2632 /*******************************************************/
2633
2634 int av_read_play(AVFormatContext *s)
2635 {
2636 if (s->iformat->read_play)
2637 return s->iformat->read_play(s);
2638 if (s->pb)
2639 return avio_pause(s->pb, 0);
2640 return AVERROR(ENOSYS);
2641 }
2642
2643 int av_read_pause(AVFormatContext *s)
2644 {
2645 if (s->iformat->read_pause)
2646 return s->iformat->read_pause(s);
2647 if (s->pb)
2648 return avio_pause(s->pb, 1);
2649 return AVERROR(ENOSYS);
2650 }
2651
2652 void avformat_free_context(AVFormatContext *s)
2653 {
2654 int i;
2655 AVStream *st;
2656
2657 av_opt_free(s);
2658 if (s->iformat && s->iformat->priv_class && s->priv_data)
2659 av_opt_free(s->priv_data);
2660
2661 for(i=0;i<s->nb_streams;i++) {
2662 /* free all data in a stream component */
2663 st = s->streams[i];
2664 if (st->parser) {
2665 av_parser_close(st->parser);
2666 }
2667 if (st->attached_pic.data)
2668 av_free_packet(&st->attached_pic);
2669 av_dict_free(&st->metadata);
2670 av_free(st->index_entries);
2671 av_free(st->codec->extradata);
2672 av_free(st->codec->subtitle_header);
2673 av_free(st->codec);
2674 av_free(st->priv_data);
2675 av_free(st->info);
2676 av_free(st);
2677 }
2678 for(i=s->nb_programs-1; i>=0; i--) {
2679 av_dict_free(&s->programs[i]->metadata);
2680 av_freep(&s->programs[i]->stream_index);
2681 av_freep(&s->programs[i]);
2682 }
2683 av_freep(&s->programs);
2684 av_freep(&s->priv_data);
2685 while(s->nb_chapters--) {
2686 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2687 av_free(s->chapters[s->nb_chapters]);
2688 }
2689 av_freep(&s->chapters);
2690 av_dict_free(&s->metadata);
2691 av_freep(&s->streams);
2692 av_free(s);
2693 }
2694
2695 #if FF_API_CLOSE_INPUT_FILE
2696 void av_close_input_file(AVFormatContext *s)
2697 {
2698 avformat_close_input(&s);
2699 }
2700 #endif
2701
2702 void avformat_close_input(AVFormatContext **ps)
2703 {
2704 AVFormatContext *s = *ps;
2705 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2706 NULL : s->pb;
2707 flush_packet_queue(s);
2708 if (s->iformat->read_close)
2709 s->iformat->read_close(s);
2710 avformat_free_context(s);
2711 *ps = NULL;
2712 if (pb)
2713 avio_close(pb);
2714 }
2715
2716 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2717 {
2718 AVStream *st;
2719 int i;
2720 AVStream **streams;
2721
2722 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2723 return NULL;
2724 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2725 if (!streams)
2726 return NULL;
2727 s->streams = streams;
2728
2729 st = av_mallocz(sizeof(AVStream));
2730 if (!st)
2731 return NULL;
2732 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2733 av_free(st);
2734 return NULL;
2735 }
2736
2737 st->codec = avcodec_alloc_context3(c);
2738 if (s->iformat) {
2739 /* no default bitrate if decoding */
2740 st->codec->bit_rate = 0;
2741 }
2742 st->index = s->nb_streams;
2743 st->start_time = AV_NOPTS_VALUE;
2744 st->duration = AV_NOPTS_VALUE;
2745 /* we set the current DTS to 0 so that formats without any timestamps
2746 but durations get some timestamps, formats with some unknown
2747 timestamps have their first few packets buffered and the
2748 timestamps corrected before they are returned to the user */
2749 st->cur_dts = 0;
2750 st->first_dts = AV_NOPTS_VALUE;
2751 st->probe_packets = MAX_PROBE_PACKETS;
2752
2753 /* default pts setting is MPEG-like */
2754 avpriv_set_pts_info(st, 33, 1, 90000);
2755 st->last_IP_pts = AV_NOPTS_VALUE;
2756 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2757 st->pts_buffer[i]= AV_NOPTS_VALUE;
2758 st->reference_dts = AV_NOPTS_VALUE;
2759
2760 st->sample_aspect_ratio = (AVRational){0,1};
2761
2762 #if FF_API_R_FRAME_RATE
2763 st->info->last_dts = AV_NOPTS_VALUE;
2764 #endif
2765 st->info->fps_first_dts = AV_NOPTS_VALUE;
2766 st->info->fps_last_dts = AV_NOPTS_VALUE;
2767
2768 s->streams[s->nb_streams++] = st;
2769 return st;
2770 }
2771
2772 AVProgram *av_new_program(AVFormatContext *ac, int id)
2773 {
2774 AVProgram *program=NULL;
2775 int i;
2776
2777 av_dlog(ac, "new_program: id=0x%04x\n", id);
2778
2779 for(i=0; i<ac->nb_programs; i++)
2780 if(ac->programs[i]->id == id)
2781 program = ac->programs[i];
2782
2783 if(!program){
2784 program = av_mallocz(sizeof(AVProgram));
2785 if (!program)
2786 return NULL;
2787 dynarray_add(&ac->programs, &ac->nb_programs, program);
2788 program->discard = AVDISCARD_NONE;
2789 }
2790 program->id = id;
2791
2792 return program;
2793 }
2794
2795 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2796 {
2797 AVChapter *chapter = NULL;
2798 int i;
2799
2800 for(i=0; i<s->nb_chapters; i++)
2801 if(s->chapters[i]->id == id)
2802 chapter = s->chapters[i];
2803
2804 if(!chapter){
2805 chapter= av_mallocz(sizeof(AVChapter));
2806 if(!chapter)
2807 return NULL;
2808 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2809 }
2810 av_dict_set(&chapter->metadata, "title", title, 0);
2811 chapter->id = id;
2812 chapter->time_base= time_base;
2813 chapter->start = start;
2814 chapter->end = end;
2815
2816 return chapter;
2817 }
2818
2819 /************************************************************/
2820 /* output media file */
2821
2822 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2823 {
2824 const AVCodecTag *avctag;
2825 int n;
2826 enum AVCodecID id = AV_CODEC_ID_NONE;
2827 unsigned int tag = 0;
2828
2829 /**
2830 * Check that tag + id is in the table
2831 * If neither is in the table -> OK
2832 * If tag is in the table with another id -> FAIL
2833 * If id is in the table with another tag -> FAIL unless strict < normal
2834 */
2835 for (n = 0; s->oformat->codec_tag[n]; n++) {
2836 avctag = s->oformat->codec_tag[n];
2837 while (avctag->id != AV_CODEC_ID_NONE) {
2838 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2839 id = avctag->id;
2840 if (id == st->codec->codec_id)
2841 return 1;
2842 }
2843 if (avctag->id == st->codec->codec_id)
2844 tag = avctag->tag;
2845 avctag++;
2846 }
2847 }
2848 if (id != AV_CODEC_ID_NONE)
2849 return 0;
2850 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2851 return 0;
2852 return 1;
2853 }
2854
2855 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2856 {
2857 int ret = 0, i;
2858 AVStream *st;
2859 AVDictionary *tmp = NULL;
2860
2861 if (options)
2862 av_dict_copy(&tmp, *options, 0);
2863 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2864 goto fail;
2865
2866 // some sanity checks
2867 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2868 av_log(s, AV_LOG_ERROR, "no streams\n");
2869 ret = AVERROR(EINVAL);
2870 goto fail;
2871 }
2872
2873 for(i=0;i<s->nb_streams;i++) {
2874 st = s->streams[i];
2875
2876 switch (st->codec->codec_type) {
2877 case AVMEDIA_TYPE_AUDIO:
2878 if(st->codec->sample_rate<=0){
2879 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2880 ret = AVERROR(EINVAL);
2881 goto fail;
2882 }
2883 if(!st->codec->block_align)
2884 st->codec->block_align = st->codec->channels *
2885 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2886 break;
2887 case AVMEDIA_TYPE_VIDEO:
2888 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2889 av_log(s, AV_LOG_ERROR, "time base not set\n");
2890 ret = AVERROR(EINVAL);
2891 goto fail;
2892 }
2893 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2894 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2895 ret = AVERROR(EINVAL);
2896 goto fail;
2897 }
2898 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2899 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
2900 "(%d/%d) and encoder layer (%d/%d)\n",
2901 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2902 st->codec->sample_aspect_ratio.num,
2903 st->codec->sample_aspect_ratio.den);
2904 ret = AVERROR(EINVAL);
2905 goto fail;
2906 }
2907 break;
2908 }
2909
2910 if(s->oformat->codec_tag){
2911 if(st->codec->codec_tag && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2912 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2913 st->codec->codec_tag= 0;
2914 }
2915 if(st->codec->codec_tag){
2916 if (!validate_codec_tag(s, st)) {
2917 char tagbuf[32];
2918 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2919 av_log(s, AV_LOG_ERROR,
2920 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2921 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2922 ret = AVERROR_INVALIDDATA;
2923 goto fail;
2924 }
2925 }else
2926 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2927 }
2928
2929 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2930 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2931 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2932 }
2933
2934 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2935 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2936 if (!s->priv_data) {
2937 ret = AVERROR(ENOMEM);
2938 goto fail;
2939 }
2940 if (s->oformat->priv_class) {
2941 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2942 av_opt_set_defaults(s->priv_data);
2943 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2944 goto fail;
2945 }
2946 }
2947
2948 /* set muxer identification string */
2949 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2950 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2951 }
2952
2953 if(s->oformat->write_header){
2954 ret = s->oformat->write_header(s);
2955 if (ret < 0)
2956 goto fail;
2957 }
2958
2959 /* init PTS generation */
2960 for(i=0;i<s->nb_streams;i++) {
2961 int64_t den = AV_NOPTS_VALUE;
2962 st = s->streams[i];
2963
2964 switch (st->codec->codec_type) {
2965 case AVMEDIA_TYPE_AUDIO:
2966 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2967 break;
2968 case AVMEDIA_TYPE_VIDEO:
2969 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2970 break;
2971 default:
2972 break;
2973 }
2974 if (den != AV_NOPTS_VALUE) {
2975 if (den <= 0) {
2976 ret = AVERROR_INVALIDDATA;
2977 goto fail;
2978 }
2979 frac_init(&st->pts, 0, 0, den);
2980 }
2981 }
2982
2983 if (options) {
2984 av_dict_free(options);
2985 *options = tmp;
2986 }
2987 return 0;
2988 fail:
2989 av_dict_free(&tmp);
2990 return ret;
2991 }
2992
2993 //FIXME merge with compute_pkt_fields
2994 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2995 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2996 int num, den, frame_size, i;
2997
2998 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2999 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3000
3001 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3002 return AVERROR(EINVAL);*/
3003
3004 /* duration field */
3005 if (pkt->duration == 0) {
3006 compute_frame_duration(&num, &den, st, NULL, pkt);
3007 if (den && num) {
3008 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3009 }
3010 }
3011
3012 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3013 pkt->pts= pkt->dts;
3014
3015 //XXX/FIXME this is a temporary hack until all encoders output pts
3016 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3017 pkt->dts=
3018 // pkt->pts= st->cur_dts;
3019 pkt->pts= st->pts.val;
3020 }
3021
3022 //calculate dts from pts
3023 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3024 st->pts_buffer[0]= pkt->pts;
3025 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3026 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3027 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3028 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3029
3030 pkt->dts= st->pts_buffer[0];
3031 }
3032
3033 if (st->cur_dts && st->cur_dts != AV_NOPTS_VALUE &&
3034 ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) &&
3035 st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)) {
3036 av_log(s, AV_LOG_ERROR,
3037 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3038 st->index, st->cur_dts, pkt->dts);
3039 return AVERROR(EINVAL);
3040 }
3041 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3042 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3043 return AVERROR(EINVAL);
3044 }
3045
3046 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3047 st->cur_dts= pkt->dts;
3048 st->pts.val= pkt->dts;
3049
3050 /* update pts */
3051 switch (st->codec->codec_type) {
3052 case AVMEDIA_TYPE_AUDIO:
3053 frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3054
3055 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3056 likely equal to the encoder delay, but it would be better if we
3057 had the real timestamps from the encoder */
3058 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3059 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3060 }
3061 break;
3062 case AVMEDIA_TYPE_VIDEO:
3063 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3064 break;
3065 default:
3066 break;
3067 }
3068 return 0;
3069 }
3070
3071 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3072 {
3073 int ret;
3074
3075 if (!pkt) {
3076 if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3077 return s->oformat->write_packet(s, pkt);
3078 return 1;
3079 }
3080
3081 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3082
3083 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3084 return ret;
3085
3086 ret= s->oformat->write_packet(s, pkt);
3087
3088 if (ret >= 0)
3089 s->streams[pkt->stream_index]->nb_frames++;
3090 return ret;
3091 }
3092
3093 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3094 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3095 {
3096 AVPacketList **next_point, *this_pktl;
3097
3098 this_pktl = av_mallocz(sizeof(AVPacketList