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