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