2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
25 #include "avio_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"
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"
43 #include "audiointerleave.h"
55 * various utility functions for use within FFmpeg
58 unsigned avformat_version(void)
60 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
61 return LIBAVFORMAT_VERSION_INT;
64 const char *avformat_configuration(void)
66 return FFMPEG_CONFIGURATION;
69 const char *avformat_license(void)
71 #define LICENSE_PREFIX "libavformat license: "
72 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
77 static int is_relative(int64_t ts) {
78 return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 * Wrap a given time stamp, if there is an indication for an overflow
85 * @param timestamp the time stamp to wrap
86 * @return resulting time stamp
88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
90 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
91 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
92 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
93 timestamp < st->pts_wrap_reference)
94 return timestamp + (1ULL<<st->pts_wrap_bits);
95 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
96 timestamp >= st->pts_wrap_reference)
97 return timestamp - (1ULL<<st->pts_wrap_bits);
102 /** head of registered input format linked list */
103 static AVInputFormat *first_iformat = NULL;
104 /** head of registered output format linked list */
105 static AVOutputFormat *first_oformat = NULL;
107 AVInputFormat *av_iformat_next(AVInputFormat *f)
109 if(f) return f->next;
110 else return first_iformat;
113 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
115 if(f) return f->next;
116 else return first_oformat;
119 void av_register_input_format(AVInputFormat *format)
123 while (*p != NULL) p = &(*p)->next;
128 void av_register_output_format(AVOutputFormat *format)
132 while (*p != NULL) p = &(*p)->next;
137 int av_match_ext(const char *filename, const char *extensions)
145 ext = strrchr(filename, '.');
151 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
154 if (!av_strcasecmp(ext1, ext))
164 static int match_format(const char *name, const char *names)
172 namelen = strlen(name);
173 while ((p = strchr(names, ','))) {
174 len = FFMAX(p - names, namelen);
175 if (!av_strncasecmp(name, names, len))
179 return !av_strcasecmp(name, names);
182 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
183 const char *mime_type)
185 AVOutputFormat *fmt = NULL, *fmt_found;
186 int score_max, score;
188 /* specific test for image sequences */
189 #if CONFIG_IMAGE2_MUXER
190 if (!short_name && filename &&
191 av_filename_number_test(filename) &&
192 ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
193 return av_guess_format("image2", NULL, NULL);
196 /* Find the proper file type. */
199 while ((fmt = av_oformat_next(fmt))) {
201 if (fmt->name && short_name && match_format(short_name, fmt->name))
203 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
205 if (filename && fmt->extensions &&
206 av_match_ext(filename, fmt->extensions)) {
209 if (score > score_max) {
217 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
218 const char *filename, const char *mime_type, enum AVMediaType type){
219 if(type == AVMEDIA_TYPE_VIDEO){
220 enum AVCodecID codec_id= AV_CODEC_ID_NONE;
222 #if CONFIG_IMAGE2_MUXER
223 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
224 codec_id= ff_guess_image2_codec(filename);
227 if(codec_id == AV_CODEC_ID_NONE)
228 codec_id= fmt->video_codec;
230 }else if(type == AVMEDIA_TYPE_AUDIO)
231 return fmt->audio_codec;
232 else if (type == AVMEDIA_TYPE_SUBTITLE)
233 return fmt->subtitle_codec;
235 return AV_CODEC_ID_NONE;
238 AVInputFormat *av_find_input_format(const char *short_name)
240 AVInputFormat *fmt = NULL;
241 while ((fmt = av_iformat_next(fmt))) {
242 if (match_format(short_name, fmt->name))
248 int ffio_limit(AVIOContext *s, int size)
251 int64_t remaining= s->maxsize - avio_tell(s);
252 if(remaining < size){
253 int64_t newsize= avio_size(s);
254 if(!s->maxsize || s->maxsize<newsize)
255 s->maxsize= newsize - !newsize;
256 remaining= s->maxsize - avio_tell(s);
257 remaining= FFMAX(remaining, 0);
260 if(s->maxsize>=0 && remaining+1 < size){
261 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
268 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
271 int orig_size = size;
272 size= ffio_limit(s, size);
274 ret= av_new_packet(pkt, size);
279 pkt->pos= avio_tell(s);
281 ret= avio_read(s, pkt->data, size);
285 av_shrink_packet(pkt, ret);
286 if (pkt->size < orig_size)
287 pkt->flags |= AV_PKT_FLAG_CORRUPT;
292 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
297 return av_get_packet(s, pkt, size);
298 old_size = pkt->size;
299 ret = av_grow_packet(pkt, size);
302 ret = avio_read(s, pkt->data + old_size, size);
303 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
308 int av_filename_number_test(const char *filename)
311 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
314 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
316 AVProbeData lpd = *pd;
317 AVInputFormat *fmt1 = NULL, *fmt;
318 int score, nodat = 0, score_max=0;
319 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
322 lpd.buf = zerobuffer;
324 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
325 int id3len = ff_id3v2_tag_len(lpd.buf);
326 if (lpd.buf_size > id3len + 16) {
328 lpd.buf_size -= id3len;
334 while ((fmt1 = av_iformat_next(fmt1))) {
335 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
338 if (fmt1->read_probe) {
339 score = fmt1->read_probe(&lpd);
340 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
341 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
342 } else if (fmt1->extensions) {
343 if (av_match_ext(lpd.filename, fmt1->extensions)) {
347 if (score > score_max) {
350 }else if (score == score_max)
353 *score_ret= score_max;
358 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
361 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
362 if(score_ret > *score_max){
363 *score_max= score_ret;
369 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
371 return av_probe_input_format2(pd, is_opened, &score);
374 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
376 static const struct {
377 const char *name; enum AVCodecID id; enum AVMediaType type;
379 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
380 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
381 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
382 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
383 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
384 { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
385 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
386 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
387 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
391 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
393 if (fmt && st->request_probe <= score) {
395 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
396 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
397 for (i = 0; fmt_id_type[i].name; i++) {
398 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
399 st->codec->codec_id = fmt_id_type[i].id;
400 st->codec->codec_type = fmt_id_type[i].type;
408 /************************************************************/
409 /* input media file */
411 int av_demuxer_open(AVFormatContext *ic){
414 if (ic->iformat->read_header) {
415 err = ic->iformat->read_header(ic);
420 if (ic->pb && !ic->data_offset)
421 ic->data_offset = avio_tell(ic->pb);
427 /** size of probe buffer, for guessing file type from file contents */
428 #define PROBE_BUF_MIN 2048
429 #define PROBE_BUF_MAX (1<<20)
431 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
432 const char *filename, void *logctx,
433 unsigned int offset, unsigned int max_probe_size)
435 AVProbeData pd = { filename ? filename : "", NULL, -offset };
436 unsigned char *buf = NULL;
438 int ret = 0, probe_size, buf_offset = 0;
440 if (!max_probe_size) {
441 max_probe_size = PROBE_BUF_MAX;
442 } else if (max_probe_size > PROBE_BUF_MAX) {
443 max_probe_size = PROBE_BUF_MAX;
444 } else if (max_probe_size < PROBE_BUF_MIN) {
445 av_log(logctx, AV_LOG_ERROR,
446 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
447 return AVERROR(EINVAL);
450 if (offset >= max_probe_size) {
451 return AVERROR(EINVAL);
454 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
455 if (!av_strcasecmp(mime_type, "audio/aacp")) {
456 *fmt = av_find_input_format("aac");
458 av_freep(&mime_type);
461 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
462 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
463 int score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
466 if (probe_size < offset) {
470 /* read probe data */
471 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
474 return AVERROR(ENOMEM);
477 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
478 /* fail if error was not end of file, otherwise, lower score */
479 if (ret != AVERROR_EOF) {
484 ret = 0; /* error was end of file, nothing read */
486 pd.buf_size = buf_offset += ret;
487 pd.buf = &buf[offset];
489 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
491 /* guess file format */
492 *fmt = av_probe_input_format2(&pd, 1, &score);
494 if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
495 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
497 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
503 return AVERROR_INVALIDDATA;
506 /* rewind. reuse probe buffer to avoid seeking */
507 ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
512 /* open input file and probe the format if necessary */
513 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
516 AVProbeData pd = {filename, NULL, 0};
517 int score = AVPROBE_SCORE_RETRY;
520 s->flags |= AVFMT_FLAG_CUSTOM_IO;
522 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
523 else if (s->iformat->flags & AVFMT_NOFILE)
524 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
525 "will be ignored with AVFMT_NOFILE format.\n");
529 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
530 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
533 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
534 &s->interrupt_callback, options)) < 0)
538 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
541 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
542 AVPacketList **plast_pktl){
543 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
548 (*plast_pktl)->next = pktl;
550 *packet_buffer = pktl;
552 /* add the packet in the buffered packet list */
558 void avformat_queue_attached_pictures(AVFormatContext *s)
561 for (i = 0; i < s->nb_streams; i++)
562 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
563 s->streams[i]->discard < AVDISCARD_ALL) {
564 AVPacket copy = s->streams[i]->attached_pic;
565 copy.destruct = NULL;
566 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
570 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
572 AVFormatContext *s = *ps;
574 AVDictionary *tmp = NULL;
575 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
577 if (!s && !(s = avformat_alloc_context()))
578 return AVERROR(ENOMEM);
580 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
581 return AVERROR(EINVAL);
587 av_dict_copy(&tmp, *options, 0);
589 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
592 if ((ret = init_input(s, filename, &tmp)) < 0)
594 avio_skip(s->pb, s->skip_initial_bytes);
596 /* check filename in case an image number is expected */
597 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
598 if (!av_filename_number_test(filename)) {
599 ret = AVERROR(EINVAL);
604 s->duration = s->start_time = AV_NOPTS_VALUE;
605 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
607 /* allocate private data */
608 if (s->iformat->priv_data_size > 0) {
609 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
610 ret = AVERROR(ENOMEM);
613 if (s->iformat->priv_class) {
614 *(const AVClass**)s->priv_data = s->iformat->priv_class;
615 av_opt_set_defaults(s->priv_data);
616 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
621 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
623 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
625 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
626 if ((ret = s->iformat->read_header(s)) < 0)
629 if (id3v2_extra_meta) {
630 if (!strcmp(s->iformat->name, "mp3")) {
631 if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
634 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
636 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
638 avformat_queue_attached_pictures(s);
640 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
641 s->data_offset = avio_tell(s->pb);
643 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
646 av_dict_free(options);
653 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
655 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
657 avformat_free_context(s);
662 /*******************************************************/
664 static void force_codec_ids(AVFormatContext *s, AVStream *st)
666 switch(st->codec->codec_type){
667 case AVMEDIA_TYPE_VIDEO:
668 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
670 case AVMEDIA_TYPE_AUDIO:
671 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
673 case AVMEDIA_TYPE_SUBTITLE:
674 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
679 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
681 if(st->request_probe>0){
682 AVProbeData *pd = &st->probe_data;
684 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
688 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
692 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
693 pd->buf_size += pkt->size;
694 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
697 st->probe_packets = 0;
699 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
704 end= s->raw_packet_buffer_remaining_size <= 0
705 || st->probe_packets<=0;
707 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
708 int score= set_codec_from_probe_data(s, st, pd);
709 if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
713 st->request_probe= -1;
714 if(st->codec->codec_id != AV_CODEC_ID_NONE){
715 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
717 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
719 force_codec_ids(s, st);
724 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
730 AVPacketList *pktl = s->raw_packet_buffer;
734 st = s->streams[pkt->stream_index];
735 if(st->request_probe <= 0){
736 s->raw_packet_buffer = pktl->next;
737 s->raw_packet_buffer_remaining_size += pkt->size;
746 ret= s->iformat->read_packet(s, pkt);
748 if (!pktl || ret == AVERROR(EAGAIN))
750 for (i = 0; i < s->nb_streams; i++) {
752 if (st->probe_packets) {
753 probe_codec(s, st, NULL);
755 av_assert0(st->request_probe <= 0);
760 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
761 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
762 av_log(s, AV_LOG_WARNING,
763 "Dropped corrupted packet (stream = %d)\n",
769 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
770 av_packet_merge_side_data(pkt);
772 if(pkt->stream_index >= (unsigned)s->nb_streams){
773 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
777 st= s->streams[pkt->stream_index];
778 pkt->dts = wrap_timestamp(st, pkt->dts);
779 pkt->pts = wrap_timestamp(st, pkt->pts);
781 force_codec_ids(s, st);
783 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
784 if (s->use_wallclock_as_timestamps)
785 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
787 if(!pktl && st->request_probe <= 0)
790 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
791 s->raw_packet_buffer_remaining_size -= pkt->size;
793 probe_codec(s, st, pkt);
797 #if FF_API_READ_PACKET
798 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
800 return ff_read_packet(s, pkt);
805 /**********************************************************/
807 static int determinable_frame_size(AVCodecContext *avctx)
809 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
810 avctx->codec_id == AV_CODEC_ID_MP1 ||
811 avctx->codec_id == AV_CODEC_ID_MP2 ||
812 avctx->codec_id == AV_CODEC_ID_MP3/* ||
813 avctx->codec_id == AV_CODEC_ID_CELT*/)
819 * Get the number of samples of an audio frame. Return -1 on error.
821 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
825 /* give frame_size priority if demuxing */
826 if (!mux && enc->frame_size > 1)
827 return enc->frame_size;
829 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
832 /* fallback to using frame_size if muxing */
833 if (enc->frame_size > 1)
834 return enc->frame_size;
836 //For WMA we currently have no other means to calculate duration thus we
837 //do it here by assuming CBR, which is true for all known cases.
838 if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
839 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
840 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
848 * Return the frame duration in seconds. Return 0 if not available.
850 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
851 AVCodecParserContext *pc, AVPacket *pkt)
857 switch(st->codec->codec_type) {
858 case AVMEDIA_TYPE_VIDEO:
859 if (st->r_frame_rate.num && !pc) {
860 *pnum = st->r_frame_rate.den;
861 *pden = st->r_frame_rate.num;
862 } else if(st->time_base.num*1000LL > st->time_base.den) {
863 *pnum = st->time_base.num;
864 *pden = st->time_base.den;
865 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
866 *pnum = st->codec->time_base.num;
867 *pden = st->codec->time_base.den;
868 if (pc && pc->repeat_pict) {
869 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
870 *pden /= 1 + pc->repeat_pict;
872 *pnum *= 1 + pc->repeat_pict;
874 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
875 //Thus if we have no parser in such case leave duration undefined.
876 if(st->codec->ticks_per_frame>1 && !pc){
881 case AVMEDIA_TYPE_AUDIO:
882 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
883 if (frame_size <= 0 || st->codec->sample_rate <= 0)
886 *pden = st->codec->sample_rate;
893 static int is_intra_only(AVCodecContext *enc){
894 const AVCodecDescriptor *desc;
896 if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
899 desc = av_codec_get_codec_descriptor(enc);
901 desc = avcodec_descriptor_get(enc->codec_id);
902 av_codec_set_codec_descriptor(enc, desc);
905 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
909 static int has_decode_delay_been_guessed(AVStream *st)
911 if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
912 if(!st->info) // if we have left find_stream_info then nb_decoded_frames wont increase anymore for stream copy
914 #if CONFIG_H264_DECODER
915 if(st->codec->has_b_frames &&
916 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
919 if(st->codec->has_b_frames<3)
920 return st->nb_decoded_frames >= 7;
921 else if(st->codec->has_b_frames<4)
922 return st->nb_decoded_frames >= 18;
924 return st->nb_decoded_frames >= 20;
927 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
931 if (pktl == s->parse_queue_end)
932 return s->packet_buffer;
936 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
938 if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
939 st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
942 // reference time stamp should be 60 s before first time stamp
943 int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
944 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
945 int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
946 (st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
947 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
949 AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
951 if (!first_program) {
952 int default_stream_index = av_find_default_stream_index(s);
953 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
954 for (i=0; i<s->nb_streams; i++) {
955 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
956 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
960 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
961 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
965 AVProgram *program = first_program;
967 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
968 pts_wrap_reference = program->pts_wrap_reference;
969 pts_wrap_behavior = program->pts_wrap_behavior;
972 program = av_find_program_from_stream(s, program, stream_index);
975 // update every program with differing pts_wrap_reference
976 program = first_program;
978 if (program->pts_wrap_reference != pts_wrap_reference) {
979 for (i=0; i<program->nb_stream_indexes; i++) {
980 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
981 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
984 program->pts_wrap_reference = pts_wrap_reference;
985 program->pts_wrap_behavior = pts_wrap_behavior;
987 program = av_find_program_from_stream(s, program, stream_index);
995 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
996 int64_t dts, int64_t pts, AVPacket *pkt)
998 AVStream *st= s->streams[stream_index];
999 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1000 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1004 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
1007 delay = st->codec->has_b_frames;
1008 st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
1010 shift = st->first_dts - RELATIVE_TS_BASE;
1012 for (i=0; i<MAX_REORDER_DELAY+1; i++)
1013 pts_buffer[i] = AV_NOPTS_VALUE;
1015 if (is_relative(pts))
1018 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1019 if(pktl->pkt.stream_index != stream_index)
1021 if(is_relative(pktl->pkt.pts))
1022 pktl->pkt.pts += shift;
1024 if(is_relative(pktl->pkt.dts))
1025 pktl->pkt.dts += shift;
1027 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1028 st->start_time= pktl->pkt.pts;
1030 if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1031 pts_buffer[0]= pktl->pkt.pts;
1032 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
1033 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
1034 if(pktl->pkt.dts == AV_NOPTS_VALUE)
1035 pktl->pkt.dts= pts_buffer[0];
1039 if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
1040 // correct first time stamps to negative values
1041 st->first_dts = wrap_timestamp(st, st->first_dts);
1042 st->cur_dts = wrap_timestamp(st, st->cur_dts);
1043 pkt->dts = wrap_timestamp(st, pkt->dts);
1044 pkt->pts = wrap_timestamp(st, pkt->pts);
1045 pts = wrap_timestamp(st, pts);
1048 if (st->start_time == AV_NOPTS_VALUE)
1049 st->start_time = pts;
1052 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1053 int stream_index, int duration)
1055 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1056 int64_t cur_dts= RELATIVE_TS_BASE;
1058 if(st->first_dts != AV_NOPTS_VALUE){
1059 cur_dts= st->first_dts;
1060 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1061 if(pktl->pkt.stream_index == stream_index){
1062 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1064 cur_dts -= duration;
1067 if(pktl && pktl->pkt.dts != st->first_dts) {
1068 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in the queue\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
1072 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1075 pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1076 st->first_dts = cur_dts;
1077 }else if(st->cur_dts != RELATIVE_TS_BASE)
1080 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1081 if(pktl->pkt.stream_index != stream_index)
1083 if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1084 && !pktl->pkt.duration){
1085 pktl->pkt.dts= cur_dts;
1086 if(!st->codec->has_b_frames)
1087 pktl->pkt.pts= cur_dts;
1088 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1089 pktl->pkt.duration = duration;
1092 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1095 st->cur_dts= cur_dts;
1098 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1099 AVCodecParserContext *pc, AVPacket *pkt)
1101 int num, den, presentation_delayed, delay, i;
1104 if (s->flags & AVFMT_FLAG_NOFILLIN)
1107 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1108 pkt->dts= AV_NOPTS_VALUE;
1110 if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1111 //FIXME Set low_delay = 0 when has_b_frames = 1
1112 st->codec->has_b_frames = 1;
1114 /* do we have a video B-frame ? */
1115 delay= st->codec->has_b_frames;
1116 presentation_delayed = 0;
1118 /* XXX: need has_b_frame, but cannot get it if the codec is
1121 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1122 presentation_delayed = 1;
1124 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){
1125 if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1126 pkt->dts -= 1LL<<st->pts_wrap_bits;
1128 pkt->pts += 1LL<<st->pts_wrap_bits;
1131 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1132 // we take the conservative approach and discard both
1133 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1134 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1135 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1136 if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1137 pkt->dts= AV_NOPTS_VALUE;
1140 if (pkt->duration == 0) {
1141 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1143 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1146 if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1147 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1149 /* correct timestamps with byte offset if demuxers only have timestamps
1150 on packet boundaries */
1151 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1152 /* this will estimate bitrate based on this frame's duration and size */
1153 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1154 if(pkt->pts != AV_NOPTS_VALUE)
1156 if(pkt->dts != AV_NOPTS_VALUE)
1160 if (pc && pc->dts_sync_point >= 0) {
1161 // we have synchronization info from the parser
1162 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1164 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1165 if (pkt->dts != AV_NOPTS_VALUE) {
1166 // got DTS from the stream, update reference timestamp
1167 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1168 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1169 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1170 // compute DTS based on reference timestamp
1171 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1172 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1174 if (pc->dts_sync_point > 0)
1175 st->reference_dts = pkt->dts; // new reference
1179 /* This may be redundant, but it should not hurt. */
1180 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1181 presentation_delayed = 1;
1183 av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1184 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1185 /* interpolate PTS and DTS if they are not present */
1186 //We skip H264 currently because delay and has_b_frames are not reliably set
1187 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1188 if (presentation_delayed) {
1189 /* DTS = decompression timestamp */
1190 /* PTS = presentation timestamp */
1191 if (pkt->dts == AV_NOPTS_VALUE)
1192 pkt->dts = st->last_IP_pts;
1193 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1194 if (pkt->dts == AV_NOPTS_VALUE)
1195 pkt->dts = st->cur_dts;
1197 /* this is tricky: the dts must be incremented by the duration
1198 of the frame we are displaying, i.e. the last I- or P-frame */
1199 if (st->last_IP_duration == 0)
1200 st->last_IP_duration = pkt->duration;
1201 if(pkt->dts != AV_NOPTS_VALUE)
1202 st->cur_dts = pkt->dts + st->last_IP_duration;
1203 st->last_IP_duration = pkt->duration;
1204 st->last_IP_pts= pkt->pts;
1205 /* cannot compute PTS if not present (we can compute it only
1206 by knowing the future */
1207 } else if (pkt->pts != AV_NOPTS_VALUE ||
1208 pkt->dts != AV_NOPTS_VALUE ||
1210 int duration = pkt->duration;
1212 /* presentation is not delayed : PTS and DTS are the same */
1213 if (pkt->pts == AV_NOPTS_VALUE)
1214 pkt->pts = pkt->dts;
1215 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1217 if (pkt->pts == AV_NOPTS_VALUE)
1218 pkt->pts = st->cur_dts;
1219 pkt->dts = pkt->pts;
1220 if (pkt->pts != AV_NOPTS_VALUE)
1221 st->cur_dts = pkt->pts + duration;
1225 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1226 st->pts_buffer[0]= pkt->pts;
1227 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1228 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1229 if(pkt->dts == AV_NOPTS_VALUE)
1230 pkt->dts= st->pts_buffer[0];
1232 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1233 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1235 if(pkt->dts > st->cur_dts)
1236 st->cur_dts = pkt->dts;
1238 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1239 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1242 if (is_intra_only(st->codec))
1243 pkt->flags |= AV_PKT_FLAG_KEY;
1245 pkt->convergence_duration = pc->convergence_duration;
1248 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1251 AVPacketList *pktl = *pkt_buf;
1252 *pkt_buf = pktl->next;
1253 av_free_packet(&pktl->pkt);
1256 *pkt_buf_end = NULL;
1260 * Parse a packet, add all split parts to parse_queue
1262 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1264 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1266 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1267 AVStream *st = s->streams[stream_index];
1268 uint8_t *data = pkt ? pkt->data : NULL;
1269 int size = pkt ? pkt->size : 0;
1270 int ret = 0, got_output = 0;
1273 av_init_packet(&flush_pkt);
1276 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1277 // preserve 0-size sync packets
1278 compute_pkt_fields(s, st, st->parser, pkt);
1281 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1284 av_init_packet(&out_pkt);
1285 len = av_parser_parse2(st->parser, st->codec,
1286 &out_pkt.data, &out_pkt.size, data, size,
1287 pkt->pts, pkt->dts, pkt->pos);
1289 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1291 /* increment read pointer */
1295 got_output = !!out_pkt.size;
1300 /* set the duration */
1301 out_pkt.duration = 0;
1302 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1303 if (st->codec->sample_rate > 0) {
1304 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1305 (AVRational){ 1, st->codec->sample_rate },
1309 } else if (st->codec->time_base.num != 0 &&
1310 st->codec->time_base.den != 0) {
1311 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1312 st->codec->time_base,
1317 out_pkt.stream_index = st->index;
1318 out_pkt.pts = st->parser->pts;
1319 out_pkt.dts = st->parser->dts;
1320 out_pkt.pos = st->parser->pos;
1322 if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1323 out_pkt.pos = st->parser->frame_offset;
1325 if (st->parser->key_frame == 1 ||
1326 (st->parser->key_frame == -1 &&
1327 st->parser->pict_type == AV_PICTURE_TYPE_I))
1328 out_pkt.flags |= AV_PKT_FLAG_KEY;
1330 if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1331 out_pkt.flags |= AV_PKT_FLAG_KEY;
1333 compute_pkt_fields(s, st, st->parser, &out_pkt);
1335 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1336 out_pkt.destruct = pkt->destruct;
1337 pkt->destruct = NULL;
1339 if ((ret = av_dup_packet(&out_pkt)) < 0)
1342 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1343 av_free_packet(&out_pkt);
1344 ret = AVERROR(ENOMEM);
1350 /* end of the stream => close and free the parser */
1351 if (pkt == &flush_pkt) {
1352 av_parser_close(st->parser);
1357 av_free_packet(pkt);
1361 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1362 AVPacketList **pkt_buffer_end,
1366 av_assert0(*pkt_buffer);
1369 *pkt_buffer = pktl->next;
1371 *pkt_buffer_end = NULL;
1376 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1378 int ret = 0, i, got_packet = 0;
1380 av_init_packet(pkt);
1382 while (!got_packet && !s->parse_queue) {
1386 /* read next packet */
1387 ret = ff_read_packet(s, &cur_pkt);
1389 if (ret == AVERROR(EAGAIN))
1391 /* flush the parsers */
1392 for(i = 0; i < s->nb_streams; i++) {
1394 if (st->parser && st->need_parsing)
1395 parse_packet(s, NULL, st->index);
1397 /* all remaining packets are now in parse_queue =>
1398 * really terminate parsing */
1402 st = s->streams[cur_pkt.stream_index];
1404 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1405 cur_pkt.dts != AV_NOPTS_VALUE &&
1406 cur_pkt.pts < cur_pkt.dts) {
1407 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1408 cur_pkt.stream_index,
1409 av_ts2str(cur_pkt.pts),
1410 av_ts2str(cur_pkt.dts),
1413 if (s->debug & FF_FDEBUG_TS)
1414 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1415 cur_pkt.stream_index,
1416 av_ts2str(cur_pkt.pts),
1417 av_ts2str(cur_pkt.dts),
1422 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1423 st->parser = av_parser_init(st->codec->codec_id);
1425 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1426 "%s, packets or times may be invalid.\n",
1427 avcodec_get_name(st->codec->codec_id));
1428 /* no parser available: just output the raw packets */
1429 st->need_parsing = AVSTREAM_PARSE_NONE;
1430 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1431 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1432 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1433 st->parser->flags |= PARSER_FLAG_ONCE;
1434 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1435 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1439 if (!st->need_parsing || !st->parser) {
1440 /* no parsing needed: we just output the packet as is */
1442 compute_pkt_fields(s, st, NULL, pkt);
1443 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1444 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1445 ff_reduce_index(s, st->index);
1446 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1449 } else if (st->discard < AVDISCARD_ALL) {
1450 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1454 av_free_packet(&cur_pkt);
1456 if (pkt->flags & AV_PKT_FLAG_KEY)
1457 st->skip_to_keyframe = 0;
1458 if (st->skip_to_keyframe) {
1459 av_free_packet(&cur_pkt);
1464 if (!got_packet && s->parse_queue)
1465 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1467 if(s->debug & FF_FDEBUG_TS)
1468 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1470 av_ts2str(pkt->pts),
1471 av_ts2str(pkt->dts),
1479 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1481 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1487 ret = s->packet_buffer ?
1488 read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1489 read_frame_internal(s, pkt);
1496 AVPacketList *pktl = s->packet_buffer;
1499 AVPacket *next_pkt = &pktl->pkt;
1501 if (next_pkt->dts != AV_NOPTS_VALUE) {
1502 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1503 // last dts seen for this stream. if any of packets following
1504 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1505 int64_t last_dts = next_pkt->dts;
1506 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1507 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1508 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1509 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1510 next_pkt->pts = pktl->pkt.dts;
1512 if (last_dts != AV_NOPTS_VALUE) {
1513 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1514 last_dts = pktl->pkt.dts;
1519 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1520 // Fixing the last reference frame had none pts issue (For MXF etc).
1521 // We only do this when
1523 // 2. we are not able to resolve a pts value for current packet.
1524 // 3. the packets for this stream at the end of the files had valid dts.
1525 next_pkt->pts = last_dts + next_pkt->duration;
1527 pktl = s->packet_buffer;
1530 /* read packet from packet buffer, if there is data */
1531 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1532 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1533 ret = read_from_packet_buffer(&s->packet_buffer,
1534 &s->packet_buffer_end, pkt);
1539 ret = read_frame_internal(s, pkt);
1541 if (pktl && ret != AVERROR(EAGAIN)) {
1548 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1549 &s->packet_buffer_end)) < 0)
1550 return AVERROR(ENOMEM);
1555 st = s->streams[pkt->stream_index];
1556 if (st->skip_samples) {
1557 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1558 AV_WL32(p, st->skip_samples);
1559 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1560 st->skip_samples = 0;
1563 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1564 ff_reduce_index(s, st->index);
1565 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1568 if (is_relative(pkt->dts))
1569 pkt->dts -= RELATIVE_TS_BASE;
1570 if (is_relative(pkt->pts))
1571 pkt->pts -= RELATIVE_TS_BASE;
1576 /* XXX: suppress the packet queue */
1577 static void flush_packet_queue(AVFormatContext *s)
1579 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1580 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1581 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1583 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1586 /*******************************************************/
1589 int av_find_default_stream_index(AVFormatContext *s)
1591 int first_audio_index = -1;
1595 if (s->nb_streams <= 0)
1597 for(i = 0; i < s->nb_streams; i++) {
1599 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1600 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1603 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1604 first_audio_index = i;
1606 return first_audio_index >= 0 ? first_audio_index : 0;
1610 * Flush the frame reader.
1612 void ff_read_frame_flush(AVFormatContext *s)
1617 flush_packet_queue(s);
1619 /* for each stream, reset read state */
1620 for(i = 0; i < s->nb_streams; i++) {
1624 av_parser_close(st->parser);
1627 st->last_IP_pts = AV_NOPTS_VALUE;
1628 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1629 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1630 st->reference_dts = AV_NOPTS_VALUE;
1632 st->probe_packets = MAX_PROBE_PACKETS;
1634 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1635 st->pts_buffer[j]= AV_NOPTS_VALUE;
1639 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1643 for(i = 0; i < s->nb_streams; i++) {
1644 AVStream *st = s->streams[i];
1646 st->cur_dts = av_rescale(timestamp,
1647 st->time_base.den * (int64_t)ref_st->time_base.num,
1648 st->time_base.num * (int64_t)ref_st->time_base.den);
1652 void ff_reduce_index(AVFormatContext *s, int stream_index)
1654 AVStream *st= s->streams[stream_index];
1655 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1657 if((unsigned)st->nb_index_entries >= max_entries){
1659 for(i=0; 2*i<st->nb_index_entries; i++)
1660 st->index_entries[i]= st->index_entries[2*i];
1661 st->nb_index_entries= i;
1665 int ff_add_index_entry(AVIndexEntry **index_entries,
1666 int *nb_index_entries,
1667 unsigned int *index_entries_allocated_size,
1668 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1670 AVIndexEntry *entries, *ie;
1673 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1676 if(timestamp == AV_NOPTS_VALUE)
1677 return AVERROR(EINVAL);
1679 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1680 timestamp -= RELATIVE_TS_BASE;
1682 entries = av_fast_realloc(*index_entries,
1683 index_entries_allocated_size,
1684 (*nb_index_entries + 1) *
1685 sizeof(AVIndexEntry));
1689 *index_entries= entries;
1691 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1694 index= (*nb_index_entries)++;
1695 ie= &entries[index];
1696 assert(index==0 || ie[-1].timestamp < timestamp);
1698 ie= &entries[index];
1699 if(ie->timestamp != timestamp){
1700 if(ie->timestamp <= timestamp)
1702 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1703 (*nb_index_entries)++;
1704 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1705 distance= ie->min_distance;
1709 ie->timestamp = timestamp;
1710 ie->min_distance= distance;
1717 int av_add_index_entry(AVStream *st,
1718 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1720 timestamp = wrap_timestamp(st, timestamp);
1721 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1722 &st->index_entries_allocated_size, pos,
1723 timestamp, size, distance, flags);
1726 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1727 int64_t wanted_timestamp, int flags)
1735 //optimize appending index entries at the end
1736 if(b && entries[b-1].timestamp < wanted_timestamp)
1741 timestamp = entries[m].timestamp;
1742 if(timestamp >= wanted_timestamp)
1744 if(timestamp <= wanted_timestamp)
1747 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1749 if(!(flags & AVSEEK_FLAG_ANY)){
1750 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1751 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1760 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1763 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1764 wanted_timestamp, flags);
1767 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1768 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1770 return wrap_timestamp(s->streams[stream_index], read_timestamp(s, stream_index, ppos, pos_limit));
1773 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1775 AVInputFormat *avif= s->iformat;
1776 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1777 int64_t ts_min, ts_max, ts;
1782 if (stream_index < 0)
1785 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1788 ts_min= AV_NOPTS_VALUE;
1789 pos_limit= -1; //gcc falsely says it may be uninitialized
1791 st= s->streams[stream_index];
1792 if(st->index_entries){
1795 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()
1796 index= FFMAX(index, 0);
1797 e= &st->index_entries[index];
1799 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1801 ts_min= e->timestamp;
1802 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1803 pos_min, av_ts2str(ts_min));
1808 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1809 assert(index < st->nb_index_entries);
1811 e= &st->index_entries[index];
1812 assert(e->timestamp >= target_ts);
1814 ts_max= e->timestamp;
1815 pos_limit= pos_max - e->min_distance;
1816 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1817 pos_max, pos_limit, av_ts2str(ts_max));
1821 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1826 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1829 ff_read_frame_flush(s);
1830 ff_update_cur_dts(s, st, ts);
1835 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1836 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1837 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1838 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1841 int64_t start_pos, filesize;
1844 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1846 if(ts_min == AV_NOPTS_VALUE){
1847 pos_min = s->data_offset;
1848 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1849 if (ts_min == AV_NOPTS_VALUE)
1853 if(ts_min >= target_ts){
1858 if(ts_max == AV_NOPTS_VALUE){
1860 filesize = avio_size(s->pb);
1861 pos_max = filesize - 1;
1864 ts_max = ff_read_timestamp(s, stream_index, &pos_max, pos_max + step, read_timestamp);
1866 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1867 if (ts_max == AV_NOPTS_VALUE)
1871 int64_t tmp_pos= pos_max + 1;
1872 int64_t tmp_ts= ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1873 if(tmp_ts == AV_NOPTS_VALUE)
1877 if(tmp_pos >= filesize)
1883 if(ts_max <= target_ts){
1888 if(ts_min > ts_max){
1890 }else if(ts_min == ts_max){
1895 while (pos_min < pos_limit) {
1896 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1897 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1898 assert(pos_limit <= pos_max);
1901 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1902 // interpolate position (better than dichotomy)
1903 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1904 + pos_min - approximate_keyframe_distance;
1905 }else if(no_change==1){
1906 // bisection, if interpolation failed to change min or max pos last time
1907 pos = (pos_min + pos_limit)>>1;
1909 /* linear search if bisection failed, can only happen if there
1910 are very few or no keyframes between min/max */
1915 else if(pos > pos_limit)
1919 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1924 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1925 pos_min, pos, pos_max,
1926 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1927 pos_limit, start_pos, no_change);
1928 if(ts == AV_NOPTS_VALUE){
1929 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1932 assert(ts != AV_NOPTS_VALUE);
1933 if (target_ts <= ts) {
1934 pos_limit = start_pos - 1;
1938 if (target_ts >= ts) {
1944 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1945 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1948 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1950 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1951 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1952 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1958 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1959 int64_t pos_min, pos_max;
1961 pos_min = s->data_offset;
1962 pos_max = avio_size(s->pb) - 1;
1964 if (pos < pos_min) pos= pos_min;
1965 else if(pos > pos_max) pos= pos_max;
1967 avio_seek(s->pb, pos, SEEK_SET);
1972 static int seek_frame_generic(AVFormatContext *s,
1973 int stream_index, int64_t timestamp, int flags)
1980 st = s->streams[stream_index];
1982 index = av_index_search_timestamp(st, timestamp, flags);
1984 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1987 if(index < 0 || index==st->nb_index_entries-1){
1991 if(st->nb_index_entries){
1992 assert(st->index_entries);
1993 ie= &st->index_entries[st->nb_index_entries-1];
1994 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1996 ff_update_cur_dts(s, st, ie->timestamp);
1998 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2004 read_status = av_read_frame(s, &pkt);
2005 } while (read_status == AVERROR(EAGAIN));
2006 if (read_status < 0)
2008 av_free_packet(&pkt);
2009 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
2010 if(pkt.flags & AV_PKT_FLAG_KEY)
2012 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
2013 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);
2018 index = av_index_search_timestamp(st, timestamp, flags);
2023 ff_read_frame_flush(s);
2024 if (s->iformat->read_seek){
2025 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2028 ie = &st->index_entries[index];
2029 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2031 ff_update_cur_dts(s, st, ie->timestamp);
2036 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2037 int64_t timestamp, int flags)
2042 if (flags & AVSEEK_FLAG_BYTE) {
2043 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2045 ff_read_frame_flush(s);
2046 return seek_frame_byte(s, stream_index, timestamp, flags);
2049 if(stream_index < 0){
2050 stream_index= av_find_default_stream_index(s);
2051 if(stream_index < 0)
2054 st= s->streams[stream_index];
2055 /* timestamp for default must be expressed in AV_TIME_BASE units */
2056 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2059 /* first, we try the format specific seek */
2060 if (s->iformat->read_seek) {
2061 ff_read_frame_flush(s);
2062 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2069 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2070 ff_read_frame_flush(s);
2071 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2072 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2073 ff_read_frame_flush(s);
2074 return seek_frame_generic(s, stream_index, timestamp, flags);
2080 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2082 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
2085 avformat_queue_attached_pictures(s);
2090 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2092 if(min_ts > ts || max_ts < ts)
2096 flags |= AVSEEK_FLAG_ANY;
2098 if (s->iformat->read_seek2) {
2100 ff_read_frame_flush(s);
2102 if (stream_index == -1 && s->nb_streams == 1) {
2103 AVRational time_base = s->streams[0]->time_base;
2104 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2105 min_ts = av_rescale_rnd(min_ts, time_base.den,
2106 time_base.num * (int64_t)AV_TIME_BASE,
2107 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2108 max_ts = av_rescale_rnd(max_ts, time_base.den,
2109 time_base.num * (int64_t)AV_TIME_BASE,
2110 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2113 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2116 avformat_queue_attached_pictures(s);
2120 if(s->iformat->read_timestamp){
2121 //try to seek via read_timestamp()
2124 //Fallback to old API if new is not implemented but old is
2125 //Note the old has somewhat different semantics
2126 if (s->iformat->read_seek || 1) {
2127 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2128 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2129 if (ret<0 && ts != min_ts && max_ts != ts) {
2130 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2132 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2137 // try some generic seek like seek_frame_generic() but with new ts semantics
2138 return -1; //unreachable
2141 /*******************************************************/
2144 * Return TRUE if the stream has accurate duration in any stream.
2146 * @return TRUE if the stream has accurate duration for at least one component.
2148 static int has_duration(AVFormatContext *ic)
2153 for(i = 0;i < ic->nb_streams; i++) {
2154 st = ic->streams[i];
2155 if (st->duration != AV_NOPTS_VALUE)
2158 if (ic->duration != AV_NOPTS_VALUE)
2164 * Estimate the stream timings from the one of each components.
2166 * Also computes the global bitrate if possible.
2168 static void update_stream_timings(AVFormatContext *ic)
2170 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2171 int64_t duration, duration1, filesize;
2176 start_time = INT64_MAX;
2177 start_time_text = INT64_MAX;
2178 end_time = INT64_MIN;
2179 duration = INT64_MIN;
2180 for(i = 0;i < ic->nb_streams; i++) {
2181 st = ic->streams[i];
2182 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2183 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2184 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2185 if (start_time1 < start_time_text)
2186 start_time_text = start_time1;
2188 start_time = FFMIN(start_time, start_time1);
2189 end_time1 = AV_NOPTS_VALUE;
2190 if (st->duration != AV_NOPTS_VALUE) {
2191 end_time1 = start_time1
2192 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2193 end_time = FFMAX(end_time, end_time1);
2195 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2196 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2197 p->start_time = start_time1;
2198 if(p->end_time < end_time1)
2199 p->end_time = end_time1;
2202 if (st->duration != AV_NOPTS_VALUE) {
2203 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2204 duration = FFMAX(duration, duration1);
2207 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2208 start_time = start_time_text;
2209 else if(start_time > start_time_text)
2210 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2212 if (start_time != INT64_MAX) {
2213 ic->start_time = start_time;
2214 if (end_time != INT64_MIN) {
2215 if (ic->nb_programs) {
2216 for (i=0; i<ic->nb_programs; i++) {
2217 p = ic->programs[i];
2218 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2219 duration = FFMAX(duration, p->end_time - p->start_time);
2222 duration = FFMAX(duration, end_time - start_time);
2225 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2226 ic->duration = duration;
2228 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2229 /* compute the bitrate */
2230 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2231 (double)ic->duration;
2235 static void fill_all_stream_timings(AVFormatContext *ic)
2240 update_stream_timings(ic);
2241 for(i = 0;i < ic->nb_streams; i++) {
2242 st = ic->streams[i];
2243 if (st->start_time == AV_NOPTS_VALUE) {
2244 if(ic->start_time != AV_NOPTS_VALUE)
2245 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2246 if(ic->duration != AV_NOPTS_VALUE)
2247 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2252 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2254 int64_t filesize, duration;
2258 /* if bit_rate is already set, we believe it */
2259 if (ic->bit_rate <= 0) {
2261 for(i=0;i<ic->nb_streams;i++) {
2262 st = ic->streams[i];
2263 if (st->codec->bit_rate > 0)
2264 bit_rate += st->codec->bit_rate;
2266 ic->bit_rate = bit_rate;
2269 /* if duration is already set, we believe it */
2270 if (ic->duration == AV_NOPTS_VALUE &&
2271 ic->bit_rate != 0) {
2272 filesize = ic->pb ? avio_size(ic->pb) : 0;
2274 for(i = 0; i < ic->nb_streams; i++) {
2275 st = ic->streams[i];
2276 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2277 if (st->duration == AV_NOPTS_VALUE)
2278 st->duration = duration;
2284 #define DURATION_MAX_READ_SIZE 250000LL
2285 #define DURATION_MAX_RETRY 4
2287 /* only usable for MPEG-PS streams */
2288 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2290 AVPacket pkt1, *pkt = &pkt1;
2292 int read_size, i, ret;
2294 int64_t filesize, offset, duration;
2297 /* flush packet queue */
2298 flush_packet_queue(ic);
2300 for (i=0; i<ic->nb_streams; i++) {
2301 st = ic->streams[i];
2302 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2303 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2306 av_parser_close(st->parser);
2311 /* estimate the end time (duration) */
2312 /* XXX: may need to support wrapping */
2313 filesize = ic->pb ? avio_size(ic->pb) : 0;
2314 end_time = AV_NOPTS_VALUE;
2316 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2320 avio_seek(ic->pb, offset, SEEK_SET);
2323 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2327 ret = ff_read_packet(ic, pkt);
2328 } while(ret == AVERROR(EAGAIN));
2331 read_size += pkt->size;
2332 st = ic->streams[pkt->stream_index];
2333 if (pkt->pts != AV_NOPTS_VALUE &&
2334 (st->start_time != AV_NOPTS_VALUE ||
2335 st->first_dts != AV_NOPTS_VALUE)) {
2336 duration = end_time = pkt->pts;
2337 if (st->start_time != AV_NOPTS_VALUE)
2338 duration -= st->start_time;
2340 duration -= st->first_dts;
2342 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2343 st->duration = duration;
2346 av_free_packet(pkt);
2348 }while( end_time==AV_NOPTS_VALUE
2349 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2350 && ++retry <= DURATION_MAX_RETRY);
2352 fill_all_stream_timings(ic);
2354 avio_seek(ic->pb, old_offset, SEEK_SET);
2355 for (i=0; i<ic->nb_streams; i++) {
2357 st->cur_dts= st->first_dts;
2358 st->last_IP_pts = AV_NOPTS_VALUE;
2359 st->reference_dts = AV_NOPTS_VALUE;
2363 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2367 /* get the file size, if possible */
2368 if (ic->iformat->flags & AVFMT_NOFILE) {
2371 file_size = avio_size(ic->pb);
2372 file_size = FFMAX(0, file_size);
2375 if ((!strcmp(ic->iformat->name, "mpeg") ||
2376 !strcmp(ic->iformat->name, "mpegts")) &&
2377 file_size && ic->pb->seekable) {
2378 /* get accurate estimate from the PTSes */
2379 estimate_timings_from_pts(ic, old_offset);
2380 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2381 } else if (has_duration(ic)) {
2382 /* at least one component has timings - we use them for all
2384 fill_all_stream_timings(ic);
2385 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2387 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2388 /* less precise: use bitrate info */
2389 estimate_timings_from_bit_rate(ic);
2390 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2392 update_stream_timings(ic);
2396 AVStream av_unused *st;
2397 for(i = 0;i < ic->nb_streams; i++) {
2398 st = ic->streams[i];
2399 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2400 (double) st->start_time / AV_TIME_BASE,
2401 (double) st->duration / AV_TIME_BASE);
2403 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2404 (double) ic->start_time / AV_TIME_BASE,
2405 (double) ic->duration / AV_TIME_BASE,
2406 ic->bit_rate / 1000);
2410 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2412 AVCodecContext *avctx = st->codec;
2414 #define FAIL(errmsg) do { \
2416 *errmsg_ptr = errmsg; \
2420 switch (avctx->codec_type) {
2421 case AVMEDIA_TYPE_AUDIO:
2422 if (!avctx->frame_size && determinable_frame_size(avctx))
2423 FAIL("unspecified frame size");
2424 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2425 FAIL("unspecified sample format");
2426 if (!avctx->sample_rate)
2427 FAIL("unspecified sample rate");
2428 if (!avctx->channels)
2429 FAIL("unspecified number of channels");
2430 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2431 FAIL("no decodable DTS frames");
2433 case AVMEDIA_TYPE_VIDEO:
2435 FAIL("unspecified size");
2436 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2437 FAIL("unspecified pixel format");
2439 case AVMEDIA_TYPE_SUBTITLE:
2440 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2441 FAIL("unspecified size");
2443 case AVMEDIA_TYPE_DATA:
2444 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2447 if (avctx->codec_id == AV_CODEC_ID_NONE)
2448 FAIL("unknown codec");
2452 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2453 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2455 const AVCodec *codec;
2456 int got_picture = 1, ret = 0;
2457 AVFrame *frame = avcodec_alloc_frame();
2458 AVSubtitle subtitle;
2459 AVPacket pkt = *avpkt;
2462 return AVERROR(ENOMEM);
2464 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2465 AVDictionary *thread_opt = NULL;
2467 codec = st->codec->codec ? st->codec->codec :
2468 avcodec_find_decoder(st->codec->codec_id);
2471 st->info->found_decoder = -1;
2476 /* force thread count to 1 since the h264 decoder will not extract SPS
2477 * and PPS to extradata during multi-threaded decoding */
2478 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2479 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2481 av_dict_free(&thread_opt);
2483 st->info->found_decoder = -1;
2486 st->info->found_decoder = 1;
2487 } else if (!st->info->found_decoder)
2488 st->info->found_decoder = 1;
2490 if (st->info->found_decoder < 0) {
2495 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2497 (!has_codec_parameters(st, NULL) ||
2498 !has_decode_delay_been_guessed(st) ||
2499 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2501 avcodec_get_frame_defaults(frame);
2502 switch(st->codec->codec_type) {
2503 case AVMEDIA_TYPE_VIDEO:
2504 ret = avcodec_decode_video2(st->codec, frame,
2505 &got_picture, &pkt);
2507 case AVMEDIA_TYPE_AUDIO:
2508 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2510 case AVMEDIA_TYPE_SUBTITLE:
2511 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2512 &got_picture, &pkt);
2520 st->nb_decoded_frames++;
2527 if(!pkt.data && !got_picture)
2531 avcodec_free_frame(&frame);
2535 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2537 while (tags->id != AV_CODEC_ID_NONE) {
2545 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2548 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2549 if(tag == tags[i].tag)
2552 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2553 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2556 return AV_CODEC_ID_NONE;
2559 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2563 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2564 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2565 default: return AV_CODEC_ID_NONE;
2570 if (sflags & (1 << (bps - 1))) {
2572 case 1: return AV_CODEC_ID_PCM_S8;
2573 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2574 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2575 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2576 default: return AV_CODEC_ID_NONE;
2580 case 1: return AV_CODEC_ID_PCM_U8;
2581 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2582 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2583 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2584 default: return AV_CODEC_ID_NONE;
2590 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2593 if (!av_codec_get_tag2(tags, id, &tag))
2598 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2602 for(i=0; tags && tags[i]; i++){
2603 const AVCodecTag *codec_tags = tags[i];
2604 while (codec_tags->id != AV_CODEC_ID_NONE) {
2605 if (codec_tags->id == id) {
2606 *tag = codec_tags->tag;
2615 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2618 for(i=0; tags && tags[i]; i++){
2619 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2620 if(id!=AV_CODEC_ID_NONE) return id;
2622 return AV_CODEC_ID_NONE;
2625 static void compute_chapters_end(AVFormatContext *s)
2628 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2630 for (i = 0; i < s->nb_chapters; i++)
2631 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2632 AVChapter *ch = s->chapters[i];
2633 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2636 for (j = 0; j < s->nb_chapters; j++) {
2637 AVChapter *ch1 = s->chapters[j];
2638 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2639 if (j != i && next_start > ch->start && next_start < end)
2642 ch->end = (end == INT64_MAX) ? ch->start : end;
2646 static int get_std_framerate(int i){
2647 if(i<60*12) return (i+1)*1001;
2648 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2652 * Is the time base unreliable.
2653 * This is a heuristic to balance between quick acceptance of the values in
2654 * the headers vs. some extra checks.
2655 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2656 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2657 * And there are "variable" fps files this needs to detect as well.
2659 static int tb_unreliable(AVCodecContext *c){
2660 if( c->time_base.den >= 101L*c->time_base.num
2661 || c->time_base.den < 5L*c->time_base.num
2662 /* || c->codec_tag == AV_RL32("DIVX")
2663 || c->codec_tag == AV_RL32("XVID")*/
2664 || c->codec_tag == AV_RL32("mp4v")
2665 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2666 || c->codec_id == AV_CODEC_ID_H264
2672 #if FF_API_FORMAT_PARAMETERS
2673 int av_find_stream_info(AVFormatContext *ic)
2675 return avformat_find_stream_info(ic, NULL);
2679 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2681 int i, count, ret, read_size, j;
2683 AVPacket pkt1, *pkt;
2684 int64_t old_offset = avio_tell(ic->pb);
2685 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2686 int flush_codecs = ic->probesize > 0;
2689 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2691 for(i=0;i<ic->nb_streams;i++) {
2692 const AVCodec *codec;
2693 AVDictionary *thread_opt = NULL;
2694 st = ic->streams[i];
2696 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2697 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2698 /* if(!st->time_base.num)
2700 if(!st->codec->time_base.num)
2701 st->codec->time_base= st->time_base;
2703 //only for the split stuff
2704 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2705 st->parser = av_parser_init(st->codec->codec_id);
2707 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2708 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2709 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2710 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2712 } else if (st->need_parsing) {
2713 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2714 "%s, packets or times may be invalid.\n",
2715 avcodec_get_name(st->codec->codec_id));
2718 codec = st->codec->codec ? st->codec->codec :
2719 avcodec_find_decoder(st->codec->codec_id);
2721 /* force thread count to 1 since the h264 decoder will not extract SPS
2722 * and PPS to extradata during multi-threaded decoding */
2723 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2725 /* Ensure that subtitle_header is properly set. */
2726 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2727 && codec && !st->codec->codec)
2728 avcodec_open2(st->codec, codec, options ? &options[i]
2731 //try to just open decoders, in case this is enough to get parameters
2732 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2733 if (codec && !st->codec->codec)
2734 avcodec_open2(st->codec, codec, options ? &options[i]
2738 av_dict_free(&thread_opt);
2741 for (i=0; i<ic->nb_streams; i++) {
2742 #if FF_API_R_FRAME_RATE
2743 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2745 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2746 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2752 if (ff_check_interrupt(&ic->interrupt_callback)){
2754 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2758 /* check if one codec still needs to be handled */
2759 for(i=0;i<ic->nb_streams;i++) {
2760 int fps_analyze_framecount = 20;
2762 st = ic->streams[i];
2763 if (!has_codec_parameters(st, NULL))
2765 /* if the timebase is coarse (like the usual millisecond precision
2766 of mkv), we need to analyze more frames to reliably arrive at
2768 if (av_q2d(st->time_base) > 0.0005)
2769 fps_analyze_framecount *= 2;
2770 if (ic->fps_probe_size >= 0)
2771 fps_analyze_framecount = ic->fps_probe_size;
2772 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2773 fps_analyze_framecount = 0;
2774 /* variable fps and no guess at the real fps */
2775 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2776 && st->info->duration_count < fps_analyze_framecount
2777 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2779 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2781 if (st->first_dts == AV_NOPTS_VALUE &&
2782 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2783 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2786 if (i == ic->nb_streams) {
2787 /* NOTE: if the format has no header, then we need to read
2788 some packets to get most of the streams, so we cannot
2790 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2791 /* if we found the info for all the codecs, we can stop */
2793 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2798 /* we did not get all the codec info, but we read too much data */
2799 if (read_size >= ic->probesize) {
2801 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2802 for (i = 0; i < ic->nb_streams; i++)
2803 if (!ic->streams[i]->r_frame_rate.num &&
2804 ic->streams[i]->info->duration_count <= 1)
2805 av_log(ic, AV_LOG_WARNING,
2806 "Stream #%d: not enough frames to estimate rate; "
2807 "consider increasing probesize\n", i);
2811 /* NOTE: a new stream can be added there if no header in file
2812 (AVFMTCTX_NOHEADER) */
2813 ret = read_frame_internal(ic, &pkt1);
2814 if (ret == AVERROR(EAGAIN))
2822 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2825 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2826 &ic->packet_buffer_end);
2827 if ((ret = av_dup_packet(pkt)) < 0)
2828 goto find_stream_info_err;
2831 read_size += pkt->size;
2833 st = ic->streams[pkt->stream_index];
2834 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2835 /* check for non-increasing dts */
2836 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2837 st->info->fps_last_dts >= pkt->dts) {
2838 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2839 "packet %d with DTS %"PRId64", packet %d with DTS "
2840 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2841 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2842 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2844 /* check for a discontinuity in dts - if the difference in dts
2845 * is more than 1000 times the average packet duration in the sequence,
2846 * we treat it as a discontinuity */
2847 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2848 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2849 (pkt->dts - st->info->fps_last_dts) / 1000 >
2850 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2851 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2852 "packet %d with DTS %"PRId64", packet %d with DTS "
2853 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2854 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2855 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2858 /* update stored dts values */
2859 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2860 st->info->fps_first_dts = pkt->dts;
2861 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2863 st->info->fps_last_dts = pkt->dts;
2864 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2866 if (st->codec_info_nb_frames>1) {
2868 if (st->time_base.den > 0)
2869 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2870 if (st->avg_frame_rate.num > 0)
2871 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2873 if (t >= ic->max_analyze_duration) {
2874 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2877 if (pkt->duration) {
2878 st->info->codec_info_duration += pkt->duration;
2879 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2882 #if FF_API_R_FRAME_RATE
2884 int64_t last = st->info->last_dts;
2886 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2887 && pkt->dts - (uint64_t)last < INT64_MAX){
2888 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2889 int64_t duration= pkt->dts - last;
2891 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2892 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2893 for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2894 int framerate= get_std_framerate(i);
2895 double sdts= dts*framerate/(1001*12);
2897 int64_t ticks= llrint(sdts+j*0.5);
2898 double error= sdts - ticks + j*0.5;
2899 st->info->duration_error[j][0][i] += error;
2900 st->info->duration_error[j][1][i] += error*error;
2903 st->info->duration_count++;
2904 // ignore the first 4 values, they might have some random jitter
2905 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2906 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2908 if (pkt->dts != AV_NOPTS_VALUE)
2909 st->info->last_dts = pkt->dts;
2912 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2913 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2914 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2915 st->codec->extradata_size= i;
2916 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2917 if (!st->codec->extradata)
2918 return AVERROR(ENOMEM);
2919 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2920 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2924 /* if still no information, we try to open the codec and to
2925 decompress the frame. We try to avoid that in most cases as
2926 it takes longer and uses more memory. For MPEG-4, we need to
2927 decompress for QuickTime.
2929 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2930 least one frame of codec data, this makes sure the codec initializes
2931 the channel configuration and does not only trust the values from the container.
2933 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2935 st->codec_info_nb_frames++;
2940 AVPacket empty_pkt = { 0 };
2942 av_init_packet(&empty_pkt);
2944 ret = -1; /* we could not have all the codec parameters before EOF */
2945 for(i=0;i<ic->nb_streams;i++) {
2948 st = ic->streams[i];
2950 /* flush the decoders */
2951 if (st->info->found_decoder == 1) {
2953 err = try_decode_frame(st, &empty_pkt,
2954 (options && i < orig_nb_streams) ?
2955 &options[i] : NULL);
2956 } while (err > 0 && !has_codec_parameters(st, NULL));
2959 av_log(ic, AV_LOG_INFO,
2960 "decoding for stream %d failed\n", st->index);
2964 if (!has_codec_parameters(st, &errmsg)) {
2966 avcodec_string(buf, sizeof(buf), st->codec, 0);
2967 av_log(ic, AV_LOG_WARNING,
2968 "Could not find codec parameters for stream %d (%s): %s\n"
2969 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2977 // close codecs which were opened in try_decode_frame()
2978 for(i=0;i<ic->nb_streams;i++) {
2979 st = ic->streams[i];
2980 avcodec_close(st->codec);
2982 for(i=0;i<ic->nb_streams;i++) {
2983 st = ic->streams[i];
2984 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2985 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2986 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2987 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2988 st->codec->codec_tag= tag;
2991 /* estimate average framerate if not set by demuxer */
2992 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
2994 double best_error = 0.01;
2996 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2997 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
2998 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3000 /* round guessed framerate to a "standard" framerate if it's
3001 * within 1% of the original estimate*/
3002 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3003 AVRational std_fps = { get_std_framerate(j), 12*1001 };
3004 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3006 if (error < best_error) {
3008 best_fps = std_fps.num;
3012 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3013 best_fps, 12*1001, INT_MAX);
3016 // the check for tb_unreliable() is not completely correct, since this is not about handling
3017 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3018 // ipmovie.c produces.
3019 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)
3020 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);
3021 if (st->info->duration_count>1 && !st->r_frame_rate.num
3022 && tb_unreliable(st->codec)) {
3024 double best_error= 0.01;
3026 for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
3029 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3031 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3034 int n= st->info->duration_count;
3035 double a= st->info->duration_error[k][0][j] / n;
3036 double error= st->info->duration_error[k][1][j]/n - a*a;
3038 if(error < best_error && best_error> 0.000000001){
3040 num = get_std_framerate(j);
3043 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3046 // do not increase frame rate by more than 1 % in order to match a standard rate.
3047 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3048 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3051 if (!st->r_frame_rate.num){
3052 if( st->codec->time_base.den * (int64_t)st->time_base.num
3053 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3054 st->r_frame_rate.num = st->codec->time_base.den;
3055 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3057 st->r_frame_rate.num = st->time_base.den;
3058 st->r_frame_rate.den = st->time_base.num;
3061 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3062 if(!st->codec->bits_per_coded_sample)
3063 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3064 // set stream disposition based on audio service type
3065 switch (st->codec->audio_service_type) {
3066 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3067 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3068 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3069 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3070 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3071 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3072 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3073 st->disposition = AV_DISPOSITION_COMMENT; break;
3074 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3075 st->disposition = AV_DISPOSITION_KARAOKE; break;
3081 estimate_timings(ic, old_offset);
3083 compute_chapters_end(ic);
3085 find_stream_info_err:
3086 for (i=0; i < ic->nb_streams; i++) {
3087 if (ic->streams[i]->codec)
3088 ic->streams[i]->codec->thread_count = 0;
3089 av_freep(&ic->streams[i]->info);
3092 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3096 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3100 for (i = 0; i < ic->nb_programs; i++) {
3101 if (ic->programs[i] == last) {
3105 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3106 if (ic->programs[i]->stream_index[j] == s)
3107 return ic->programs[i];
3113 int av_find_best_stream(AVFormatContext *ic,
3114 enum AVMediaType type,
3115 int wanted_stream_nb,
3117 AVCodec **decoder_ret,
3120 int i, nb_streams = ic->nb_streams;
3121 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3122 unsigned *program = NULL;
3123 AVCodec *decoder = NULL, *best_decoder = NULL;
3125 if (related_stream >= 0 && wanted_stream_nb < 0) {
3126 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3128 program = p->stream_index;
3129 nb_streams = p->nb_stream_indexes;
3132 for (i = 0; i < nb_streams; i++) {
3133 int real_stream_index = program ? program[i] : i;
3134 AVStream *st = ic->streams[real_stream_index];
3135 AVCodecContext *avctx = st->codec;
3136 if (avctx->codec_type != type)
3138 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3140 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3143 decoder = avcodec_find_decoder(st->codec->codec_id);
3146 ret = AVERROR_DECODER_NOT_FOUND;
3150 count = st->codec_info_nb_frames;
3151 bitrate = avctx->bit_rate;
3152 multiframe = FFMIN(5, count);
3153 if ((best_multiframe > multiframe) ||
3154 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3155 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3158 best_bitrate = bitrate;
3159 best_multiframe = multiframe;
3160 ret = real_stream_index;
3161 best_decoder = decoder;
3162 if (program && i == nb_streams - 1 && ret < 0) {
3164 nb_streams = ic->nb_streams;
3165 i = 0; /* no related stream found, try again with everything */
3169 *decoder_ret = best_decoder;
3173 /*******************************************************/
3175 int av_read_play(AVFormatContext *s)
3177 if (s->iformat->read_play)
3178 return s->iformat->read_play(s);
3180 return avio_pause(s->pb, 0);
3181 return AVERROR(ENOSYS);
3184 int av_read_pause(AVFormatContext *s)
3186 if (s->iformat->read_pause)
3187 return s->iformat->read_pause(s);
3189 return avio_pause(s->pb, 1);
3190 return AVERROR(ENOSYS);
3193 void ff_free_stream(AVFormatContext *s, AVStream *st){
3194 av_assert0(s->nb_streams>0);
3195 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3198 av_parser_close(st->parser);
3200 if (st->attached_pic.data)
3201 av_free_packet(&st->attached_pic);
3202 av_dict_free(&st->metadata);
3203 av_freep(&st->index_entries);
3204 av_freep(&st->codec->extradata);
3205 av_freep(&st->codec->subtitle_header);
3206 av_freep(&st->codec);
3207 av_freep(&st->priv_data);
3208 av_freep(&st->info);
3209 av_freep(&st->probe_data.buf);
3210 av_freep(&s->streams[ --s->nb_streams ]);
3213 void avformat_free_context(AVFormatContext *s)
3221 if (s->iformat && s->iformat->priv_class && s->priv_data)
3222 av_opt_free(s->priv_data);
3224 for(i=s->nb_streams-1; i>=0; i--) {
3225 ff_free_stream(s, s->streams[i]);
3227 for(i=s->nb_programs-1; i>=0; i--) {
3228 av_dict_free(&s->programs[i]->metadata);
3229 av_freep(&s->programs[i]->stream_index);
3230 av_freep(&s->programs[i]);
3232 av_freep(&s->programs);
3233 av_freep(&s->priv_data);
3234 while(s->nb_chapters--) {
3235 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3236 av_freep(&s->chapters[s->nb_chapters]);
3238 av_freep(&s->chapters);
3239 av_dict_free(&s->metadata);
3240 av_freep(&s->streams);
3244 #if FF_API_CLOSE_INPUT_FILE
3245 void av_close_input_file(AVFormatContext *s)
3247 avformat_close_input(&s);
3251 void avformat_close_input(AVFormatContext **ps)
3253 AVFormatContext *s = *ps;
3254 AVIOContext *pb = s->pb;
3256 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3257 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3260 flush_packet_queue(s);
3263 if (s->iformat->read_close)
3264 s->iformat->read_close(s);
3267 avformat_free_context(s);
3274 #if FF_API_NEW_STREAM
3275 AVStream *av_new_stream(AVFormatContext *s, int id)
3277 AVStream *st = avformat_new_stream(s, NULL);
3284 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3290 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3292 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3295 s->streams = streams;
3297 st = av_mallocz(sizeof(AVStream));
3300 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3304 st->info->last_dts = AV_NOPTS_VALUE;
3306 st->codec = avcodec_alloc_context3(c);
3308 /* no default bitrate if decoding */
3309 st->codec->bit_rate = 0;
3311 st->index = s->nb_streams;
3312 st->start_time = AV_NOPTS_VALUE;
3313 st->duration = AV_NOPTS_VALUE;
3314 /* we set the current DTS to 0 so that formats without any timestamps
3315 but durations get some timestamps, formats with some unknown
3316 timestamps have their first few packets buffered and the
3317 timestamps corrected before they are returned to the user */
3318 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3319 st->first_dts = AV_NOPTS_VALUE;
3320 st->probe_packets = MAX_PROBE_PACKETS;
3321 st->pts_wrap_reference = AV_NOPTS_VALUE;
3322 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3324 /* default pts setting is MPEG-like */
3325 avpriv_set_pts_info(st, 33, 1, 90000);
3326 st->last_IP_pts = AV_NOPTS_VALUE;
3327 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3328 st->pts_buffer[i]= AV_NOPTS_VALUE;
3329 st->reference_dts = AV_NOPTS_VALUE;
3331 st->sample_aspect_ratio = (AVRational){0,1};
3333 #if FF_API_R_FRAME_RATE
3334 st->info->last_dts = AV_NOPTS_VALUE;
3336 st->info->fps_first_dts = AV_NOPTS_VALUE;
3337 st->info->fps_last_dts = AV_NOPTS_VALUE;
3339 s->streams[s->nb_streams++] = st;
3343 AVProgram *av_new_program(AVFormatContext *ac, int id)
3345 AVProgram *program=NULL;
3348 av_dlog(ac, "new_program: id=0x%04x\n", id);
3350 for(i=0; i<ac->nb_programs; i++)
3351 if(ac->programs[i]->id == id)
3352 program = ac->programs[i];
3355 program = av_mallocz(sizeof(AVProgram));
3358 dynarray_add(&ac->programs, &ac->nb_programs, program);
3359 program->discard = AVDISCARD_NONE;
3362 program->pts_wrap_reference = AV_NOPTS_VALUE;
3363 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3365 program->start_time =
3366 program->end_time = AV_NOPTS_VALUE;
3371 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3373 AVChapter *chapter = NULL;
3376 for(i=0; i<s->nb_chapters; i++)
3377 if(s->chapters[i]->id == id)
3378 chapter = s->chapters[i];
3381 chapter= av_mallocz(sizeof(AVChapter));
3384 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3386 av_dict_set(&chapter->metadata, "title", title, 0);
3388 chapter->time_base= time_base;
3389 chapter->start = start;
3395 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3398 AVProgram *program=NULL;
3401 if (idx >= ac->nb_streams) {
3402 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3406 for(i=0; i<ac->nb_programs; i++){
3407 if(ac->programs[i]->id != progid)
3409 program = ac->programs[i];
3410 for(j=0; j<program->nb_stream_indexes; j++)
3411 if(program->stream_index[j] == idx)
3414 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3417 program->stream_index = tmp;
3418 program->stream_index[program->nb_stream_indexes++] = idx;
3423 static void print_fps(double d, const char *postfix){
3424 uint64_t v= lrintf(d*100);
3425 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3426 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3427 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3430 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3432 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3433 AVDictionaryEntry *tag=NULL;
3435 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3436 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3437 if(strcmp("language", tag->key)){
3438 const char *p = tag->value;
3439 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3442 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3443 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3444 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3446 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3447 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3450 av_log(ctx, AV_LOG_INFO, "\n");
3456 /* "user interface" functions */
3457 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3460 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3461 AVStream *st = ic->streams[i];
3462 int g = av_gcd(st->time_base.num, st->time_base.den);
3463 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3464 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3465 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3466 /* the pid is an important information, so we display it */
3467 /* XXX: add a generic system */
3468 if (flags & AVFMT_SHOW_IDS)
3469 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3471 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3472 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3473 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3474 if (st->sample_aspect_ratio.num && // default
3475 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3476 AVRational display_aspect_ratio;
3477 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3478 st->codec->width*st->sample_aspect_ratio.num,
3479 st->codec->height*st->sample_aspect_ratio.den,
3481 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3482 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3483 display_aspect_ratio.num, display_aspect_ratio.den);
3485 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3486 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3487 print_fps(av_q2d(st->avg_frame_rate), "fps");
3488 #if FF_API_R_FRAME_RATE
3489 if(st->r_frame_rate.den && st->r_frame_rate.num)
3490 print_fps(av_q2d(st->r_frame_rate), "tbr");
3492 if(st->time_base.den && st->time_base.num)
3493 print_fps(1/av_q2d(st->time_base), "tbn");
3494 if(st->codec->time_base.den && st->codec->time_base.num)
3495 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3497 if (st->disposition & AV_DISPOSITION_DEFAULT)
3498 av_log(NULL, AV_LOG_INFO, " (default)");
3499 if (st->disposition & AV_DISPOSITION_DUB)
3500 av_log(NULL, AV_LOG_INFO, " (dub)");
3501 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3502 av_log(NULL, AV_LOG_INFO, " (original)");
3503 if (st->disposition & AV_DISPOSITION_COMMENT)
3504 av_log(NULL, AV_LOG_INFO, " (comment)");
3505 if (st->disposition & AV_DISPOSITION_LYRICS)
3506 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3507 if (st->disposition & AV_DISPOSITION_KARAOKE)
3508 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3509 if (st->disposition & AV_DISPOSITION_FORCED)
3510 av_log(NULL, AV_LOG_INFO, " (forced)");
3511 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3512 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3513 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3514 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3515 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3516 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3517 av_log(NULL, AV_LOG_INFO, "\n");
3518 dump_metadata(NULL, st->metadata, " ");
3521 void av_dump_format(AVFormatContext *ic,
3527 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3528 if (ic->nb_streams && !printed)
3531 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3532 is_output ? "Output" : "Input",
3534 is_output ? ic->oformat->name : ic->iformat->name,
3535 is_output ? "to" : "from", url);
3536 dump_metadata(NULL, ic->metadata, " ");
3538 av_log(NULL, AV_LOG_INFO, " Duration: ");
3539 if (ic->duration != AV_NOPTS_VALUE) {
3540 int hours, mins, secs, us;
3541 int64_t duration = ic->duration + 5000;
3542 secs = duration / AV_TIME_BASE;
3543 us = duration % AV_TIME_BASE;
3548 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3549 (100 * us) / AV_TIME_BASE);
3551 av_log(NULL, AV_LOG_INFO, "N/A");
3553 if (ic->start_time != AV_NOPTS_VALUE) {
3555 av_log(NULL, AV_LOG_INFO, ", start: ");
3556 secs = ic->start_time / AV_TIME_BASE;
3557 us = abs(ic->start_time % AV_TIME_BASE);
3558 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3559 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3561 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3563 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3565 av_log(NULL, AV_LOG_INFO, "N/A");
3567 av_log(NULL, AV_LOG_INFO, "\n");
3569 for (i = 0; i < ic->nb_chapters; i++) {
3570 AVChapter *ch = ic->chapters[i];
3571 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3572 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3573 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3575 dump_metadata(NULL, ch->metadata, " ");
3577 if(ic->nb_programs) {
3578 int j, k, total = 0;
3579 for(j=0; j<ic->nb_programs; j++) {
3580 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3582 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3583 name ? name->value : "");
3584 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3585 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3586 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3587 printed[ic->programs[j]->stream_index[k]] = 1;
3589 total += ic->programs[j]->nb_stream_indexes;
3591 if (total < ic->nb_streams)
3592 av_log(NULL, AV_LOG_INFO, " No Program\n");
3594 for(i=0;i<ic->nb_streams;i++)
3596 dump_stream_format(ic, i, index, is_output);
3601 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3602 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3604 return av_gettime();
3608 uint64_t ff_ntp_time(void)
3610 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3613 int av_get_frame_filename(char *buf, int buf_size,
3614 const char *path, int number)
3617 char *q, buf1[20], c;
3618 int nd, len, percentd_found;
3630 while (isdigit(*p)) {
3631 nd = nd * 10 + *p++ - '0';
3634 } while (isdigit(c));
3643 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3645 if ((q - buf + len) > buf_size - 1)
3647 memcpy(q, buf1, len);
3655 if ((q - buf) < buf_size - 1)
3659 if (!percentd_found)
3668 static void hex_dump_internal(void *avcl, FILE *f, int level,
3669 const uint8_t *buf, int size)
3672 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3674 for(i=0;i<size;i+=16) {
3681 PRINT(" %02x", buf[i+j]);
3686 for(j=0;j<len;j++) {
3688 if (c < ' ' || c > '~')
3697 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3699 hex_dump_internal(NULL, f, 0, buf, size);
3702 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3704 hex_dump_internal(avcl, NULL, level, buf, size);
3707 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3709 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3710 PRINT("stream #%d:\n", pkt->stream_index);
3711 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3712 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3713 /* DTS is _always_ valid after av_read_frame() */
3715 if (pkt->dts == AV_NOPTS_VALUE)
3718 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3719 /* PTS may not be known if B-frames are present. */
3721 if (pkt->pts == AV_NOPTS_VALUE)
3724 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3726 PRINT(" size=%d\n", pkt->size);
3729 av_hex_dump(f, pkt->data, pkt->size);
3733 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3735 AVRational tb = { 1, AV_TIME_BASE };
3736 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3740 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3742 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3746 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3748 AVRational tb = { 1, AV_TIME_BASE };
3749 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3753 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3756 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3759 void av_url_split(char *proto, int proto_size,
3760 char *authorization, int authorization_size,
3761 char *hostname, int hostname_size,
3763 char *path, int path_size,
3766 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3768 if (port_ptr) *port_ptr = -1;
3769 if (proto_size > 0) proto[0] = 0;
3770 if (authorization_size > 0) authorization[0] = 0;
3771 if (hostname_size > 0) hostname[0] = 0;
3772 if (path_size > 0) path[0] = 0;
3774 /* parse protocol */
3775 if ((p = strchr(url, ':'))) {
3776 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3781 /* no protocol means plain filename */
3782 av_strlcpy(path, url, path_size);
3786 /* separate path from hostname */
3787 ls = strchr(p, '/');
3788 ls2 = strchr(p, '?');
3792 ls = FFMIN(ls, ls2);
3794 av_strlcpy(path, ls, path_size);
3796 ls = &p[strlen(p)]; // XXX
3798 /* the rest is hostname, use that to parse auth/port */
3800 /* authorization (user[:pass]@hostname) */
3802 while ((at = strchr(p, '@')) && at < ls) {
3803 av_strlcpy(authorization, at2,
3804 FFMIN(authorization_size, at + 1 - at2));
3805 p = at + 1; /* skip '@' */
3808 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3810 av_strlcpy(hostname, p + 1,
3811 FFMIN(hostname_size, brk - p));
3812 if (brk[1] == ':' && port_ptr)
3813 *port_ptr = atoi(brk + 2);
3814 } else if ((col = strchr(p, ':')) && col < ls) {
3815 av_strlcpy(hostname, p,
3816 FFMIN(col + 1 - p, hostname_size));
3817 if (port_ptr) *port_ptr = atoi(col + 1);
3819 av_strlcpy(hostname, p,
3820 FFMIN(ls + 1 - p, hostname_size));
3824 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3827 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3830 'C', 'D', 'E', 'F' };
3831 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3834 'c', 'd', 'e', 'f' };
3835 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3837 for(i = 0; i < s; i++) {
3838 buff[i * 2] = hex_table[src[i] >> 4];
3839 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3845 int ff_hex_to_data(uint8_t *data, const char *p)
3852 p += strspn(p, SPACE_CHARS);
3855 c = toupper((unsigned char) *p++);
3856 if (c >= '0' && c <= '9')
3858 else if (c >= 'A' && c <= 'F')
3873 #if FF_API_SET_PTS_INFO
3874 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3875 unsigned int pts_num, unsigned int pts_den)
3877 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3881 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3882 unsigned int pts_num, unsigned int pts_den)
3885 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3886 if(new_tb.num != pts_num)
3887 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3889 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3891 if(new_tb.num <= 0 || new_tb.den <= 0) {
3892 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);
3895 s->time_base = new_tb;
3896 av_codec_set_pkt_timebase(s->codec, new_tb);
3897 s->pts_wrap_bits = pts_wrap_bits;
3900 int ff_url_join(char *str, int size, const char *proto,
3901 const char *authorization, const char *hostname,
3902 int port, const char *fmt, ...)
3905 struct addrinfo hints = { 0 }, *ai;
3910 av_strlcatf(str, size, "%s://", proto);
3911 if (authorization && authorization[0])
3912 av_strlcatf(str, size, "%s@", authorization);
3913 #if CONFIG_NETWORK && defined(AF_INET6)
3914 /* Determine if hostname is a numerical IPv6 address,
3915 * properly escape it within [] in that case. */
3916 hints.ai_flags = AI_NUMERICHOST;
3917 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3918 if (ai->ai_family == AF_INET6) {
3919 av_strlcat(str, "[", size);
3920 av_strlcat(str, hostname, size);
3921 av_strlcat(str, "]", size);
3923 av_strlcat(str, hostname, size);
3928 /* Not an IPv6 address, just output the plain string. */
3929 av_strlcat(str, hostname, size);
3932 av_strlcatf(str, size, ":%d", port);
3935 int len = strlen(str);
3938 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3944 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3945 AVFormatContext *src)
3950 local_pkt.stream_index = dst_stream;
3951 if (pkt->pts != AV_NOPTS_VALUE)
3952 local_pkt.pts = av_rescale_q(pkt->pts,
3953 src->streams[pkt->stream_index]->time_base,
3954 dst->streams[dst_stream]->time_base);
3955 if (pkt->dts != AV_NOPTS_VALUE)
3956 local_pkt.dts = av_rescale_q(pkt->dts,
3957 src->streams[pkt->stream_index]->time_base,
3958 dst->streams[dst_stream]->time_base);
3959 return av_write_frame(dst, &local_pkt);
3962 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3965 const char *ptr = str;
3967 /* Parse key=value pairs. */
3970 char *dest = NULL, *dest_end;
3971 int key_len, dest_len = 0;
3973 /* Skip whitespace and potential commas. */
3974 while (*ptr && (isspace(*ptr) || *ptr == ','))
3981 if (!(ptr = strchr(key, '=')))
3984 key_len = ptr - key;
3986 callback_get_buf(context, key, key_len, &dest, &dest_len);
3987 dest_end = dest + dest_len - 1;
3991 while (*ptr && *ptr != '\"') {
3995 if (dest && dest < dest_end)
3999 if (dest && dest < dest_end)
4007 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4008 if (dest && dest < dest_end)
4016 int ff_find_stream_index(AVFormatContext *s, int id)
4019 for (i = 0; i < s->nb_streams; i++) {
4020 if (s->streams[i]->id == id)
4026 void ff_make_absolute_url(char *buf, int size, const char *base,
4029 char *sep, *path_query;
4030 /* Absolute path, relative to the current server */
4031 if (base && strstr(base, "://") && rel[0] == '/') {
4033 av_strlcpy(buf, base, size);
4034 sep = strstr(buf, "://");
4036 /* Take scheme from base url */
4037 if (rel[1] == '/') {
4040 /* Take scheme and host from base url */
4042 sep = strchr(sep, '/');
4047 av_strlcat(buf, rel, size);
4050 /* If rel actually is an absolute url, just copy it */
4051 if (!base || strstr(rel, "://") || rel[0] == '/') {
4052 av_strlcpy(buf, rel, size);
4056 av_strlcpy(buf, base, size);
4058 /* Strip off any query string from base */
4059 path_query = strchr(buf, '?');
4060 if (path_query != NULL)
4063 /* Is relative path just a new query part? */
4064 if (rel[0] == '?') {
4065 av_strlcat(buf, rel, size);
4069 /* Remove the file name from the base url */
4070 sep = strrchr(buf, '/');
4075 while (av_strstart(rel, "../", NULL) && sep) {
4076 /* Remove the path delimiter at the end */
4078 sep = strrchr(buf, '/');
4079 /* If the next directory name to pop off is "..", break here */
4080 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4081 /* Readd the slash we just removed */
4082 av_strlcat(buf, "/", size);
4085 /* Cut off the directory name */
4092 av_strlcat(buf, rel, size);
4095 int64_t ff_iso8601_to_unix_time(const char *datestr)
4097 struct tm time1 = {0}, time2 = {0};
4099 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4100 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4102 return av_timegm(&time2);
4104 return av_timegm(&time1);
4107 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4110 if (ofmt->query_codec)
4111 return ofmt->query_codec(codec_id, std_compliance);
4112 else if (ofmt->codec_tag)
4113 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4114 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4115 codec_id == ofmt->subtitle_codec)
4118 return AVERROR_PATCHWELCOME;
4121 int avformat_network_init(void)
4125 ff_network_inited_globally = 1;
4126 if ((ret = ff_network_init()) < 0)
4133 int avformat_network_deinit(void)
4142 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4143 uint64_t channel_layout, int32_t sample_rate,
4144 int32_t width, int32_t height)
4150 return AVERROR(EINVAL);
4153 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4155 if (channel_layout) {
4157 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4161 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4163 if (width || height) {
4165 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4167 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4169 return AVERROR(ENOMEM);
4170 bytestream_put_le32(&data, flags);
4172 bytestream_put_le32(&data, channels);
4174 bytestream_put_le64(&data, channel_layout);
4176 bytestream_put_le32(&data, sample_rate);
4177 if (width || height) {
4178 bytestream_put_le32(&data, width);
4179 bytestream_put_le32(&data, height);
4184 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4186 return ff_codec_bmp_tags;
4188 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4190 return ff_codec_wav_tags;
4193 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4195 AVRational undef = {0, 1};
4196 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4197 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4198 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4200 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4201 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4202 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4203 stream_sample_aspect_ratio = undef;
4205 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4206 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4207 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4208 frame_sample_aspect_ratio = undef;
4210 if (stream_sample_aspect_ratio.num)
4211 return stream_sample_aspect_ratio;
4213 return frame_sample_aspect_ratio;
4216 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4219 if (*spec <= '9' && *spec >= '0') /* opt:index */
4220 return strtol(spec, NULL, 0) == st->index;
4221 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4222 *spec == 't') { /* opt:[vasdt] */
4223 enum AVMediaType type;
4226 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4227 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4228 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4229 case 'd': type = AVMEDIA_TYPE_DATA; break;
4230 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4231 default: av_assert0(0);
4233 if (type != st->codec->codec_type)
4235 if (*spec++ == ':') { /* possibly followed by :index */
4236 int i, index = strtol(spec, NULL, 0);
4237 for (i = 0; i < s->nb_streams; i++)
4238 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4239 return i == st->index;
4243 } else if (*spec == 'p' && *(spec + 1) == ':') {
4247 prog_id = strtol(spec, &endptr, 0);
4248 for (i = 0; i < s->nb_programs; i++) {
4249 if (s->programs[i]->id != prog_id)
4252 if (*endptr++ == ':') {
4253 int stream_idx = strtol(endptr, NULL, 0);
4254 return stream_idx >= 0 &&
4255 stream_idx < s->programs[i]->nb_stream_indexes &&
4256 st->index == s->programs[i]->stream_index[stream_idx];
4259 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4260 if (st->index == s->programs[i]->stream_index[j])
4264 } else if (*spec == '#') {
4267 sid = strtol(spec + 1, &endptr, 0);
4269 return st->id == sid;
4270 } else if (!*spec) /* empty specifier, matches everything */
4273 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4274 return AVERROR(EINVAL);
4277 void ff_generate_avci_extradata(AVStream *st)
4279 static const uint8_t avci100_1080p_extradata[] = {
4281 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4282 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4283 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4284 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4285 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4286 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4287 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4288 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4289 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4291 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4294 static const uint8_t avci100_1080i_extradata[] = {
4296 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4297 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4298 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4299 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4300 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4301 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4302 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4303 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4304 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4305 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4306 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4308 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4311 static const uint8_t avci50_1080i_extradata[] = {
4313 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4314 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4315 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4316 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4317 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4318 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4319 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4320 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4321 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4322 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4323 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4325 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4328 static const uint8_t avci100_720p_extradata[] = {
4330 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4331 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4332 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4333 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4334 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4335 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4336 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4337 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4338 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4339 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4341 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4345 const uint8_t *data = 0;
4346 if (st->codec->width == 1920) {
4347 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4348 data = avci100_1080p_extradata;
4349 size = sizeof(avci100_1080p_extradata);
4351 data = avci100_1080i_extradata;
4352 size = sizeof(avci100_1080i_extradata);
4354 } else if (st->codec->width == 1440) {
4355 data = avci50_1080i_extradata;
4356 size = sizeof(avci50_1080i_extradata);
4357 } else if (st->codec->width == 1280) {
4358 data = avci100_720p_extradata;
4359 size = sizeof(avci100_720p_extradata);
4363 av_freep(&st->codec->extradata);
4364 st->codec->extradata_size = 0;
4365 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4366 if (!st->codec->extradata)
4368 memcpy(st->codec->extradata, data, size);
4369 st->codec->extradata_size = size;