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