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