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