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