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