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