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