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