lavf: print a matching tag in case of code tag validation failure
[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 "riff.h"
41 #include "audiointerleave.h"
42 #include "url.h"
43 #include <sys/time.h>
44 #include <time.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) != 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 && !strcmp(fmt->name, short_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 CodecID 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 CodecID codec_id= 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 == 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 CODEC_ID_NONE;
265 }
266
267 AVInputFormat *av_find_input_format(const char *short_name)
268 {
269     AVInputFormat *fmt = NULL;
270     while ((fmt = av_iformat_next(fmt))) {
271         if (match_format(short_name, fmt->name))
272             return fmt;
273     }
274     return NULL;
275 }
276
277 int ffio_limit(AVIOContext *s, int size)
278 {
279     if(s->maxsize>=0){
280         int64_t remaining= s->maxsize - avio_tell(s);
281         if(remaining < size){
282             int64_t newsize= avio_size(s);
283             if(!s->maxsize || s->maxsize<newsize)
284                 s->maxsize= newsize - !newsize;
285             remaining= s->maxsize - avio_tell(s);
286             remaining= FFMAX(remaining, 0);
287         }
288
289         if(s->maxsize>=0 && remaining+1 < size){
290             av_log(0, AV_LOG_ERROR, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
291             size= remaining+1;
292         }
293     }
294     return size;
295 }
296
297 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
298 {
299     int ret;
300     int orig_size = size;
301     size= ffio_limit(s, size);
302
303     ret= av_new_packet(pkt, size);
304
305     if(ret<0)
306         return ret;
307
308     pkt->pos= avio_tell(s);
309
310     ret= avio_read(s, pkt->data, size);
311     if(ret<=0)
312         av_free_packet(pkt);
313     else
314         av_shrink_packet(pkt, ret);
315     if (pkt->size < orig_size)
316         pkt->flags |= AV_PKT_FLAG_CORRUPT;
317
318     return ret;
319 }
320
321 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
322 {
323     int ret;
324     int old_size;
325     if (!pkt->size)
326         return av_get_packet(s, pkt, size);
327     old_size = pkt->size;
328     ret = av_grow_packet(pkt, size);
329     if (ret < 0)
330         return ret;
331     ret = avio_read(s, pkt->data + old_size, size);
332     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
333     return ret;
334 }
335
336
337 int av_filename_number_test(const char *filename)
338 {
339     char buf[1024];
340     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
341 }
342
343 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
344 {
345     AVProbeData lpd = *pd;
346     AVInputFormat *fmt1 = NULL, *fmt;
347     int score, nodat = 0, score_max=0;
348
349     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
350         int id3len = ff_id3v2_tag_len(lpd.buf);
351         if (lpd.buf_size > id3len + 16) {
352             lpd.buf += id3len;
353             lpd.buf_size -= id3len;
354         }else
355             nodat = 1;
356     }
357
358     fmt = NULL;
359     while ((fmt1 = av_iformat_next(fmt1))) {
360         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
361             continue;
362         score = 0;
363         if (fmt1->read_probe) {
364             score = fmt1->read_probe(&lpd);
365             if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
366                 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
367         } else if (fmt1->extensions) {
368             if (av_match_ext(lpd.filename, fmt1->extensions)) {
369                 score = 50;
370             }
371         }
372         if (score > score_max) {
373             score_max = score;
374             fmt = fmt1;
375         }else if (score == score_max)
376             fmt = NULL;
377     }
378     *score_ret= score_max;
379
380     return fmt;
381 }
382
383 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
384 {
385     int score_ret;
386     AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
387     if(score_ret > *score_max){
388         *score_max= score_ret;
389         return fmt;
390     }else
391         return NULL;
392 }
393
394 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
395     int score=0;
396     return av_probe_input_format2(pd, is_opened, &score);
397 }
398
399 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
400 {
401     static const struct {
402         const char *name; enum CodecID id; enum AVMediaType type;
403     } fmt_id_type[] = {
404         { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
405         { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
406         { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
407         { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
408         { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
409         { "loas"     , CODEC_ID_AAC_LATM  , AVMEDIA_TYPE_AUDIO },
410         { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
411         { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
412         { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
413         { 0 }
414     };
415     int score;
416     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
417
418     if (fmt) {
419         int i;
420         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
421                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
422         for (i = 0; fmt_id_type[i].name; i++) {
423             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
424                 st->codec->codec_id   = fmt_id_type[i].id;
425                 st->codec->codec_type = fmt_id_type[i].type;
426                 break;
427             }
428         }
429     }
430     return score;
431 }
432
433 /************************************************************/
434 /* input media file */
435
436 int av_demuxer_open(AVFormatContext *ic){
437     int err;
438
439     if (ic->iformat->read_header) {
440         err = ic->iformat->read_header(ic);
441         if (err < 0)
442             return err;
443     }
444
445     if (ic->pb && !ic->data_offset)
446         ic->data_offset = avio_tell(ic->pb);
447
448     return 0;
449 }
450
451
452 /** size of probe buffer, for guessing file type from file contents */
453 #define PROBE_BUF_MIN 2048
454 #define PROBE_BUF_MAX (1<<20)
455
456 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
457                           const char *filename, void *logctx,
458                           unsigned int offset, unsigned int max_probe_size)
459 {
460     AVProbeData pd = { filename ? filename : "", NULL, -offset };
461     unsigned char *buf = NULL;
462     int ret = 0, probe_size;
463
464     if (!max_probe_size) {
465         max_probe_size = PROBE_BUF_MAX;
466     } else if (max_probe_size > PROBE_BUF_MAX) {
467         max_probe_size = PROBE_BUF_MAX;
468     } else if (max_probe_size < PROBE_BUF_MIN) {
469         return AVERROR(EINVAL);
470     }
471
472     if (offset >= max_probe_size) {
473         return AVERROR(EINVAL);
474     }
475
476     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
477         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
478         int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
479         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
480         void *buftmp;
481
482         if (probe_size < offset) {
483             continue;
484         }
485
486         /* read probe data */
487         buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
488         if(!buftmp){
489             av_free(buf);
490             return AVERROR(ENOMEM);
491         }
492         buf=buftmp;
493         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
494             /* fail if error was not end of file, otherwise, lower score */
495             if (ret != AVERROR_EOF) {
496                 av_free(buf);
497                 return ret;
498             }
499             score = 0;
500             ret = 0;            /* error was end of file, nothing read */
501         }
502         pd.buf_size += ret;
503         pd.buf = &buf[offset];
504
505         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
506
507         /* guess file format */
508         *fmt = av_probe_input_format2(&pd, 1, &score);
509         if(*fmt){
510             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
511                 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
512             }else
513                 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
514         }
515     }
516
517     if (!*fmt) {
518         av_free(buf);
519         return AVERROR_INVALIDDATA;
520     }
521
522     /* rewind. reuse probe buffer to avoid seeking */
523     if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
524         av_free(buf);
525
526     return ret;
527 }
528
529 /* open input file and probe the format if necessary */
530 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
531 {
532     int ret;
533     AVProbeData pd = {filename, NULL, 0};
534
535     if (s->pb) {
536         s->flags |= AVFMT_FLAG_CUSTOM_IO;
537         if (!s->iformat)
538             return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
539         else if (s->iformat->flags & AVFMT_NOFILE)
540             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
541                                       "will be ignored with AVFMT_NOFILE format.\n");
542         return 0;
543     }
544
545     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
546         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
547         return 0;
548
549     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
550                           &s->interrupt_callback, options)) < 0)
551         return ret;
552     if (s->iformat)
553         return 0;
554     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
555 }
556
557 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
558                                AVPacketList **plast_pktl){
559     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
560     if (!pktl)
561         return NULL;
562
563     if (*packet_buffer)
564         (*plast_pktl)->next = pktl;
565     else
566         *packet_buffer = pktl;
567
568     /* add the packet in the buffered packet list */
569     *plast_pktl = pktl;
570     pktl->pkt= *pkt;
571     return &pktl->pkt;
572 }
573
574 static void 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, sizeof(s->filename));
621
622     /* allocate private data */
623     if (s->iformat->priv_data_size > 0) {
624         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
625             ret = AVERROR(ENOMEM);
626             goto fail;
627         }
628         if (s->iformat->priv_class) {
629             *(const AVClass**)s->priv_data = s->iformat->priv_class;
630             av_opt_set_defaults(s->priv_data);
631             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
632                 goto fail;
633         }
634     }
635
636     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
637     if (s->pb)
638         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
639
640     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
641         if ((ret = s->iformat->read_header(s)) < 0)
642             goto fail;
643
644     if (id3v2_extra_meta &&
645         (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
646         goto fail;
647     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
648
649     queue_attached_pictures(s);
650
651     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
652         s->data_offset = avio_tell(s->pb);
653
654     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
655
656     if (options) {
657         av_dict_free(options);
658         *options = tmp;
659     }
660     *ps = s;
661     return 0;
662
663 fail:
664     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
665     av_dict_free(&tmp);
666     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
667         avio_close(s->pb);
668     avformat_free_context(s);
669     *ps = NULL;
670     return ret;
671 }
672
673 /*******************************************************/
674
675 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
676 {
677     int ret, i;
678     AVStream *st;
679
680     for(;;){
681         AVPacketList *pktl = s->raw_packet_buffer;
682
683         if (pktl) {
684             *pkt = pktl->pkt;
685             if(s->streams[pkt->stream_index]->request_probe <= 0){
686                 s->raw_packet_buffer = pktl->next;
687                 s->raw_packet_buffer_remaining_size += pkt->size;
688                 av_free(pktl);
689                 return 0;
690             }
691         }
692
693         av_init_packet(pkt);
694         ret= s->iformat->read_packet(s, pkt);
695         if (ret < 0) {
696             if (!pktl || ret == AVERROR(EAGAIN))
697                 return ret;
698             for (i = 0; i < s->nb_streams; i++)
699                 if(s->streams[i]->request_probe > 0)
700                     s->streams[i]->request_probe = -1;
701             continue;
702         }
703
704         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
705             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
706             av_log(s, AV_LOG_WARNING,
707                    "Dropped corrupted packet (stream = %d)\n",
708                    pkt->stream_index);
709             av_free_packet(pkt);
710             continue;
711         }
712
713         if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
714             av_packet_merge_side_data(pkt);
715
716         if(pkt->stream_index >= (unsigned)s->nb_streams){
717             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
718             continue;
719         }
720
721         st= s->streams[pkt->stream_index];
722
723         switch(st->codec->codec_type){
724         case AVMEDIA_TYPE_VIDEO:
725             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
726             break;
727         case AVMEDIA_TYPE_AUDIO:
728             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
729             break;
730         case AVMEDIA_TYPE_SUBTITLE:
731             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
732             break;
733         }
734
735         if(!pktl && st->request_probe <= 0)
736             return ret;
737
738         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
739         s->raw_packet_buffer_remaining_size -= pkt->size;
740
741         if(st->request_probe>0){
742             AVProbeData *pd = &st->probe_data;
743             int end;
744             av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
745             --st->probe_packets;
746
747             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
748             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
749             pd->buf_size += pkt->size;
750             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
751
752             end=    s->raw_packet_buffer_remaining_size <= 0
753                  || st->probe_packets<=0;
754
755             if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
756                 int score= set_codec_from_probe_data(s, st, pd);
757                 if(    (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
758                     || end){
759                     pd->buf_size=0;
760                     av_freep(&pd->buf);
761                     st->request_probe= -1;
762                     if(st->codec->codec_id != CODEC_ID_NONE){
763                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
764                     }else
765                         av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
766                 }
767             }
768         }
769     }
770 }
771
772 #if FF_API_READ_PACKET
773 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
774 {
775     return ff_read_packet(s, pkt);
776 }
777 #endif
778
779
780 /**********************************************************/
781
782 static int determinable_frame_size(AVCodecContext *avctx)
783 {
784     if (/*avctx->codec_id == CODEC_ID_AAC ||*/
785         avctx->codec_id == CODEC_ID_MP1 ||
786         avctx->codec_id == CODEC_ID_MP2 ||
787         avctx->codec_id == CODEC_ID_MP3/* ||
788         avctx->codec_id == CODEC_ID_CELT*/)
789         return 1;
790     return 0;
791 }
792
793 /**
794  * Get the number of samples of an audio frame. Return -1 on error.
795  */
796 static int get_audio_frame_size(AVCodecContext *enc, int size, int mux)
797 {
798     int frame_size;
799
800     /* give frame_size priority if demuxing */
801     if (!mux && enc->frame_size > 1)
802         return enc->frame_size;
803
804     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
805         return frame_size;
806
807     /* fallback to using frame_size if muxing */
808     if (enc->frame_size > 1)
809         return enc->frame_size;
810
811     return -1;
812 }
813
814
815 /**
816  * Return the frame duration in seconds. Return 0 if not available.
817  */
818 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
819                                    AVCodecParserContext *pc, AVPacket *pkt)
820 {
821     int frame_size;
822
823     *pnum = 0;
824     *pden = 0;
825     switch(st->codec->codec_type) {
826     case AVMEDIA_TYPE_VIDEO:
827         if (st->r_frame_rate.num && !pc) {
828             *pnum = st->r_frame_rate.den;
829             *pden = st->r_frame_rate.num;
830         } else if(st->time_base.num*1000LL > st->time_base.den) {
831             *pnum = st->time_base.num;
832             *pden = st->time_base.den;
833         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
834             *pnum = st->codec->time_base.num;
835             *pden = st->codec->time_base.den;
836             if (pc && pc->repeat_pict) {
837                 *pnum = (*pnum) * (1 + pc->repeat_pict);
838             }
839             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
840             //Thus if we have no parser in such case leave duration undefined.
841             if(st->codec->ticks_per_frame>1 && !pc){
842                 *pnum = *pden = 0;
843             }
844         }
845         break;
846     case AVMEDIA_TYPE_AUDIO:
847         frame_size = get_audio_frame_size(st->codec, pkt->size, 0);
848         if (frame_size <= 0 || st->codec->sample_rate <= 0)
849             break;
850         *pnum = frame_size;
851         *pden = st->codec->sample_rate;
852         break;
853     default:
854         break;
855     }
856 }
857
858 static int is_intra_only(AVCodecContext *enc){
859     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
860         return 1;
861     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
862         switch(enc->codec_id){
863         case CODEC_ID_MJPEG:
864         case CODEC_ID_MJPEGB:
865         case CODEC_ID_LJPEG:
866         case CODEC_ID_PRORES:
867         case CODEC_ID_RAWVIDEO:
868         case CODEC_ID_V210:
869         case CODEC_ID_DVVIDEO:
870         case CODEC_ID_HUFFYUV:
871         case CODEC_ID_FFVHUFF:
872         case CODEC_ID_ASV1:
873         case CODEC_ID_ASV2:
874         case CODEC_ID_VCR1:
875         case CODEC_ID_DNXHD:
876         case CODEC_ID_JPEG2000:
877         case CODEC_ID_UTVIDEO:
878             return 1;
879         default: break;
880         }
881     }
882     return 0;
883 }
884
885 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
886 {
887     if (pktl->next)
888         return pktl->next;
889     if (pktl == s->parse_queue_end)
890         return s->packet_buffer;
891     return NULL;
892 }
893
894 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
895                                       int64_t dts, int64_t pts)
896 {
897     AVStream *st= s->streams[stream_index];
898     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
899
900     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
901         return;
902
903     st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
904     st->cur_dts= dts;
905
906     if (is_relative(pts))
907         pts += st->first_dts - RELATIVE_TS_BASE;
908
909     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
910         if(pktl->pkt.stream_index != stream_index)
911             continue;
912         if(is_relative(pktl->pkt.pts))
913             pktl->pkt.pts += st->first_dts - RELATIVE_TS_BASE;
914
915         if(is_relative(pktl->pkt.dts))
916             pktl->pkt.dts += st->first_dts - RELATIVE_TS_BASE;
917
918         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
919             st->start_time= pktl->pkt.pts;
920     }
921     if (st->start_time == AV_NOPTS_VALUE)
922         st->start_time = pts;
923 }
924
925 static void update_initial_durations(AVFormatContext *s, AVStream *st,
926                                      int stream_index, int duration)
927 {
928     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
929     int64_t cur_dts= RELATIVE_TS_BASE;
930
931     if(st->first_dts != AV_NOPTS_VALUE){
932         cur_dts= st->first_dts;
933         for(; pktl; pktl= get_next_pkt(s, st, pktl)){
934             if(pktl->pkt.stream_index == stream_index){
935                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
936                     break;
937                 cur_dts -= duration;
938             }
939         }
940         pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
941         st->first_dts = cur_dts;
942     }else if(st->cur_dts != RELATIVE_TS_BASE)
943         return;
944
945     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
946         if(pktl->pkt.stream_index != stream_index)
947             continue;
948         if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
949            && !pktl->pkt.duration){
950             pktl->pkt.dts= cur_dts;
951             if(!st->codec->has_b_frames)
952                 pktl->pkt.pts= cur_dts;
953 //            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
954                 pktl->pkt.duration = duration;
955         }else
956             break;
957         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
958     }
959     if(!pktl)
960         st->cur_dts= cur_dts;
961 }
962
963 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
964                                AVCodecParserContext *pc, AVPacket *pkt)
965 {
966     int num, den, presentation_delayed, delay, i;
967     int64_t offset;
968
969     if (s->flags & AVFMT_FLAG_NOFILLIN)
970         return;
971
972     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
973         pkt->dts= AV_NOPTS_VALUE;
974
975     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
976         //FIXME Set low_delay = 0 when has_b_frames = 1
977         st->codec->has_b_frames = 1;
978
979     /* do we have a video B-frame ? */
980     delay= st->codec->has_b_frames;
981     presentation_delayed = 0;
982
983     /* XXX: need has_b_frame, but cannot get it if the codec is
984         not initialized */
985     if (delay &&
986         pc && pc->pict_type != AV_PICTURE_TYPE_B)
987         presentation_delayed = 1;
988
989     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
990         pkt->dts -= 1LL<<st->pts_wrap_bits;
991     }
992
993     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
994     // we take the conservative approach and discard both
995     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
996     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
997         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
998         pkt->dts= AV_NOPTS_VALUE;
999     }
1000
1001     if (pkt->duration == 0) {
1002         compute_frame_duration(&num, &den, st, pc, pkt);
1003         if (den && num) {
1004             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1005         }
1006     }
1007     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1008         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1009
1010     /* correct timestamps with byte offset if demuxers only have timestamps
1011        on packet boundaries */
1012     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1013         /* this will estimate bitrate based on this frame's duration and size */
1014         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1015         if(pkt->pts != AV_NOPTS_VALUE)
1016             pkt->pts += offset;
1017         if(pkt->dts != AV_NOPTS_VALUE)
1018             pkt->dts += offset;
1019     }
1020
1021     if (pc && pc->dts_sync_point >= 0) {
1022         // we have synchronization info from the parser
1023         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1024         if (den > 0) {
1025             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1026             if (pkt->dts != AV_NOPTS_VALUE) {
1027                 // got DTS from the stream, update reference timestamp
1028                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1029                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1030             } else if (st->reference_dts != AV_NOPTS_VALUE) {
1031                 // compute DTS based on reference timestamp
1032                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1033                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1034             }
1035             if (pc->dts_sync_point > 0)
1036                 st->reference_dts = pkt->dts; // new reference
1037         }
1038     }
1039
1040     /* This may be redundant, but it should not hurt. */
1041     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1042         presentation_delayed = 1;
1043
1044 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p duration:%d\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc, pkt->duration);
1045     /* interpolate PTS and DTS if they are not present */
1046     //We skip H264 currently because delay and has_b_frames are not reliably set
1047     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1048         if (presentation_delayed) {
1049             /* DTS = decompression timestamp */
1050             /* PTS = presentation timestamp */
1051             if (pkt->dts == AV_NOPTS_VALUE)
1052                 pkt->dts = st->last_IP_pts;
1053             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1054             if (pkt->dts == AV_NOPTS_VALUE)
1055                 pkt->dts = st->cur_dts;
1056
1057             /* this is tricky: the dts must be incremented by the duration
1058             of the frame we are displaying, i.e. the last I- or P-frame */
1059             if (st->last_IP_duration == 0)
1060                 st->last_IP_duration = pkt->duration;
1061             if(pkt->dts != AV_NOPTS_VALUE)
1062                 st->cur_dts = pkt->dts + st->last_IP_duration;
1063             st->last_IP_duration  = pkt->duration;
1064             st->last_IP_pts= pkt->pts;
1065             /* cannot compute PTS if not present (we can compute it only
1066             by knowing the future */
1067         } else if (pkt->pts != AV_NOPTS_VALUE ||
1068                    pkt->dts != AV_NOPTS_VALUE ||
1069                    pkt->duration                ) {
1070             int duration = pkt->duration;
1071
1072             if(pkt->pts != AV_NOPTS_VALUE && duration){
1073                 int64_t old_diff= FFABS(st->cur_dts - duration - pkt->pts);
1074                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1075                 if(   old_diff < new_diff && old_diff < (duration>>3)
1076                    && (!strcmp(s->iformat->name, "mpeg") ||
1077                        !strcmp(s->iformat->name, "mpegts"))){
1078                     pkt->pts += duration;
1079                     av_log(s, AV_LOG_WARNING, "Adjusting PTS forward\n");
1080     //                av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
1081                 }
1082             }
1083
1084             /* presentation is not delayed : PTS and DTS are the same */
1085             if (pkt->pts == AV_NOPTS_VALUE)
1086                 pkt->pts = pkt->dts;
1087             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1088                                       pkt->pts);
1089             if (pkt->pts == AV_NOPTS_VALUE)
1090                 pkt->pts = st->cur_dts;
1091             pkt->dts = pkt->pts;
1092             if (pkt->pts != AV_NOPTS_VALUE)
1093                 st->cur_dts = pkt->pts + duration;
1094         }
1095     }
1096
1097     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1098         st->pts_buffer[0]= pkt->pts;
1099         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1100             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1101         if(pkt->dts == AV_NOPTS_VALUE)
1102             pkt->dts= st->pts_buffer[0];
1103         if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1104             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1105         }
1106         if(pkt->dts > st->cur_dts)
1107             st->cur_dts = pkt->dts;
1108     }
1109
1110 //    av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1111
1112     /* update flags */
1113     if(is_intra_only(st->codec))
1114         pkt->flags |= AV_PKT_FLAG_KEY;
1115     if (pc)
1116         pkt->convergence_duration = pc->convergence_duration;
1117 }
1118
1119 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1120 {
1121     while (*pkt_buf) {
1122         AVPacketList *pktl = *pkt_buf;
1123         *pkt_buf = pktl->next;
1124         av_free_packet(&pktl->pkt);
1125         av_freep(&pktl);
1126     }
1127     *pkt_buf_end = NULL;
1128 }
1129
1130 /**
1131  * Parse a packet, add all split parts to parse_queue
1132  *
1133  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1134  */
1135 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1136 {
1137     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1138     AVStream     *st = s->streams[stream_index];
1139     uint8_t    *data = pkt ? pkt->data : NULL;
1140     int         size = pkt ? pkt->size : 0;
1141     int ret = 0, got_output = 0;
1142
1143     if (!pkt) {
1144         av_init_packet(&flush_pkt);
1145         pkt = &flush_pkt;
1146         got_output = 1;
1147     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1148         // preserve 0-size sync packets
1149         compute_pkt_fields(s, st, st->parser, pkt);
1150     }
1151
1152     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1153         int len;
1154
1155         av_init_packet(&out_pkt);
1156         len = av_parser_parse2(st->parser,  st->codec,
1157                                &out_pkt.data, &out_pkt.size, data, size,
1158                                pkt->pts, pkt->dts, pkt->pos);
1159
1160         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1161         /* increment read pointer */
1162         data += len;
1163         size -= len;
1164
1165         got_output = !!out_pkt.size;
1166
1167         if (!out_pkt.size)
1168             continue;
1169
1170         /* set the duration */
1171         out_pkt.duration = 0;
1172         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1173             if (st->codec->sample_rate > 0) {
1174                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1175                                                     (AVRational){ 1, st->codec->sample_rate },
1176                                                     st->time_base,
1177                                                     AV_ROUND_DOWN);
1178             }
1179         } else if (st->codec->time_base.num != 0 &&
1180                    st->codec->time_base.den != 0) {
1181             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1182                                                 st->codec->time_base,
1183                                                 st->time_base,
1184                                                 AV_ROUND_DOWN);
1185         }
1186
1187         out_pkt.stream_index = st->index;
1188         out_pkt.pts = st->parser->pts;
1189         out_pkt.dts = st->parser->dts;
1190         out_pkt.pos = st->parser->pos;
1191
1192         if (st->parser->key_frame == 1 ||
1193             (st->parser->key_frame == -1 &&
1194              st->parser->pict_type == AV_PICTURE_TYPE_I))
1195             out_pkt.flags |= AV_PKT_FLAG_KEY;
1196
1197         compute_pkt_fields(s, st, st->parser, &out_pkt);
1198
1199         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1200             out_pkt.flags & AV_PKT_FLAG_KEY) {
1201             int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? out_pkt.pos : st->parser->frame_offset;
1202             ff_reduce_index(s, st->index);
1203             av_add_index_entry(st, pos, out_pkt.dts,
1204                                0, 0, AVINDEX_KEYFRAME);
1205         }
1206
1207         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1208             out_pkt.destruct = pkt->destruct;
1209             pkt->destruct = NULL;
1210         }
1211         if ((ret = av_dup_packet(&out_pkt)) < 0)
1212             goto fail;
1213
1214         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1215             av_free_packet(&out_pkt);
1216             ret = AVERROR(ENOMEM);
1217             goto fail;
1218         }
1219     }
1220
1221
1222     /* end of the stream => close and free the parser */
1223     if (pkt == &flush_pkt) {
1224         av_parser_close(st->parser);
1225         st->parser = NULL;
1226     }
1227
1228 fail:
1229     av_free_packet(pkt);
1230     return ret;
1231 }
1232
1233 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1234                                    AVPacketList **pkt_buffer_end,
1235                                    AVPacket      *pkt)
1236 {
1237     AVPacketList *pktl;
1238     av_assert0(*pkt_buffer);
1239     pktl = *pkt_buffer;
1240     *pkt = pktl->pkt;
1241     *pkt_buffer = pktl->next;
1242     if (!pktl->next)
1243         *pkt_buffer_end = NULL;
1244     av_freep(&pktl);
1245     return 0;
1246 }
1247
1248 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1249 {
1250     int ret = 0, i, got_packet = 0;
1251
1252     av_init_packet(pkt);
1253
1254     while (!got_packet && !s->parse_queue) {
1255         AVStream *st;
1256         AVPacket cur_pkt;
1257
1258         /* read next packet */
1259         ret = ff_read_packet(s, &cur_pkt);
1260         if (ret < 0) {
1261             if (ret == AVERROR(EAGAIN))
1262                 return ret;
1263             /* flush the parsers */
1264             for(i = 0; i < s->nb_streams; i++) {
1265                 st = s->streams[i];
1266                 if (st->parser && st->need_parsing)
1267                     parse_packet(s, NULL, st->index);
1268             }
1269             /* all remaining packets are now in parse_queue =>
1270              * really terminate parsing */
1271             break;
1272         }
1273         ret = 0;
1274         st  = s->streams[cur_pkt.stream_index];
1275
1276         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1277             cur_pkt.dts != AV_NOPTS_VALUE &&
1278             cur_pkt.pts < cur_pkt.dts) {
1279             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1280                    cur_pkt.stream_index,
1281                    cur_pkt.pts,
1282                    cur_pkt.dts,
1283                    cur_pkt.size);
1284         }
1285         if (s->debug & FF_FDEBUG_TS)
1286             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1287                    cur_pkt.stream_index,
1288                    cur_pkt.pts,
1289                    cur_pkt.dts,
1290                    cur_pkt.size,
1291                    cur_pkt.duration,
1292                    cur_pkt.flags);
1293
1294         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1295             st->parser = av_parser_init(st->codec->codec_id);
1296             if (!st->parser) {
1297                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1298                        "%s, packets or times may be invalid.\n",
1299                        avcodec_get_name(st->codec->codec_id));
1300                 /* no parser available: just output the raw packets */
1301                 st->need_parsing = AVSTREAM_PARSE_NONE;
1302             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1303                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1304             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1305                 st->parser->flags |= PARSER_FLAG_ONCE;
1306             }
1307         }
1308
1309         if (!st->need_parsing || !st->parser) {
1310             /* no parsing needed: we just output the packet as is */
1311             *pkt = cur_pkt;
1312             compute_pkt_fields(s, st, NULL, pkt);
1313             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1314                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1315                 ff_reduce_index(s, st->index);
1316                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1317             }
1318             got_packet = 1;
1319         } else if (st->discard < AVDISCARD_ALL) {
1320             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1321                 return ret;
1322         } else {
1323             /* free packet */
1324             av_free_packet(&cur_pkt);
1325         }
1326         if (pkt->flags & AV_PKT_FLAG_KEY)
1327             st->skip_to_keyframe = 0;
1328         if (st->skip_to_keyframe) {
1329             av_free_packet(&cur_pkt);
1330             got_packet = 0;
1331         }
1332     }
1333
1334     if (!got_packet && s->parse_queue)
1335         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1336
1337     if(s->debug & FF_FDEBUG_TS)
1338         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1339             pkt->stream_index,
1340             pkt->pts,
1341             pkt->dts,
1342             pkt->size,
1343             pkt->duration,
1344             pkt->flags);
1345
1346     return ret;
1347 }
1348
1349 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1350 {
1351     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1352     int          eof = 0;
1353     int ret;
1354
1355     if (!genpts) {
1356         ret = s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1357                                                           &s->packet_buffer_end,
1358                                                           pkt) :
1359                                   read_frame_internal(s, pkt);
1360         goto return_packet;
1361     }
1362
1363     for (;;) {
1364         AVPacketList *pktl = s->packet_buffer;
1365
1366         if (pktl) {
1367             AVPacket *next_pkt = &pktl->pkt;
1368
1369             if (next_pkt->dts != AV_NOPTS_VALUE) {
1370                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1371                 // last dts seen for this stream. if any of packets following
1372                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1373                 int64_t last_dts = next_pkt->dts;
1374                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1375                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1376                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1377                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1378                             next_pkt->pts = pktl->pkt.dts;
1379                         }
1380                         if (last_dts != AV_NOPTS_VALUE) {
1381                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1382                             last_dts = pktl->pkt.dts;
1383                         }
1384                     }
1385                     pktl = pktl->next;
1386                 }
1387                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1388                     // Fixing the last reference frame had none pts issue (For MXF etc).
1389                     // We only do this when
1390                     // 1. eof.
1391                     // 2. we are not able to resolve a pts value for current packet.
1392                     // 3. the packets for this stream at the end of the files had valid dts.
1393                     next_pkt->pts = last_dts + next_pkt->duration;
1394                 }
1395                 pktl = s->packet_buffer;
1396             }
1397
1398             /* read packet from packet buffer, if there is data */
1399             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1400                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1401                 ret = read_from_packet_buffer(&s->packet_buffer,
1402                                                &s->packet_buffer_end, pkt);
1403                 goto return_packet;
1404             }
1405         }
1406
1407         ret = read_frame_internal(s, pkt);
1408         if (ret < 0) {
1409             if (pktl && ret != AVERROR(EAGAIN)) {
1410                 eof = 1;
1411                 continue;
1412             } else
1413                 return ret;
1414         }
1415
1416         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1417                           &s->packet_buffer_end)) < 0)
1418             return AVERROR(ENOMEM);
1419     }
1420
1421 return_packet:
1422     if (is_relative(pkt->dts))
1423         pkt->dts -= RELATIVE_TS_BASE;
1424     if (is_relative(pkt->pts))
1425         pkt->pts -= RELATIVE_TS_BASE;
1426     return ret;
1427 }
1428
1429 /* XXX: suppress the packet queue */
1430 static void flush_packet_queue(AVFormatContext *s)
1431 {
1432     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1433     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1434     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1435
1436     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1437 }
1438
1439 /*******************************************************/
1440 /* seek support */
1441
1442 int av_find_default_stream_index(AVFormatContext *s)
1443 {
1444     int first_audio_index = -1;
1445     int i;
1446     AVStream *st;
1447
1448     if (s->nb_streams <= 0)
1449         return -1;
1450     for(i = 0; i < s->nb_streams; i++) {
1451         st = s->streams[i];
1452         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1453             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1454             return i;
1455         }
1456         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1457             first_audio_index = i;
1458     }
1459     return first_audio_index >= 0 ? first_audio_index : 0;
1460 }
1461
1462 /**
1463  * Flush the frame reader.
1464  */
1465 void ff_read_frame_flush(AVFormatContext *s)
1466 {
1467     AVStream *st;
1468     int i, j;
1469
1470     flush_packet_queue(s);
1471
1472     /* for each stream, reset read state */
1473     for(i = 0; i < s->nb_streams; i++) {
1474         st = s->streams[i];
1475
1476         if (st->parser) {
1477             av_parser_close(st->parser);
1478             st->parser = NULL;
1479         }
1480         st->last_IP_pts = AV_NOPTS_VALUE;
1481         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1482         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1483         st->reference_dts = AV_NOPTS_VALUE;
1484
1485         st->probe_packets = MAX_PROBE_PACKETS;
1486
1487         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1488             st->pts_buffer[j]= AV_NOPTS_VALUE;
1489     }
1490 }
1491
1492 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1493 {
1494     int i;
1495
1496     for(i = 0; i < s->nb_streams; i++) {
1497         AVStream *st = s->streams[i];
1498
1499         st->cur_dts = av_rescale(timestamp,
1500                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1501                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1502     }
1503 }
1504
1505 void ff_reduce_index(AVFormatContext *s, int stream_index)
1506 {
1507     AVStream *st= s->streams[stream_index];
1508     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1509
1510     if((unsigned)st->nb_index_entries >= max_entries){
1511         int i;
1512         for(i=0; 2*i<st->nb_index_entries; i++)
1513             st->index_entries[i]= st->index_entries[2*i];
1514         st->nb_index_entries= i;
1515     }
1516 }
1517
1518 int ff_add_index_entry(AVIndexEntry **index_entries,
1519                        int *nb_index_entries,
1520                        unsigned int *index_entries_allocated_size,
1521                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1522 {
1523     AVIndexEntry *entries, *ie;
1524     int index;
1525
1526     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1527         return -1;
1528
1529     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1530         timestamp -= RELATIVE_TS_BASE;
1531
1532     entries = av_fast_realloc(*index_entries,
1533                               index_entries_allocated_size,
1534                               (*nb_index_entries + 1) *
1535                               sizeof(AVIndexEntry));
1536     if(!entries)
1537         return -1;
1538
1539     *index_entries= entries;
1540
1541     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1542
1543     if(index<0){
1544         index= (*nb_index_entries)++;
1545         ie= &entries[index];
1546         assert(index==0 || ie[-1].timestamp < timestamp);
1547     }else{
1548         ie= &entries[index];
1549         if(ie->timestamp != timestamp){
1550             if(ie->timestamp <= timestamp)
1551                 return -1;
1552             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1553             (*nb_index_entries)++;
1554         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1555             distance= ie->min_distance;
1556     }
1557
1558     ie->pos = pos;
1559     ie->timestamp = timestamp;
1560     ie->min_distance= distance;
1561     ie->size= size;
1562     ie->flags = flags;
1563
1564     return index;
1565 }
1566
1567 int av_add_index_entry(AVStream *st,
1568                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1569 {
1570     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1571                               &st->index_entries_allocated_size, pos,
1572                               timestamp, size, distance, flags);
1573 }
1574
1575 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1576                               int64_t wanted_timestamp, int flags)
1577 {
1578     int a, b, m;
1579     int64_t timestamp;
1580
1581     a = - 1;
1582     b = nb_entries;
1583
1584     //optimize appending index entries at the end
1585     if(b && entries[b-1].timestamp < wanted_timestamp)
1586         a= b-1;
1587
1588     while (b - a > 1) {
1589         m = (a + b) >> 1;
1590         timestamp = entries[m].timestamp;
1591         if(timestamp >= wanted_timestamp)
1592             b = m;
1593         if(timestamp <= wanted_timestamp)
1594             a = m;
1595     }
1596     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1597
1598     if(!(flags & AVSEEK_FLAG_ANY)){
1599         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1600             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1601         }
1602     }
1603
1604     if(m == nb_entries)
1605         return -1;
1606     return  m;
1607 }
1608
1609 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1610                               int flags)
1611 {
1612     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1613                                      wanted_timestamp, flags);
1614 }
1615
1616 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1617 {
1618     AVInputFormat *avif= s->iformat;
1619     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1620     int64_t ts_min, ts_max, ts;
1621     int index;
1622     int64_t ret;
1623     AVStream *st;
1624
1625     if (stream_index < 0)
1626         return -1;
1627
1628     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1629
1630     ts_max=
1631     ts_min= AV_NOPTS_VALUE;
1632     pos_limit= -1; //gcc falsely says it may be uninitialized
1633
1634     st= s->streams[stream_index];
1635     if(st->index_entries){
1636         AVIndexEntry *e;
1637
1638         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()
1639         index= FFMAX(index, 0);
1640         e= &st->index_entries[index];
1641
1642         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1643             pos_min= e->pos;
1644             ts_min= e->timestamp;
1645             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1646                     pos_min,ts_min);
1647         }else{
1648             assert(index==0);
1649         }
1650
1651         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1652         assert(index < st->nb_index_entries);
1653         if(index >= 0){
1654             e= &st->index_entries[index];
1655             assert(e->timestamp >= target_ts);
1656             pos_max= e->pos;
1657             ts_max= e->timestamp;
1658             pos_limit= pos_max - e->min_distance;
1659             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1660                     pos_max,pos_limit, ts_max);
1661         }
1662     }
1663
1664     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1665     if(pos<0)
1666         return -1;
1667
1668     /* do the seek */
1669     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1670         return ret;
1671
1672     ff_read_frame_flush(s);
1673     ff_update_cur_dts(s, st, ts);
1674
1675     return 0;
1676 }
1677
1678 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1679                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1680                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1681                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1682 {
1683     int64_t pos, ts;
1684     int64_t start_pos, filesize;
1685     int no_change;
1686
1687     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1688
1689     if(ts_min == AV_NOPTS_VALUE){
1690         pos_min = s->data_offset;
1691         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1692         if (ts_min == AV_NOPTS_VALUE)
1693             return -1;
1694     }
1695
1696     if(ts_min >= target_ts){
1697         *ts_ret= ts_min;
1698         return pos_min;
1699     }
1700
1701     if(ts_max == AV_NOPTS_VALUE){
1702         int step= 1024;
1703         filesize = avio_size(s->pb);
1704         pos_max = filesize - 1;
1705         do{
1706             pos_max -= step;
1707             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1708             step += step;
1709         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1710         if (ts_max == AV_NOPTS_VALUE)
1711             return -1;
1712
1713         for(;;){
1714             int64_t tmp_pos= pos_max + 1;
1715             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1716             if(tmp_ts == AV_NOPTS_VALUE)
1717                 break;
1718             ts_max= tmp_ts;
1719             pos_max= tmp_pos;
1720             if(tmp_pos >= filesize)
1721                 break;
1722         }
1723         pos_limit= pos_max;
1724     }
1725
1726     if(ts_max <= target_ts){
1727         *ts_ret= ts_max;
1728         return pos_max;
1729     }
1730
1731     if(ts_min > ts_max){
1732         return -1;
1733     }else if(ts_min == ts_max){
1734         pos_limit= pos_min;
1735     }
1736
1737     no_change=0;
1738     while (pos_min < pos_limit) {
1739         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1740                 pos_min, pos_max, ts_min, ts_max);
1741         assert(pos_limit <= pos_max);
1742
1743         if(no_change==0){
1744             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1745             // interpolate position (better than dichotomy)
1746             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1747                 + pos_min - approximate_keyframe_distance;
1748         }else if(no_change==1){
1749             // bisection, if interpolation failed to change min or max pos last time
1750             pos = (pos_min + pos_limit)>>1;
1751         }else{
1752             /* linear search if bisection failed, can only happen if there
1753                are very few or no keyframes between min/max */
1754             pos=pos_min;
1755         }
1756         if(pos <= pos_min)
1757             pos= pos_min + 1;
1758         else if(pos > pos_limit)
1759             pos= pos_limit;
1760         start_pos= pos;
1761
1762         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1763         if(pos == pos_max)
1764             no_change++;
1765         else
1766             no_change=0;
1767         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1768                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1769                 pos_limit, start_pos, no_change);
1770         if(ts == AV_NOPTS_VALUE){
1771             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1772             return -1;
1773         }
1774         assert(ts != AV_NOPTS_VALUE);
1775         if (target_ts <= ts) {
1776             pos_limit = start_pos - 1;
1777             pos_max = pos;
1778             ts_max = ts;
1779         }
1780         if (target_ts >= ts) {
1781             pos_min = pos;
1782             ts_min = ts;
1783         }
1784     }
1785
1786     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1787     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1788 #if 0
1789     pos_min = pos;
1790     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1791     pos_min++;
1792     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1793     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1794             pos, ts_min, target_ts, ts_max);
1795 #endif
1796     *ts_ret= ts;
1797     return pos;
1798 }
1799
1800 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1801     int64_t pos_min, pos_max;
1802
1803     pos_min = s->data_offset;
1804     pos_max = avio_size(s->pb) - 1;
1805
1806     if     (pos < pos_min) pos= pos_min;
1807     else if(pos > pos_max) pos= pos_max;
1808
1809     avio_seek(s->pb, pos, SEEK_SET);
1810
1811     return 0;
1812 }
1813
1814 static int seek_frame_generic(AVFormatContext *s,
1815                                  int stream_index, int64_t timestamp, int flags)
1816 {
1817     int index;
1818     int64_t ret;
1819     AVStream *st;
1820     AVIndexEntry *ie;
1821
1822     st = s->streams[stream_index];
1823
1824     index = av_index_search_timestamp(st, timestamp, flags);
1825
1826     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1827         return -1;
1828
1829     if(index < 0 || index==st->nb_index_entries-1){
1830         AVPacket pkt;
1831         int nonkey=0;
1832
1833         if(st->nb_index_entries){
1834             assert(st->index_entries);
1835             ie= &st->index_entries[st->nb_index_entries-1];
1836             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1837                 return ret;
1838             ff_update_cur_dts(s, st, ie->timestamp);
1839         }else{
1840             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1841                 return ret;
1842         }
1843         for (;;) {
1844             int read_status;
1845             do{
1846                 read_status = av_read_frame(s, &pkt);
1847             } while (read_status == AVERROR(EAGAIN));
1848             if (read_status < 0)
1849                 break;
1850             av_free_packet(&pkt);
1851             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1852                 if(pkt.flags & AV_PKT_FLAG_KEY)
1853                     break;
1854                 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1855                     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);
1856                     break;
1857                 }
1858             }
1859         }
1860         index = av_index_search_timestamp(st, timestamp, flags);
1861     }
1862     if (index < 0)
1863         return -1;
1864
1865     ff_read_frame_flush(s);
1866     AV_NOWARN_DEPRECATED(
1867     if (s->iformat->read_seek){
1868         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1869             return 0;
1870     }
1871     )
1872     ie = &st->index_entries[index];
1873     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1874         return ret;
1875     ff_update_cur_dts(s, st, ie->timestamp);
1876
1877     return 0;
1878 }
1879
1880 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1881                                int64_t timestamp, int flags)
1882 {
1883     int ret;
1884     AVStream *st;
1885
1886     if (flags & AVSEEK_FLAG_BYTE) {
1887         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1888             return -1;
1889         ff_read_frame_flush(s);
1890         return seek_frame_byte(s, stream_index, timestamp, flags);
1891     }
1892
1893     if(stream_index < 0){
1894         stream_index= av_find_default_stream_index(s);
1895         if(stream_index < 0)
1896             return -1;
1897
1898         st= s->streams[stream_index];
1899         /* timestamp for default must be expressed in AV_TIME_BASE units */
1900         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1901     }
1902
1903     /* first, we try the format specific seek */
1904     AV_NOWARN_DEPRECATED(
1905     if (s->iformat->read_seek) {
1906         ff_read_frame_flush(s);
1907         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1908     } else
1909         ret = -1;
1910     )
1911     if (ret >= 0) {
1912         return 0;
1913     }
1914
1915     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1916         ff_read_frame_flush(s);
1917         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1918     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1919         ff_read_frame_flush(s);
1920         return seek_frame_generic(s, stream_index, timestamp, flags);
1921     }
1922     else
1923         return -1;
1924 }
1925
1926 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1927 {
1928     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1929
1930     if (ret >= 0)
1931         queue_attached_pictures(s);
1932
1933     return ret;
1934 }
1935
1936 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1937 {
1938     if(min_ts > ts || max_ts < ts)
1939         return -1;
1940
1941     if (s->iformat->read_seek2) {
1942         int ret;
1943         ff_read_frame_flush(s);
1944         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1945
1946         if (ret >= 0)
1947             queue_attached_pictures(s);
1948         return ret;
1949     }
1950
1951     if(s->iformat->read_timestamp){
1952         //try to seek via read_timestamp()
1953     }
1954
1955     //Fallback to old API if new is not implemented but old is
1956     //Note the old has somewat different sematics
1957     AV_NOWARN_DEPRECATED(
1958     if (s->iformat->read_seek || 1) {
1959         int dir = (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0);
1960         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
1961         if (ret<0 && ts != min_ts && max_ts != ts) {
1962             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
1963             if (ret >= 0)
1964                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
1965         }
1966         return ret;
1967     }
1968     )
1969
1970     // try some generic seek like seek_frame_generic() but with new ts semantics
1971 }
1972
1973 /*******************************************************/
1974
1975 /**
1976  * Return TRUE if the stream has accurate duration in any stream.
1977  *
1978  * @return TRUE if the stream has accurate duration for at least one component.
1979  */
1980 static int has_duration(AVFormatContext *ic)
1981 {
1982     int i;
1983     AVStream *st;
1984
1985     for(i = 0;i < ic->nb_streams; i++) {
1986         st = ic->streams[i];
1987         if (st->duration != AV_NOPTS_VALUE)
1988             return 1;
1989     }
1990     if (ic->duration != AV_NOPTS_VALUE)
1991         return 1;
1992     return 0;
1993 }
1994
1995 /**
1996  * Estimate the stream timings from the one of each components.
1997  *
1998  * Also computes the global bitrate if possible.
1999  */
2000 static void update_stream_timings(AVFormatContext *ic)
2001 {
2002     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2003     int64_t duration, duration1, filesize;
2004     int i;
2005     AVStream *st;
2006
2007     start_time = INT64_MAX;
2008     start_time_text = INT64_MAX;
2009     end_time = INT64_MIN;
2010     duration = INT64_MIN;
2011     for(i = 0;i < ic->nb_streams; i++) {
2012         st = ic->streams[i];
2013         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2014             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2015             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2016                 if (start_time1 < start_time_text)
2017                     start_time_text = start_time1;
2018             } else
2019             start_time = FFMIN(start_time, start_time1);
2020             if (st->duration != AV_NOPTS_VALUE) {
2021                 end_time1 = start_time1
2022                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2023                 end_time = FFMAX(end_time, end_time1);
2024             }
2025         }
2026         if (st->duration != AV_NOPTS_VALUE) {
2027             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2028             duration = FFMAX(duration, duration1);
2029         }
2030     }
2031     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2032         start_time = start_time_text;
2033     if (start_time != INT64_MAX) {
2034         ic->start_time = start_time;
2035         if (end_time != INT64_MIN)
2036             duration = FFMAX(duration, end_time - start_time);
2037     }
2038     if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
2039         ic->duration = duration;
2040     }
2041         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2042             /* compute the bitrate */
2043             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2044                 (double)ic->duration;
2045         }
2046 }
2047
2048 static void fill_all_stream_timings(AVFormatContext *ic)
2049 {
2050     int i;
2051     AVStream *st;
2052
2053     update_stream_timings(ic);
2054     for(i = 0;i < ic->nb_streams; i++) {
2055         st = ic->streams[i];
2056         if (st->start_time == AV_NOPTS_VALUE) {
2057             if(ic->start_time != AV_NOPTS_VALUE)
2058                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2059             if(ic->duration != AV_NOPTS_VALUE)
2060                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2061         }
2062     }
2063 }
2064
2065 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2066 {
2067     int64_t filesize, duration;
2068     int bit_rate, i;
2069     AVStream *st;
2070
2071     /* if bit_rate is already set, we believe it */
2072     if (ic->bit_rate <= 0) {
2073         bit_rate = 0;
2074         for(i=0;i<ic->nb_streams;i++) {
2075             st = ic->streams[i];
2076             if (st->codec->bit_rate > 0)
2077             bit_rate += st->codec->bit_rate;
2078         }
2079         ic->bit_rate = bit_rate;
2080     }
2081
2082     /* if duration is already set, we believe it */
2083     if (ic->duration == AV_NOPTS_VALUE &&
2084         ic->bit_rate != 0) {
2085         filesize = ic->pb ? avio_size(ic->pb) : 0;
2086         if (filesize > 0) {
2087             for(i = 0; i < ic->nb_streams; i++) {
2088                 st = ic->streams[i];
2089                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2090                 if (st->duration == AV_NOPTS_VALUE)
2091                     st->duration = duration;
2092             }
2093         }
2094     }
2095 }
2096
2097 #define DURATION_MAX_READ_SIZE 250000
2098 #define DURATION_MAX_RETRY 3
2099
2100 /* only usable for MPEG-PS streams */
2101 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2102 {
2103     AVPacket pkt1, *pkt = &pkt1;
2104     AVStream *st;
2105     int read_size, i, ret;
2106     int64_t end_time;
2107     int64_t filesize, offset, duration;
2108     int retry=0;
2109
2110     /* flush packet queue */
2111     flush_packet_queue(ic);
2112
2113     for (i=0; i<ic->nb_streams; i++) {
2114         st = ic->streams[i];
2115         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2116             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2117
2118         if (st->parser) {
2119             av_parser_close(st->parser);
2120             st->parser= NULL;
2121         }
2122     }
2123
2124     /* estimate the end time (duration) */
2125     /* XXX: may need to support wrapping */
2126     filesize = ic->pb ? avio_size(ic->pb) : 0;
2127     end_time = AV_NOPTS_VALUE;
2128     do{
2129         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2130         if (offset < 0)
2131             offset = 0;
2132
2133         avio_seek(ic->pb, offset, SEEK_SET);
2134         read_size = 0;
2135         for(;;) {
2136             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2137                 break;
2138
2139             do {
2140                 ret = ff_read_packet(ic, pkt);
2141             } while(ret == AVERROR(EAGAIN));
2142             if (ret != 0)
2143                 break;
2144             read_size += pkt->size;
2145             st = ic->streams[pkt->stream_index];
2146             if (pkt->pts != AV_NOPTS_VALUE &&
2147                 (st->start_time != AV_NOPTS_VALUE ||
2148                  st->first_dts  != AV_NOPTS_VALUE)) {
2149                 duration = end_time = pkt->pts;
2150                 if (st->start_time != AV_NOPTS_VALUE)
2151                     duration -= st->start_time;
2152                 else
2153                     duration -= st->first_dts;
2154                 if (duration < 0)
2155                     duration += 1LL<<st->pts_wrap_bits;
2156                 if (duration > 0) {
2157                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2158                         st->duration = duration;
2159                 }
2160             }
2161             av_free_packet(pkt);
2162         }
2163     }while(   end_time==AV_NOPTS_VALUE
2164            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2165            && ++retry <= DURATION_MAX_RETRY);
2166
2167     fill_all_stream_timings(ic);
2168
2169     avio_seek(ic->pb, old_offset, SEEK_SET);
2170     for (i=0; i<ic->nb_streams; i++) {
2171         st= ic->streams[i];
2172         st->cur_dts= st->first_dts;
2173         st->last_IP_pts = AV_NOPTS_VALUE;
2174         st->reference_dts = AV_NOPTS_VALUE;
2175     }
2176 }
2177
2178 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2179 {
2180     int64_t file_size;
2181
2182     /* get the file size, if possible */
2183     if (ic->iformat->flags & AVFMT_NOFILE) {
2184         file_size = 0;
2185     } else {
2186         file_size = avio_size(ic->pb);
2187         file_size = FFMAX(0, file_size);
2188     }
2189
2190     if ((!strcmp(ic->iformat->name, "mpeg") ||
2191          !strcmp(ic->iformat->name, "mpegts")) &&
2192         file_size && ic->pb->seekable) {
2193         /* get accurate estimate from the PTSes */
2194         estimate_timings_from_pts(ic, old_offset);
2195     } else if (has_duration(ic)) {
2196         /* at least one component has timings - we use them for all
2197            the components */
2198         fill_all_stream_timings(ic);
2199     } else {
2200         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2201         /* less precise: use bitrate info */
2202         estimate_timings_from_bit_rate(ic);
2203     }
2204     update_stream_timings(ic);
2205
2206     {
2207         int i;
2208         AVStream av_unused *st;
2209         for(i = 0;i < ic->nb_streams; i++) {
2210             st = ic->streams[i];
2211             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2212                     (double) st->start_time / AV_TIME_BASE,
2213                     (double) st->duration   / AV_TIME_BASE);
2214         }
2215         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2216                 (double) ic->start_time / AV_TIME_BASE,
2217                 (double) ic->duration   / AV_TIME_BASE,
2218                 ic->bit_rate / 1000);
2219     }
2220 }
2221
2222 static int has_codec_parameters(AVStream *st)
2223 {
2224     AVCodecContext *avctx = st->codec;
2225     int val;
2226     switch (avctx->codec_type) {
2227     case AVMEDIA_TYPE_AUDIO:
2228         val = avctx->sample_rate && avctx->channels;
2229         if (!avctx->frame_size && determinable_frame_size(avctx))
2230             return 0;
2231         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2232             return 0;
2233         break;
2234     case AVMEDIA_TYPE_VIDEO:
2235         val = avctx->width;
2236         if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2237             return 0;
2238         break;
2239     case AVMEDIA_TYPE_DATA:
2240         if(avctx->codec_id == CODEC_ID_NONE) return 1;
2241     default:
2242         val = 1;
2243         break;
2244     }
2245     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2246 }
2247
2248 static int has_decode_delay_been_guessed(AVStream *st)
2249 {
2250     return st->codec->codec_id != CODEC_ID_H264 ||
2251         st->info->nb_decoded_frames >= 6;
2252 }
2253
2254 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2255 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2256 {
2257     AVCodec *codec;
2258     int got_picture = 1, ret = 0;
2259     AVFrame picture;
2260     AVPacket pkt = *avpkt;
2261
2262     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2263         AVDictionary *thread_opt = NULL;
2264
2265         codec = st->codec->codec ? st->codec->codec :
2266                                    avcodec_find_decoder(st->codec->codec_id);
2267
2268         if (!codec) {
2269             st->info->found_decoder = -1;
2270             return -1;
2271         }
2272
2273         /* force thread count to 1 since the h264 decoder will not extract SPS
2274          *  and PPS to extradata during multi-threaded decoding */
2275         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2276         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2277         if (!options)
2278             av_dict_free(&thread_opt);
2279         if (ret < 0) {
2280             st->info->found_decoder = -1;
2281             return ret;
2282         }
2283         st->info->found_decoder = 1;
2284     } else if (!st->info->found_decoder)
2285         st->info->found_decoder = 1;
2286
2287     if (st->info->found_decoder < 0)
2288         return -1;
2289
2290     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2291            ret >= 0 &&
2292            (!has_codec_parameters(st)         ||
2293            !has_decode_delay_been_guessed(st) ||
2294            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2295         got_picture = 0;
2296         avcodec_get_frame_defaults(&picture);
2297         switch(st->codec->codec_type) {
2298         case AVMEDIA_TYPE_VIDEO:
2299             ret = avcodec_decode_video2(st->codec, &picture,
2300                                         &got_picture, &pkt);
2301             break;
2302         case AVMEDIA_TYPE_AUDIO:
2303             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2304             break;
2305         default:
2306             break;
2307         }
2308         if (ret >= 0) {
2309             if (got_picture)
2310                 st->info->nb_decoded_frames++;
2311             pkt.data += ret;
2312             pkt.size -= ret;
2313             ret       = got_picture;
2314         }
2315     }
2316     if(!pkt.data && !got_picture)
2317         return -1;
2318     return ret;
2319 }
2320
2321 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2322 {
2323     while (tags->id != CODEC_ID_NONE) {
2324         if (tags->id == id)
2325             return tags->tag;
2326         tags++;
2327     }
2328     return 0;
2329 }
2330
2331 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2332 {
2333     int i;
2334     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2335         if(tag == tags[i].tag)
2336             return tags[i].id;
2337     }
2338     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2339         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2340             return tags[i].id;
2341     }
2342     return CODEC_ID_NONE;
2343 }
2344
2345 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2346 {
2347     int i;
2348     for(i=0; tags && tags[i]; i++){
2349         int tag= ff_codec_get_tag(tags[i], id);
2350         if(tag) return tag;
2351     }
2352     return 0;
2353 }
2354
2355 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2356 {
2357     int i;
2358     for(i=0; tags && tags[i]; i++){
2359         enum CodecID id= ff_codec_get_id(tags[i], tag);
2360         if(id!=CODEC_ID_NONE) return id;
2361     }
2362     return CODEC_ID_NONE;
2363 }
2364
2365 static void compute_chapters_end(AVFormatContext *s)
2366 {
2367     unsigned int i, j;
2368     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2369
2370     for (i = 0; i < s->nb_chapters; i++)
2371         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2372             AVChapter *ch = s->chapters[i];
2373             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2374                                      : INT64_MAX;
2375
2376             for (j = 0; j < s->nb_chapters; j++) {
2377                 AVChapter *ch1 = s->chapters[j];
2378                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2379                 if (j != i && next_start > ch->start && next_start < end)
2380                     end = next_start;
2381             }
2382             ch->end = (end == INT64_MAX) ? ch->start : end;
2383         }
2384 }
2385
2386 static int get_std_framerate(int i){
2387     if(i<60*12) return i*1001;
2388     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2389 }
2390
2391 /*
2392  * Is the time base unreliable.
2393  * This is a heuristic to balance between quick acceptance of the values in
2394  * the headers vs. some extra checks.
2395  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2396  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2397  * And there are "variable" fps files this needs to detect as well.
2398  */
2399 static int tb_unreliable(AVCodecContext *c){
2400     if(   c->time_base.den >= 101L*c->time_base.num
2401        || c->time_base.den <    5L*c->time_base.num
2402 /*       || c->codec_tag == AV_RL32("DIVX")
2403        || c->codec_tag == AV_RL32("XVID")*/
2404        || c->codec_id == CODEC_ID_MPEG2VIDEO
2405        || c->codec_id == CODEC_ID_H264
2406        )
2407         return 1;
2408     return 0;
2409 }
2410
2411 #if FF_API_FORMAT_PARAMETERS
2412 int av_find_stream_info(AVFormatContext *ic)
2413 {
2414     return avformat_find_stream_info(ic, NULL);
2415 }
2416 #endif
2417
2418 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2419 {
2420     int i, count, ret, read_size, j;
2421     AVStream *st;
2422     AVPacket pkt1, *pkt;
2423     int64_t old_offset = avio_tell(ic->pb);
2424     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2425     int flush_codecs = 1;
2426
2427     if(ic->pb)
2428         av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2429
2430     for(i=0;i<ic->nb_streams;i++) {
2431         AVCodec *codec;
2432         AVDictionary *thread_opt = NULL;
2433         st = ic->streams[i];
2434
2435         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2436             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2437 /*            if(!st->time_base.num)
2438                 st->time_base= */
2439             if(!st->codec->time_base.num)
2440                 st->codec->time_base= st->time_base;
2441         }
2442         //only for the split stuff
2443         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2444             st->parser = av_parser_init(st->codec->codec_id);
2445             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2446                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2447             }
2448         }
2449         codec = st->codec->codec ? st->codec->codec :
2450                                    avcodec_find_decoder(st->codec->codec_id);
2451
2452         /* force thread count to 1 since the h264 decoder will not extract SPS
2453          *  and PPS to extradata during multi-threaded decoding */
2454         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2455
2456         /* Ensure that subtitle_header is properly set. */
2457         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2458             && codec && !st->codec->codec)
2459             avcodec_open2(st->codec, codec, options ? &options[i]
2460                               : &thread_opt);
2461
2462         //try to just open decoders, in case this is enough to get parameters
2463         if (!has_codec_parameters(st)) {
2464             if (codec && !st->codec->codec)
2465                 avcodec_open2(st->codec, codec, options ? &options[i]
2466                               : &thread_opt);
2467         }
2468         if (!options)
2469             av_dict_free(&thread_opt);
2470     }
2471
2472     for (i=0; i<ic->nb_streams; i++) {
2473         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2474     }
2475
2476     count = 0;
2477     read_size = 0;
2478     for(;;) {
2479         if (ff_check_interrupt(&ic->interrupt_callback)){
2480             ret= AVERROR_EXIT;
2481             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2482             break;
2483         }
2484
2485         /* check if one codec still needs to be handled */
2486         for(i=0;i<ic->nb_streams;i++) {
2487             int fps_analyze_framecount = 20;
2488
2489             st = ic->streams[i];
2490             if (!has_codec_parameters(st))
2491                 break;
2492             /* if the timebase is coarse (like the usual millisecond precision
2493                of mkv), we need to analyze more frames to reliably arrive at
2494                the correct fps */
2495             if (av_q2d(st->time_base) > 0.0005)
2496                 fps_analyze_framecount *= 2;
2497             if (ic->fps_probe_size >= 0)
2498                 fps_analyze_framecount = ic->fps_probe_size;
2499             /* variable fps and no guess at the real fps */
2500             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2501                && st->info->duration_count < fps_analyze_framecount
2502                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2503                 break;
2504             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2505                 break;
2506             if (st->first_dts == AV_NOPTS_VALUE &&
2507                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2508                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2509                 break;
2510         }
2511         if (i == ic->nb_streams) {
2512             /* NOTE: if the format has no header, then we need to read
2513                some packets to get most of the streams, so we cannot
2514                stop here */
2515             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2516                 /* if we found the info for all the codecs, we can stop */
2517                 ret = count;
2518                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2519                 flush_codecs = 0;
2520                 break;
2521             }
2522         }
2523         /* we did not get all the codec info, but we read too much data */
2524         if (read_size >= ic->probesize) {
2525             ret = count;
2526             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2527             for (i = 0; i < ic->nb_streams; i++)
2528                 if (!ic->streams[i]->r_frame_rate.num &&
2529                     ic->streams[i]->info->duration_count <= 1)
2530                     av_log(ic, AV_LOG_WARNING,
2531                            "Stream #%d: not enough frames to estimate rate; "
2532                            "consider increasing probesize\n", i);
2533             break;
2534         }
2535
2536         /* NOTE: a new stream can be added there if no header in file
2537            (AVFMTCTX_NOHEADER) */
2538         ret = read_frame_internal(ic, &pkt1);
2539         if (ret == AVERROR(EAGAIN))
2540             continue;
2541
2542         if (ret < 0) {
2543             /* EOF or error*/
2544             break;
2545         }
2546
2547         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2548         if ((ret = av_dup_packet(pkt)) < 0)
2549             goto find_stream_info_err;
2550
2551         read_size += pkt->size;
2552
2553         st = ic->streams[pkt->stream_index];
2554         if (st->codec_info_nb_frames>1) {
2555             int64_t t=0;
2556             if (st->time_base.den > 0)
2557                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2558             if (st->avg_frame_rate.num > 0)
2559                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, (AVRational){st->avg_frame_rate.den, st->avg_frame_rate.num}, AV_TIME_BASE_Q));
2560
2561             if (t >= ic->max_analyze_duration) {
2562                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2563                 break;
2564             }
2565             st->info->codec_info_duration += pkt->duration;
2566         }
2567         {
2568             int64_t last = st->info->last_dts;
2569
2570             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2571                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2572                 int64_t duration= pkt->dts - last;
2573
2574 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2575 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2576                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2577                     int framerate= get_std_framerate(i);
2578                     double sdts= dts*framerate/(1001*12);
2579                     for(j=0; j<2; j++){
2580                         int ticks= lrintf(sdts+j*0.5);
2581                         double error= sdts - ticks + j*0.5;
2582                         st->info->duration_error[j][0][i] += error;
2583                         st->info->duration_error[j][1][i] += error*error;
2584                     }
2585                 }
2586                 st->info->duration_count++;
2587                 // ignore the first 4 values, they might have some random jitter
2588                 if (st->info->duration_count > 3)
2589                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2590             }
2591             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2592                 st->info->last_dts = pkt->dts;
2593         }
2594         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2595             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2596             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2597                 st->codec->extradata_size= i;
2598                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2599                 if (!st->codec->extradata)
2600                     return AVERROR(ENOMEM);
2601                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2602                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2603             }
2604         }
2605
2606         /* if still no information, we try to open the codec and to
2607            decompress the frame. We try to avoid that in most cases as
2608            it takes longer and uses more memory. For MPEG-4, we need to
2609            decompress for QuickTime.
2610
2611            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2612            least one frame of codec data, this makes sure the codec initializes
2613            the channel configuration and does not only trust the values from the container.
2614         */
2615         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2616
2617         st->codec_info_nb_frames++;
2618         count++;
2619     }
2620
2621     if (flush_codecs) {
2622         AVPacket empty_pkt = { 0 };
2623         int err = 0;
2624         av_init_packet(&empty_pkt);
2625
2626         ret = -1; /* we could not have all the codec parameters before EOF */
2627         for(i=0;i<ic->nb_streams;i++) {
2628             st = ic->streams[i];
2629
2630             /* flush the decoders */
2631             if (st->info->found_decoder == 1) {
2632                 do {
2633                     err = try_decode_frame(st, &empty_pkt,
2634                                             (options && i < orig_nb_streams) ?
2635                                             &options[i] : NULL);
2636                 } while (err > 0 && !has_codec_parameters(st));
2637
2638                 if (err < 0) {
2639                     av_log(ic, AV_LOG_INFO,
2640                         "decoding for stream %d failed\n", st->index);
2641                 }
2642             }
2643
2644             if (!has_codec_parameters(st)){
2645                 char buf[256];
2646                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2647                 av_log(ic, AV_LOG_WARNING,
2648                        "Could not find codec parameters (%s)\n", buf);
2649             } else {
2650                 ret = 0;
2651             }
2652         }
2653     }
2654
2655     // close codecs which were opened in try_decode_frame()
2656     for(i=0;i<ic->nb_streams;i++) {
2657         st = ic->streams[i];
2658         avcodec_close(st->codec);
2659     }
2660     for(i=0;i<ic->nb_streams;i++) {
2661         st = ic->streams[i];
2662         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2663             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2664                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2665                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2666                     st->codec->codec_tag= tag;
2667             }
2668
2669             if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2670                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2671                           (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2672                           st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2673             // the check for tb_unreliable() is not completely correct, since this is not about handling
2674             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2675             // ipmovie.c produces.
2676             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)
2677                 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);
2678             if (st->info->duration_count && !st->r_frame_rate.num
2679                && tb_unreliable(st->codec) /*&&
2680                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2681                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2682                 int num = 0;
2683                 double best_error= 0.01;
2684
2685                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2686                     int k;
2687
2688                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2689                         continue;
2690                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2691                         continue;
2692                     for(k=0; k<2; k++){
2693                         int n= st->info->duration_count;
2694                         double a= st->info->duration_error[k][0][j] / n;
2695                         double error= st->info->duration_error[k][1][j]/n - a*a;
2696
2697                         if(error < best_error && best_error> 0.000000001){
2698                             best_error= error;
2699                             num = get_std_framerate(j);
2700                         }
2701                         if(error < 0.02)
2702                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2703                     }
2704                 }
2705                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2706                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2707                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2708             }
2709
2710             if (!st->r_frame_rate.num){
2711                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2712                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2713                     st->r_frame_rate.num = st->codec->time_base.den;
2714                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2715                 }else{
2716                     st->r_frame_rate.num = st->time_base.den;
2717                     st->r_frame_rate.den = st->time_base.num;
2718                 }
2719             }
2720         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2721             if(!st->codec->bits_per_coded_sample)
2722                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2723             // set stream disposition based on audio service type
2724             switch (st->codec->audio_service_type) {
2725             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2726                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2727             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2728                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2729             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2730                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2731             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2732                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2733             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2734                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2735             }
2736         }
2737     }
2738
2739     estimate_timings(ic, old_offset);
2740
2741     compute_chapters_end(ic);
2742
2743  find_stream_info_err:
2744     for (i=0; i < ic->nb_streams; i++) {
2745         if (ic->streams[i]->codec)
2746             ic->streams[i]->codec->thread_count = 0;
2747         av_freep(&ic->streams[i]->info);
2748     }
2749     if(ic->pb)
2750         av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2751     return ret;
2752 }
2753
2754 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2755 {
2756     int i, j;
2757
2758     for (i = 0; i < ic->nb_programs; i++) {
2759         if (ic->programs[i] == last) {
2760             last = NULL;
2761         } else {
2762             if (!last)
2763                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2764                     if (ic->programs[i]->stream_index[j] == s)
2765                         return ic->programs[i];
2766         }
2767     }
2768     return NULL;
2769 }
2770
2771 int av_find_best_stream(AVFormatContext *ic,
2772                         enum AVMediaType type,
2773                         int wanted_stream_nb,
2774                         int related_stream,
2775                         AVCodec **decoder_ret,
2776                         int flags)
2777 {
2778     int i, nb_streams = ic->nb_streams;
2779     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2780     unsigned *program = NULL;
2781     AVCodec *decoder = NULL, *best_decoder = NULL;
2782
2783     if (related_stream >= 0 && wanted_stream_nb < 0) {
2784         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2785         if (p) {
2786             program = p->stream_index;
2787             nb_streams = p->nb_stream_indexes;
2788         }
2789     }
2790     for (i = 0; i < nb_streams; i++) {
2791         int real_stream_index = program ? program[i] : i;
2792         AVStream *st = ic->streams[real_stream_index];
2793         AVCodecContext *avctx = st->codec;
2794         if (avctx->codec_type != type)
2795             continue;
2796         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2797             continue;
2798         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2799             continue;
2800         if (decoder_ret) {
2801             decoder = avcodec_find_decoder(st->codec->codec_id);
2802             if (!decoder) {
2803                 if (ret < 0)
2804                     ret = AVERROR_DECODER_NOT_FOUND;
2805                 continue;
2806             }
2807         }
2808         if (best_count >= st->codec_info_nb_frames)
2809             continue;
2810         best_count = st->codec_info_nb_frames;
2811         ret = real_stream_index;
2812         best_decoder = decoder;
2813         if (program && i == nb_streams - 1 && ret < 0) {
2814             program = NULL;
2815             nb_streams = ic->nb_streams;
2816             i = 0; /* no related stream found, try again with everything */
2817         }
2818     }
2819     if (decoder_ret)
2820         *decoder_ret = best_decoder;
2821     return ret;
2822 }
2823
2824 /*******************************************************/
2825
2826 int av_read_play(AVFormatContext *s)
2827 {
2828     if (s->iformat->read_play)
2829         return s->iformat->read_play(s);
2830     if (s->pb)
2831         return avio_pause(s->pb, 0);
2832     return AVERROR(ENOSYS);
2833 }
2834
2835 int av_read_pause(AVFormatContext *s)
2836 {
2837     if (s->iformat->read_pause)
2838         return s->iformat->read_pause(s);
2839     if (s->pb)
2840         return avio_pause(s->pb, 1);
2841     return AVERROR(ENOSYS);
2842 }
2843
2844 void avformat_free_context(AVFormatContext *s)
2845 {
2846     int i;
2847     AVStream *st;
2848
2849     av_opt_free(s);
2850     if (s->iformat && s->iformat->priv_class && s->priv_data)
2851         av_opt_free(s->priv_data);
2852
2853     for(i=0;i<s->nb_streams;i++) {
2854         /* free all data in a stream component */
2855         st = s->streams[i];
2856         if (st->parser) {
2857             av_parser_close(st->parser);
2858         }
2859         if (st->attached_pic.data)
2860             av_free_packet(&st->attached_pic);
2861         av_dict_free(&st->metadata);
2862         av_freep(&st->index_entries);
2863         av_freep(&st->codec->extradata);
2864         av_freep(&st->codec->subtitle_header);
2865         av_freep(&st->codec);
2866         av_freep(&st->priv_data);
2867         av_freep(&st->info);
2868         av_freep(&st);
2869     }
2870     for(i=s->nb_programs-1; i>=0; i--) {
2871         av_dict_free(&s->programs[i]->metadata);
2872         av_freep(&s->programs[i]->stream_index);
2873         av_freep(&s->programs[i]);
2874     }
2875     av_freep(&s->programs);
2876     av_freep(&s->priv_data);
2877     while(s->nb_chapters--) {
2878         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2879         av_freep(&s->chapters[s->nb_chapters]);
2880     }
2881     av_freep(&s->chapters);
2882     av_dict_free(&s->metadata);
2883     av_freep(&s->streams);
2884     av_free(s);
2885 }
2886
2887 #if FF_API_CLOSE_INPUT_FILE
2888 void av_close_input_file(AVFormatContext *s)
2889 {
2890     avformat_close_input(&s);
2891 }
2892 #endif
2893
2894 void avformat_close_input(AVFormatContext **ps)
2895 {
2896     AVFormatContext *s = *ps;
2897     AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2898                        NULL : s->pb;
2899     flush_packet_queue(s);
2900     if (s->iformat && (s->iformat->read_close))
2901         s->iformat->read_close(s);
2902     avformat_free_context(s);
2903     *ps = NULL;
2904     if (pb)
2905         avio_close(pb);
2906 }
2907
2908 #if FF_API_NEW_STREAM
2909 AVStream *av_new_stream(AVFormatContext *s, int id)
2910 {
2911     AVStream *st = avformat_new_stream(s, NULL);
2912     if (st)
2913         st->id = id;
2914     return st;
2915 }
2916 #endif
2917
2918 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2919 {
2920     AVStream *st;
2921     int i;
2922     AVStream **streams;
2923
2924     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2925         return NULL;
2926     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2927     if (!streams)
2928         return NULL;
2929     s->streams = streams;
2930
2931     st = av_mallocz(sizeof(AVStream));
2932     if (!st)
2933         return NULL;
2934     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2935         av_free(st);
2936         return NULL;
2937     }
2938     st->info->last_dts = AV_NOPTS_VALUE;
2939
2940     st->codec = avcodec_alloc_context3(c);
2941     if (s->iformat) {
2942         /* no default bitrate if decoding */
2943         st->codec->bit_rate = 0;
2944     }
2945     st->index = s->nb_streams;
2946     st->start_time = AV_NOPTS_VALUE;
2947     st->duration = AV_NOPTS_VALUE;
2948         /* we set the current DTS to 0 so that formats without any timestamps
2949            but durations get some timestamps, formats with some unknown
2950            timestamps have their first few packets buffered and the
2951            timestamps corrected before they are returned to the user */
2952     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
2953     st->first_dts = AV_NOPTS_VALUE;
2954     st->probe_packets = MAX_PROBE_PACKETS;
2955
2956     /* default pts setting is MPEG-like */
2957     avpriv_set_pts_info(st, 33, 1, 90000);
2958     st->last_IP_pts = AV_NOPTS_VALUE;
2959     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2960         st->pts_buffer[i]= AV_NOPTS_VALUE;
2961     st->reference_dts = AV_NOPTS_VALUE;
2962
2963     st->sample_aspect_ratio = (AVRational){0,1};
2964
2965     s->streams[s->nb_streams++] = st;
2966     return st;
2967 }
2968
2969 AVProgram *av_new_program(AVFormatContext *ac, int id)
2970 {
2971     AVProgram *program=NULL;
2972     int i;
2973
2974     av_dlog(ac, "new_program: id=0x%04x\n", id);
2975
2976     for(i=0; i<ac->nb_programs; i++)
2977         if(ac->programs[i]->id == id)
2978             program = ac->programs[i];
2979
2980     if(!program){
2981         program = av_mallocz(sizeof(AVProgram));
2982         if (!program)
2983             return NULL;
2984         dynarray_add(&ac->programs, &ac->nb_programs, program);
2985         program->discard = AVDISCARD_NONE;
2986     }
2987     program->id = id;
2988
2989     return program;
2990 }
2991
2992 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2993 {
2994     AVChapter *chapter = NULL;
2995     int i;
2996
2997     for(i=0; i<s->nb_chapters; i++)
2998         if(s->chapters[i]->id == id)
2999             chapter = s->chapters[i];
3000
3001     if(!chapter){
3002         chapter= av_mallocz(sizeof(AVChapter));
3003         if(!chapter)
3004             return NULL;
3005         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3006     }
3007     av_dict_set(&chapter->metadata, "title", title, 0);
3008     chapter->id    = id;
3009     chapter->time_base= time_base;
3010     chapter->start = start;
3011     chapter->end   = end;
3012
3013     return chapter;
3014 }
3015
3016 /************************************************************/
3017 /* output media file */
3018
3019 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
3020                                    const char *format, const char *filename)
3021 {
3022     AVFormatContext *s = avformat_alloc_context();
3023     int ret = 0;
3024
3025     *avctx = NULL;
3026     if (!s)
3027         goto nomem;
3028
3029     if (!oformat) {
3030         if (format) {
3031             oformat = av_guess_format(format, NULL, NULL);
3032             if (!oformat) {
3033                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
3034                 ret = AVERROR(EINVAL);
3035                 goto error;
3036             }
3037         } else {
3038             oformat = av_guess_format(NULL, filename, NULL);
3039             if (!oformat) {
3040                 ret = AVERROR(EINVAL);
3041                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
3042                        filename);
3043                 goto error;
3044             }
3045         }
3046     }
3047
3048     s->oformat = oformat;
3049     if (s->oformat->priv_data_size > 0) {
3050         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3051         if (!s->priv_data)
3052             goto nomem;
3053         if (s->oformat->priv_class) {
3054             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3055             av_opt_set_defaults(s->priv_data);
3056         }
3057     } else
3058         s->priv_data = NULL;
3059
3060     if (filename)
3061         av_strlcpy(s->filename, filename, sizeof(s->filename));
3062     *avctx = s;
3063     return 0;
3064 nomem:
3065     av_log(s, AV_LOG_ERROR, "Out of memory\n");
3066     ret = AVERROR(ENOMEM);
3067 error:
3068     avformat_free_context(s);
3069     return ret;
3070 }
3071
3072 #if FF_API_ALLOC_OUTPUT_CONTEXT
3073 AVFormatContext *avformat_alloc_output_context(const char *format,
3074                                                AVOutputFormat *oformat, const char *filename)
3075 {
3076     AVFormatContext *avctx;
3077     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
3078     return ret < 0 ? NULL : avctx;
3079 }
3080 #endif
3081
3082 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
3083 {
3084     const AVCodecTag *avctag;
3085     int n;
3086     enum CodecID id = CODEC_ID_NONE;
3087     unsigned int tag = 0;
3088
3089     /**
3090      * Check that tag + id is in the table
3091      * If neither is in the table -> OK
3092      * If tag is in the table with another id -> FAIL
3093      * If id is in the table with another tag -> FAIL unless strict < normal
3094      */
3095     for (n = 0; s->oformat->codec_tag[n]; n++) {
3096         avctag = s->oformat->codec_tag[n];
3097         while (avctag->id != CODEC_ID_NONE) {
3098             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3099                 id = avctag->id;
3100                 if (id == st->codec->codec_id)
3101                     return 1;
3102             }
3103             if (avctag->id == st->codec->codec_id)
3104                 tag = avctag->tag;
3105             avctag++;
3106         }
3107     }
3108     if (id != CODEC_ID_NONE)
3109         return 0;
3110     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3111         return 0;
3112     return 1;
3113 }
3114
3115 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3116 {
3117     int ret = 0, i;
3118     AVStream *st;
3119     AVDictionary *tmp = NULL;
3120
3121     if (options)
3122         av_dict_copy(&tmp, *options, 0);
3123     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3124         goto fail;
3125     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3126         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3127         goto fail;
3128
3129     // some sanity checks
3130     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3131         av_log(s, AV_LOG_ERROR, "no streams\n");
3132         ret = AVERROR(EINVAL);
3133         goto fail;
3134     }
3135
3136     for(i=0;i<s->nb_streams;i++) {
3137         st = s->streams[i];
3138
3139         switch (st->codec->codec_type) {
3140         case AVMEDIA_TYPE_AUDIO:
3141             if(st->codec->sample_rate<=0){
3142                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3143                 ret = AVERROR(EINVAL);
3144                 goto fail;
3145             }
3146             if(!st->codec->block_align)
3147                 st->codec->block_align = st->codec->channels *
3148                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
3149             break;
3150         case AVMEDIA_TYPE_VIDEO:
3151             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3152                 av_log(s, AV_LOG_ERROR, "time base not set\n");
3153                 ret = AVERROR(EINVAL);
3154                 goto fail;
3155             }
3156             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3157                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3158                 ret = AVERROR(EINVAL);
3159                 goto fail;
3160             }
3161             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3162                && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3163             ){
3164                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
3165                        "(%d/%d) and encoder layer (%d/%d)\n",
3166                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3167                        st->codec->sample_aspect_ratio.num,
3168                        st->codec->sample_aspect_ratio.den);
3169                 ret = AVERROR(EINVAL);
3170                 goto fail;
3171             }
3172             break;
3173         }
3174
3175         if(s->oformat->codec_tag){
3176             if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
3177                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3178                 st->codec->codec_tag= 0;
3179             }
3180             if(st->codec->codec_tag){
3181                 if (!validate_codec_tag(s, st)) {
3182                     char tagbuf[32], cortag[32];
3183                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3184                     av_get_codec_tag_string(cortag, sizeof(cortag), av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id));
3185                     av_log(s, AV_LOG_ERROR,
3186                            "Tag %s/0x%08x incompatible with output codec id '%d' (%s)\n",
3187                            tagbuf, st->codec->codec_tag, st->codec->codec_id, cortag);
3188                     ret = AVERROR_INVALIDDATA;
3189                     goto fail;
3190                 }
3191             }else
3192                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3193         }
3194
3195         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3196             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3197           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3198     }
3199
3200     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3201         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3202         if (!s->priv_data) {
3203             ret = AVERROR(ENOMEM);
3204             goto fail;
3205         }
3206         if (s->oformat->priv_class) {
3207             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3208             av_opt_set_defaults(s->priv_data);
3209             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3210                 goto fail;
3211         }
3212     }
3213
3214     /* set muxer identification string */
3215     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3216         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3217     }
3218
3219     if(s->oformat->write_header){
3220         ret = s->oformat->write_header(s);
3221         if (ret < 0)
3222             goto fail;
3223     }
3224
3225     /* init PTS generation */
3226     for(i=0;i<s->nb_streams;i++) {
3227         int64_t den = AV_NOPTS_VALUE;
3228         st = s->streams[i];
3229
3230         switch (st->codec->codec_type) {
3231         case AVMEDIA_TYPE_AUDIO:
3232             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3233             break;
3234         case AVMEDIA_TYPE_VIDEO:
3235             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3236             break;
3237         default:
3238             break;
3239         }
3240         if (den != AV_NOPTS_VALUE) {
3241             if (den <= 0) {
3242                 ret = AVERROR_INVALIDDATA;
3243                 goto fail;
3244             }
3245             frac_init(&st->pts, 0, 0, den);
3246         }
3247     }
3248
3249     if (options) {
3250         av_dict_free(options);
3251         *options = tmp;
3252     }
3253     return 0;
3254 fail:
3255     av_dict_free(&tmp);
3256     return ret;
3257 }
3258
3259 //FIXME merge with compute_pkt_fields
3260 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3261     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3262     int num, den, frame_size, i;
3263
3264     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3265             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3266
3267     /* duration field */
3268     if (pkt->duration == 0) {
3269         compute_frame_duration(&num, &den, st, NULL, pkt);
3270         if (den && num) {
3271             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3272         }
3273     }
3274
3275     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3276         pkt->pts= pkt->dts;
3277
3278     //XXX/FIXME this is a temporary hack until all encoders output pts
3279     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3280         static int warned;
3281         if (!warned) {
3282             av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
3283             warned = 1;
3284         }
3285         pkt->dts=
3286 //        pkt->pts= st->cur_dts;
3287         pkt->pts= st->pts.val;
3288     }
3289
3290     //calculate dts from pts
3291     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3292         st->pts_buffer[0]= pkt->pts;
3293         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3294             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3295         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3296             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3297
3298         pkt->dts= st->pts_buffer[0];
3299     }
3300
3301     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)){
3302         av_log(s, AV_LOG_ERROR,
3303                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3304                st->index, st->cur_dts, pkt->dts);
3305         return AVERROR(EINVAL);
3306     }
3307     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3308         av_log(s, AV_LOG_ERROR, "pts (%"PRId64") < dts (%"PRId64") in stream %d\n", pkt->pts, pkt->dts, st->index);
3309         return AVERROR(EINVAL);
3310     }
3311
3312 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3313     st->cur_dts= pkt->dts;
3314     st->pts.val= pkt->dts;
3315
3316     /* update pts */
3317     switch (st->codec->codec_type) {
3318     case AVMEDIA_TYPE_AUDIO:
3319         frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3320
3321         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3322            likely equal to the encoder delay, but it would be better if we
3323            had the real timestamps from the encoder */
3324         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3325             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3326         }
3327         break;
3328     case AVMEDIA_TYPE_VIDEO:
3329         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3330         break;
3331     default:
3332         break;
3333     }
3334     return 0;
3335 }
3336
3337 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3338 {
3339     int ret;
3340
3341     if (!pkt) {
3342         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3343             return s->oformat->write_packet(s, pkt);
3344         return 1;
3345     }
3346
3347     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3348
3349     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3350         return ret;
3351
3352     ret= s->oformat->write_packet(s, pkt);
3353
3354     if (ret >= 0)
3355         s->streams[pkt->stream_index]->nb_frames++;
3356     return ret;
3357 }
3358
3359 #define CHUNK_START 0x1000
3360
3361 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3362                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3363 {
3364     AVPacketList **next_point, *this_pktl;
3365     AVStream *st= s->streams[pkt->stream_index];
3366     int chunked= s->max_chunk_size || s->max_chunk_duration;
3367
3368     this_pktl = av_mallocz(sizeof(AVPacketList));
3369     if (!this_pktl)
3370         return AVERROR(ENOMEM);
3371     this_pktl->pkt= *pkt;
3372     pkt->destruct= NULL;             // do not free original but only the copy
3373     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3374
3375     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3376         next_point = &(st->last_in_packet_buffer->next);
3377     }else{
3378         next_point = &s->packet_buffer;
3379     }
3380
3381     if(*next_point){
3382         if(chunked){
3383             uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3384             if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
3385                && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3386                 st->interleaver_chunk_size     += pkt->size;
3387                 st->interleaver_chunk_duration += pkt->duration;
3388                 goto next_non_null;
3389             }else{
3390                 st->interleaver_chunk_size     =
3391                 st->interleaver_chunk_duration = 0;
3392                 this_pktl->pkt.flags |= CHUNK_START;
3393             }
3394         }
3395
3396         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3397             while(   *next_point
3398                   && ((chunked && !((*next_point)->pkt.flags&CHUNK_START))
3399                       || !compare(s, &(*next_point)->pkt, pkt))){
3400                 next_point= &(*next_point)->next;
3401             }
3402             if(*next_point)
3403                 goto next_non_null;
3404         }else{
3405             next_point = &(s->packet_buffer_end->next);
3406         }
3407     }
3408     assert(!*next_point);
3409
3410     s->packet_buffer_end= this_pktl;
3411 next_non_null:
3412
3413     this_pktl->next= *next_point;
3414
3415     s->streams[pkt->stream_index]->last_in_packet_buffer=
3416     *next_point= this_pktl;
3417     return 0;
3418 }
3419
3420 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3421 {
3422     AVStream *st = s->streams[ pkt ->stream_index];
3423     AVStream *st2= s->streams[ next->stream_index];
3424     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3425                              st->time_base);
3426     if(s->audio_preload && ((st->codec->codec_type == AVMEDIA_TYPE_AUDIO) != (st2->codec->codec_type == AVMEDIA_TYPE_AUDIO))){
3427         int64_t ts = av_rescale_q(pkt ->dts, st ->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3428         int64_t ts2= av_rescale_q(next->dts, st2->time_base, AV_TIME_BASE_Q) - s->audio_preload*(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO);
3429         if(ts == ts2){
3430             ts= ( pkt ->dts* st->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st ->codec->codec_type == AVMEDIA_TYPE_AUDIO)* st->time_base.den)*st2->time_base.den
3431                -( next->dts*st2->time_base.num*AV_TIME_BASE - s->audio_preload*(int64_t)(st2->codec->codec_type == AVMEDIA_TYPE_AUDIO)*st2->time_base.den)* st->time_base.den;
3432             ts2=0;
3433         }
3434         comp= (ts>ts2) - (ts<ts2);
3435     }
3436
3437     if (comp == 0)
3438         return pkt->stream_index < next->stream_index;
3439     return comp > 0;
3440 }
3441
3442 int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3443                                  AVPacket *pkt, int flush)
3444 {
3445     AVPacketList *pktl;
3446     int stream_count=0, noninterleaved_count=0;
3447     int64_t delta_dts_max = 0;
3448     int i, ret;
3449
3450     if(pkt){
3451         ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3452         if (ret < 0)
3453             return ret;
3454     }
3455
3456     for(i=0; i < s->nb_streams; i++) {
3457         if (s->streams[i]->last_in_packet_buffer) {
3458             ++stream_count;
3459         } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3460             ++noninterleaved_count;
3461         }
3462     }
3463
3464     if (s->nb_streams == stream_count) {
3465         flush = 1;
3466     } else if (!flush){
3467         for(i=0; i < s->nb_streams; i++) {
3468             if (s->streams[i]->last_in_packet_buffer) {
3469                 int64_t delta_dts =
3470                     av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3471                                 s->streams[i]->time_base,
3472                                 AV_TIME_BASE_Q) -
3473                     av_rescale_q(s->packet_buffer->pkt.dts,
3474                                 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3475                                 AV_TIME_BASE_Q);
3476                 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3477             }
3478         }
3479         if(s->nb_streams == stream_count+noninterleaved_count &&
3480            delta_dts_max > 20*AV_TIME_BASE) {
3481             av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3482             flush = 1;
3483         }
3484     }
3485     if(stream_count && flush){
3486         pktl= s->packet_buffer;
3487         *out= pktl->pkt;
3488
3489         s->packet_buffer= pktl->next;
3490         if(!s->packet_buffer)
3491             s->packet_buffer_end= NULL;
3492
3493         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3494             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3495         av_freep(&pktl);
3496         return 1;
3497     }else{
3498         av_init_packet(out);
3499         return 0;
3500     }
3501 }
3502
3503 #if FF_API_INTERLEAVE_PACKET
3504 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
3505                                  AVPacket *pkt, int flush)
3506 {
3507     return ff_interleave_packet_per_dts(s, out, pkt, flush);
3508 }
3509 #endif
3510
3511 /**
3512  * Interleave an AVPacket correctly so it can be muxed.
3513  * @param out the interleaved packet will be output here
3514  * @param in the input packet
3515  * @param flush 1 if no further packets are available as input and all
3516  *              remaining packets should be output
3517  * @return 1 if a packet was output, 0 if no packet could be output,
3518  *         < 0 if an error occurred
3519  */
3520 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3521     if (s->oformat->interleave_packet) {
3522         int ret = s->oformat->interleave_packet(s, out, in, flush);
3523         if (in)
3524             av_free_packet(in);
3525         return ret;
3526     } else
3527         return ff_interleave_packet_per_dts(s, out, in, flush);
3528 }
3529
3530 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3531     int ret, flush = 0;
3532
3533     if (pkt) {
3534         AVStream *st= s->streams[ pkt->stream_index];
3535
3536         //FIXME/XXX/HACK drop zero sized packets
3537         if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3538             return 0;
3539
3540         av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3541                 pkt->size, pkt->dts, pkt->pts);
3542         if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3543             return ret;
3544
3545         if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3546             return AVERROR(EINVAL);
3547     } else {
3548         av_dlog(s, "av_interleaved_write_frame FLUSH\n");
3549         flush = 1;
3550     }
3551
3552     for(;;){
3553         AVPacket opkt;
3554         int ret= interleave_packet(s, &opkt, pkt, flush);
3555         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3556             return ret;
3557
3558         ret= s->oformat->write_packet(s, &opkt);
3559         if (ret >= 0)
3560             s->streams[opkt.stream_index]->nb_frames++;
3561
3562         av_free_packet(&opkt);
3563         pkt= NULL;
3564
3565         if(ret<0)
3566             return ret;
3567         if(s->pb && s->pb->error)
3568             return s->pb->error;
3569     }
3570 }
3571
3572 int av_write_trailer(AVFormatContext *s)
3573 {
3574     int ret, i;
3575
3576     for(;;){
3577         AVPacket pkt;
3578         ret= interleave_packet(s, &pkt, NULL, 1);
3579         if(ret<0) //FIXME cleanup needed for ret<0 ?
3580             goto fail;
3581         if(!ret)
3582             break;
3583
3584         ret= s->oformat->write_packet(s, &pkt);
3585         if (ret >= 0)
3586             s->streams[pkt.stream_index]->nb_frames++;
3587
3588         av_free_packet(&pkt);
3589
3590         if(ret<0)
3591             goto fail;
3592         if(s->pb && s->pb->error)
3593             goto fail;
3594     }
3595
3596     if(s->oformat->write_trailer)
3597         ret = s->oformat->write_trailer(s);
3598 fail:
3599     if (s->pb)
3600        avio_flush(s->pb);
3601     if(ret == 0)
3602        ret = s->pb ? s->pb->error : 0;
3603     for(i=0;i<s->nb_streams;i++) {
3604         av_freep(&s->streams[i]->priv_data);
3605         av_freep(&s->streams[i]->index_entries);
3606     }
3607     if (s->oformat->priv_class)
3608         av_opt_free(s->priv_data);
3609     av_freep(&s->priv_data);
3610     return ret;
3611 }
3612
3613 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3614                             int64_t *dts, int64_t *wall)
3615 {
3616     if (!s->oformat || !s->oformat->get_output_timestamp)
3617         return AVERROR(ENOSYS);
3618     s->oformat->get_output_timestamp(s, stream, dts, wall);
3619     return 0;
3620 }
3621
3622 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3623 {
3624     int i, j;
3625     AVProgram *program=NULL;
3626     void *tmp;
3627
3628     if (idx >= ac->nb_streams) {
3629         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3630         return;
3631     }
3632
3633     for(i=0; i<ac->nb_programs; i++){
3634         if(ac->programs[i]->id != progid)
3635             continue;
3636         program = ac->programs[i];
3637         for(j=0; j<program->nb_stream_indexes; j++)
3638             if(program->stream_index[j] == idx)
3639                 return;
3640
3641         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3642         if(!tmp)
3643             return;
3644         program->stream_index = tmp;
3645         program->stream_index[program->nb_stream_indexes++] = idx;
3646         return;
3647     }
3648 }
3649
3650 static void print_fps(double d, const char *postfix){
3651     uint64_t v= lrintf(d*100);
3652     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3653     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3654     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3655 }
3656
3657 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3658 {
3659     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3660         AVDictionaryEntry *tag=NULL;
3661
3662         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3663         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3664             if(strcmp("language", tag->key)){
3665                 const char *p = tag->value;
3666                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3667                 while(*p) {
3668                     char tmp[256];
3669                     size_t len = strcspn(p, "\xd\xa");
3670                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3671                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3672                     p += len;
3673                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3674                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3675                     if (*p) p++;
3676                 }
3677                 av_log(ctx, AV_LOG_INFO, "\n");
3678             }
3679         }
3680     }
3681 }
3682
3683 /* "user interface" functions */
3684 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3685 {
3686     char buf[256];
3687     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3688     AVStream *st = ic->streams[i];
3689     int g = av_gcd(st->time_base.num, st->time_base.den);
3690     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3691     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3692     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3693     /* the pid is an important information, so we display it */
3694     /* XXX: add a generic system */
3695     if (flags & AVFMT_SHOW_IDS)
3696         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3697     if (lang)
3698         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3699     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3700     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3701     if (st->sample_aspect_ratio.num && // default
3702         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3703         AVRational display_aspect_ratio;
3704         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3705                   st->codec->width*st->sample_aspect_ratio.num,
3706                   st->codec->height*st->sample_aspect_ratio.den,
3707                   1024*1024);
3708         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3709                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3710                  display_aspect_ratio.num, display_aspect_ratio.den);
3711     }
3712     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3713         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3714             print_fps(av_q2d(st->avg_frame_rate), "fps");
3715         if(st->r_frame_rate.den && st->r_frame_rate.num)
3716             print_fps(av_q2d(st->r_frame_rate), "tbr");
3717         if(st->time_base.den && st->time_base.num)
3718             print_fps(1/av_q2d(st->time_base), "tbn");
3719         if(st->codec->time_base.den && st->codec->time_base.num)
3720             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3721     }
3722     if (st->disposition & AV_DISPOSITION_DEFAULT)
3723         av_log(NULL, AV_LOG_INFO, " (default)");
3724     if (st->disposition & AV_DISPOSITION_DUB)
3725         av_log(NULL, AV_LOG_INFO, " (dub)");
3726     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3727         av_log(NULL, AV_LOG_INFO, " (original)");
3728     if (st->disposition & AV_DISPOSITION_COMMENT)
3729         av_log(NULL, AV_LOG_INFO, " (comment)");
3730     if (st->disposition & AV_DISPOSITION_LYRICS)
3731         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3732     if (st->disposition & AV_DISPOSITION_KARAOKE)
3733         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3734     if (st->disposition & AV_DISPOSITION_FORCED)
3735         av_log(NULL, AV_LOG_INFO, " (forced)");
3736     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3737         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3738     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3739         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3740     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3741         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3742     av_log(NULL, AV_LOG_INFO, "\n");
3743     dump_metadata(NULL, st->metadata, "    ");
3744 }
3745
3746 void av_dump_format(AVFormatContext *ic,
3747                     int index,
3748                     const char *url,
3749                     int is_output)
3750 {
3751     int i;
3752     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3753     if (ic->nb_streams && !printed)
3754         return;
3755
3756     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3757             is_output ? "Output" : "Input",
3758             index,
3759             is_output ? ic->oformat->name : ic->iformat->name,
3760             is_output ? "to" : "from", url);
3761     dump_metadata(NULL, ic->metadata, "  ");
3762     if (!is_output) {
3763         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3764         if (ic->duration != AV_NOPTS_VALUE) {
3765             int hours, mins, secs, us;
3766             secs = ic->duration / AV_TIME_BASE;
3767             us = ic->duration % AV_TIME_BASE;
3768             mins = secs / 60;
3769             secs %= 60;
3770             hours = mins / 60;
3771             mins %= 60;
3772             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3773                    (100 * us) / AV_TIME_BASE);
3774         } else {
3775             av_log(NULL, AV_LOG_INFO, "N/A");
3776         }
3777         if (ic->start_time != AV_NOPTS_VALUE) {
3778             int secs, us;
3779             av_log(NULL, AV_LOG_INFO, ", start: ");
3780             secs = ic->start_time / AV_TIME_BASE;
3781             us = abs(ic->start_time % AV_TIME_BASE);
3782             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3783                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3784         }
3785         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3786         if (ic->bit_rate) {
3787             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3788         } else {
3789             av_log(NULL, AV_LOG_INFO, "N/A");
3790         }
3791         av_log(NULL, AV_LOG_INFO, "\n");
3792     }
3793     for (i = 0; i < ic->nb_chapters; i++) {
3794         AVChapter *ch = ic->chapters[i];
3795         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3796         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3797         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3798
3799         dump_metadata(NULL, ch->metadata, "    ");
3800     }
3801     if(ic->nb_programs) {
3802         int j, k, total = 0;
3803         for(j=0; j<ic->nb_programs; j++) {
3804             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3805                                                   "name", NULL, 0);
3806             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3807                    name ? name->value : "");
3808             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3809             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3810                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3811                 printed[ic->programs[j]->stream_index[k]] = 1;
3812             }
3813             total += ic->programs[j]->nb_stream_indexes;
3814         }
3815         if (total < ic->nb_streams)
3816             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3817     }
3818     for(i=0;i<ic->nb_streams;i++)
3819         if (!printed[i])
3820             dump_stream_format(ic, i, index, is_output);
3821
3822     av_free(printed);
3823 }
3824
3825 int64_t av_gettime(void)
3826 {
3827     struct timeval tv;
3828     gettimeofday(&tv,NULL);
3829     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3830 }
3831
3832 uint64_t ff_ntp_time(void)
3833 {
3834   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3835 }
3836
3837 int av_get_frame_filename(char *buf, int buf_size,
3838                           const char *path, int number)
3839 {
3840     const char *p;
3841     char *q, buf1[20], c;
3842     int nd, len, percentd_found;
3843
3844     q = buf;
3845     p = path;
3846     percentd_found = 0;
3847     for(;;) {
3848         c = *p++;
3849         if (c == '\0')
3850             break;
3851         if (c == '%') {
3852             do {
3853                 nd = 0;
3854                 while (isdigit(*p)) {
3855                     nd = nd * 10 + *p++ - '0';
3856                 }
3857                 c = *p++;
3858             } while (isdigit(c));
3859
3860             switch(c) {
3861             case '%':
3862                 goto addchar;
3863             case 'd':
3864                 if (percentd_found)
3865                     goto fail;
3866                 percentd_found = 1;
3867                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3868                 len = strlen(buf1);
3869                 if ((q - buf + len) > buf_size - 1)
3870                     goto fail;
3871                 memcpy(q, buf1, len);
3872                 q += len;
3873                 break;
3874             default:
3875                 goto fail;
3876             }
3877         } else {
3878         addchar:
3879             if ((q - buf) < buf_size - 1)
3880                 *q++ = c;
3881         }
3882     }
3883     if (!percentd_found)
3884         goto fail;
3885     *q = '\0';
3886     return 0;
3887  fail:
3888     *q = '\0';
3889     return -1;
3890 }
3891
3892 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3893 {
3894     int len, i, j, c;
3895 #undef fprintf
3896 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3897
3898     for(i=0;i<size;i+=16) {
3899         len = size - i;
3900         if (len > 16)
3901             len = 16;
3902         PRINT("%08x ", i);
3903         for(j=0;j<16;j++) {
3904             if (j < len)
3905                 PRINT(" %02x", buf[i+j]);
3906             else
3907                 PRINT("   ");
3908         }
3909         PRINT(" ");
3910         for(j=0;j<len;j++) {
3911             c = buf[i+j];
3912             if (c < ' ' || c > '~')
3913                 c = '.';
3914             PRINT("%c", c);
3915         }
3916         PRINT("\n");
3917     }
3918 #undef PRINT
3919 }
3920
3921 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3922 {
3923     hex_dump_internal(NULL, f, 0, buf, size);
3924 }
3925
3926 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3927 {
3928     hex_dump_internal(avcl, NULL, level, buf, size);
3929 }
3930
3931 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3932 {
3933 #undef fprintf
3934 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3935     PRINT("stream #%d:\n", pkt->stream_index);
3936     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3937     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3938     /* DTS is _always_ valid after av_read_frame() */
3939     PRINT("  dts=");
3940     if (pkt->dts == AV_NOPTS_VALUE)
3941         PRINT("N/A");
3942     else
3943         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3944     /* PTS may not be known if B-frames are present. */
3945     PRINT("  pts=");
3946     if (pkt->pts == AV_NOPTS_VALUE)
3947         PRINT("N/A");
3948     else
3949         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3950     PRINT("\n");
3951     PRINT("  size=%d\n", pkt->size);
3952 #undef PRINT
3953     if (dump_payload)
3954         av_hex_dump(f, pkt->data, pkt->size);
3955 }
3956
3957 #if FF_API_PKT_DUMP
3958 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3959 {
3960     AVRational tb = { 1, AV_TIME_BASE };
3961     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3962 }
3963 #endif
3964
3965 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3966 {
3967     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3968 }
3969
3970 #if FF_API_PKT_DUMP
3971 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3972 {
3973     AVRational tb = { 1, AV_TIME_BASE };
3974     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3975 }
3976 #endif
3977
3978 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3979                       AVStream *st)
3980 {
3981     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3982 }
3983
3984 void av_url_split(char *proto, int proto_size,
3985                   char *authorization, int authorization_size,
3986                   char *hostname, int hostname_size,
3987                   int *port_ptr,
3988                   char *path, int path_size,
3989                   const char *url)
3990 {
3991     const char *p, *ls, *at, *col, *brk;
3992
3993     if (port_ptr)               *port_ptr = -1;
3994     if (proto_size > 0)         proto[0] = 0;
3995     if (authorization_size > 0) authorization[0] = 0;
3996     if (hostname_size > 0)      hostname[0] = 0;
3997     if (path_size > 0)          path[0] = 0;
3998
3999     /* parse protocol */
4000     if ((p = strchr(url, ':'))) {
4001         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
4002         p++; /* skip ':' */
4003         if (*p == '/') p++;
4004         if (*p == '/') p++;
4005     } else {
4006         /* no protocol means plain filename */
4007         av_strlcpy(path, url, path_size);
4008         return;
4009     }
4010
4011     /* separate path from hostname */
4012     ls = strchr(p, '/');
4013     if(!ls)
4014         ls = strchr(p, '?');
4015     if(ls)
4016         av_strlcpy(path, ls, path_size);
4017     else
4018         ls = &p[strlen(p)]; // XXX
4019
4020     /* the rest is hostname, use that to parse auth/port */
4021     if (ls != p) {
4022         /* authorization (user[:pass]@hostname) */
4023         if ((at = strchr(p, '@')) && at < ls) {
4024             av_strlcpy(authorization, p,
4025                        FFMIN(authorization_size, at + 1 - p));
4026             p = at + 1; /* skip '@' */
4027         }
4028
4029         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
4030             /* [host]:port */
4031             av_strlcpy(hostname, p + 1,
4032                        FFMIN(hostname_size, brk - p));
4033             if (brk[1] == ':' && port_ptr)
4034                 *port_ptr = atoi(brk + 2);
4035         } else if ((col = strchr(p, ':')) && col < ls) {
4036             av_strlcpy(hostname, p,
4037                        FFMIN(col + 1 - p, hostname_size));
4038             if (port_ptr) *port_ptr = atoi(col + 1);
4039         } else
4040             av_strlcpy(hostname, p,
4041                        FFMIN(ls + 1 - p, hostname_size));
4042     }
4043 }
4044
4045 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4046 {
4047     int i;
4048     static const char hex_table_uc[16] = { '0', '1', '2', '3',
4049                                            '4', '5', '6', '7',
4050                                            '8', '9', 'A', 'B',
4051                                            'C', 'D', 'E', 'F' };
4052     static const char hex_table_lc[16] = { '0', '1', '2', '3',
4053                                            '4', '5', '6', '7',
4054                                            '8', '9', 'a', 'b',
4055                                            'c', 'd', 'e', 'f' };
4056     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4057
4058     for(i = 0; i < s; i++) {
4059         buff[i * 2]     = hex_table[src[i] >> 4];
4060         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4061     }
4062
4063     return buff;
4064 }
4065
4066 int ff_hex_to_data(uint8_t *data, const char *p)
4067 {
4068     int c, len, v;
4069
4070     len = 0;
4071     v = 1;
4072     for (;;) {
4073         p += strspn(p, SPACE_CHARS);
4074         if (*p == '\0')
4075             break;
4076         c = toupper((unsigned char) *p++);
4077         if (c >= '0' && c <= '9')
4078             c = c - '0';
4079         else if (c >= 'A' && c <= 'F')
4080             c = c - 'A' + 10;
4081         else
4082             break;
4083         v = (v << 4) | c;
4084         if (v & 0x100) {
4085             if (data)
4086                 data[len] = v;
4087             len++;
4088             v = 1;
4089         }
4090     }
4091     return len;
4092 }
4093
4094 #if FF_API_SET_PTS_INFO
4095 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4096                      unsigned int pts_num, unsigned int pts_den)
4097 {
4098     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4099 }
4100 #endif
4101
4102 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4103                          unsigned int pts_num, unsigned int pts_den)
4104 {
4105     AVRational new_tb;
4106     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
4107         if(new_tb.num != pts_num)
4108             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
4109     }else
4110         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
4111
4112     if(new_tb.num <= 0 || new_tb.den <= 0) {
4113         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
4114         return;
4115     }
4116     s->time_base = new_tb;
4117     s->pts_wrap_bits = pts_wrap_bits;
4118 }
4119
4120 int ff_url_join(char *str, int size, const char *proto,
4121                 const char *authorization, const char *hostname,
4122                 int port, const char *fmt, ...)
4123 {
4124 #if CONFIG_NETWORK
4125     struct addrinfo hints = { 0 }, *ai;
4126 #endif
4127
4128     str[0] = '\0';
4129     if (proto)
4130         av_strlcatf(str, size, "%s://", proto);
4131     if (authorization && authorization[0])
4132         av_strlcatf(str, size, "%s@", authorization);
4133 #if CONFIG_NETWORK && defined(AF_INET6)
4134     /* Determine if hostname is a numerical IPv6 address,
4135      * properly escape it within [] in that case. */
4136     hints.ai_flags = AI_NUMERICHOST;
4137     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4138         if (ai->ai_family == AF_INET6) {
4139             av_strlcat(str, "[", size);
4140             av_strlcat(str, hostname, size);
4141             av_strlcat(str, "]", size);
4142         } else {
4143             av_strlcat(str, hostname, size);
4144         }
4145         freeaddrinfo(ai);
4146     } else
4147 #endif
4148         /* Not an IPv6 address, just output the plain string. */
4149         av_strlcat(str, hostname, size);
4150
4151     if (port >= 0)
4152         av_strlcatf(str, size, ":%d", port);
4153     if (fmt) {
4154         va_list vl;
4155         int len = strlen(str);
4156
4157         va_start(vl, fmt);
4158         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4159         va_end(vl);
4160     }
4161     return strlen(str);
4162 }
4163
4164 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4165                      AVFormatContext *src)
4166 {
4167     AVPacket local_pkt;
4168
4169     local_pkt = *pkt;
4170     local_pkt.stream_index = dst_stream;
4171     if (pkt->pts != AV_NOPTS_VALUE)
4172         local_pkt.pts = av_rescale_q(pkt->pts,
4173                                      src->streams[pkt->stream_index]->time_base,
4174                                      dst->streams[dst_stream]->time_base);
4175     if (pkt->dts != AV_NOPTS_VALUE)
4176         local_pkt.dts = av_rescale_q(pkt->dts,
4177                                      src->streams[pkt->stream_index]->time_base,
4178                                      dst->streams[dst_stream]->time_base);
4179     return av_write_frame(dst, &local_pkt);
4180 }
4181
4182 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4183                         void *context)
4184 {
4185     const char *ptr = str;
4186
4187     /* Parse key=value pairs. */
4188     for (;;) {
4189         const char *key;
4190         char *dest = NULL, *dest_end;
4191         int key_len, dest_len = 0;
4192
4193         /* Skip whitespace and potential commas. */
4194         while (*ptr && (isspace(*ptr) || *ptr == ','))
4195             ptr++;
4196         if (!*ptr)
4197             break;
4198
4199         key = ptr;
4200
4201         if (!(ptr = strchr(key, '=')))
4202             break;
4203         ptr++;
4204         key_len = ptr - key;
4205
4206         callback_get_buf(context, key, key_len, &dest, &dest_len);
4207         dest_end = dest + dest_len - 1;
4208
4209         if (*ptr == '\"') {
4210             ptr++;
4211             while (*ptr && *ptr != '\"') {
4212                 if (*ptr == '\\') {
4213                     if (!ptr[1])
4214                         break;
4215                     if (dest && dest < dest_end)
4216                         *dest++ = ptr[1];
4217                     ptr += 2;
4218                 } else {
4219                     if (dest && dest < dest_end)
4220                         *dest++ = *ptr;
4221                     ptr++;
4222                 }
4223             }
4224             if (*ptr == '\"')
4225                 ptr++;
4226         } else {
4227             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4228                 if (dest && dest < dest_end)
4229                     *dest++ = *ptr;
4230         }
4231         if (dest)
4232             *dest = 0;
4233     }
4234 }
4235
4236 int ff_find_stream_index(AVFormatContext *s, int id)
4237 {
4238     int i;
4239     for (i = 0; i <