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