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