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