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