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