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