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