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)
2095 if (s->iformat->read_seek2) {
2097 ff_read_frame_flush(s);
2099 if (stream_index == -1 && s->nb_streams == 1) {
2100 AVRational time_base = s->streams[0]->time_base;
2101 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2102 min_ts = av_rescale_rnd(min_ts, time_base.den,
2103 time_base.num * (int64_t)AV_TIME_BASE,
2104 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2105 max_ts = av_rescale_rnd(max_ts, time_base.den,
2106 time_base.num * (int64_t)AV_TIME_BASE,
2107 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2110 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2113 avformat_queue_attached_pictures(s);
2117 if(s->iformat->read_timestamp){
2118 //try to seek via read_timestamp()
2121 //Fallback to old API if new is not implemented but old is
2122 //Note the old has somewhat different semantics
2123 if (s->iformat->read_seek || 1) {
2124 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2125 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2126 if (ret<0 && ts != min_ts && max_ts != ts) {
2127 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2129 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2134 // try some generic seek like seek_frame_generic() but with new ts semantics
2135 return -1; //unreachable
2138 /*******************************************************/
2141 * Return TRUE if the stream has accurate duration in any stream.
2143 * @return TRUE if the stream has accurate duration for at least one component.
2145 static int has_duration(AVFormatContext *ic)
2150 for(i = 0;i < ic->nb_streams; i++) {
2151 st = ic->streams[i];
2152 if (st->duration != AV_NOPTS_VALUE)
2155 if (ic->duration != AV_NOPTS_VALUE)
2161 * Estimate the stream timings from the one of each components.
2163 * Also computes the global bitrate if possible.
2165 static void update_stream_timings(AVFormatContext *ic)
2167 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2168 int64_t duration, duration1, filesize;
2173 start_time = INT64_MAX;
2174 start_time_text = INT64_MAX;
2175 end_time = INT64_MIN;
2176 duration = INT64_MIN;
2177 for(i = 0;i < ic->nb_streams; i++) {
2178 st = ic->streams[i];
2179 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2180 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2181 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2182 if (start_time1 < start_time_text)
2183 start_time_text = start_time1;
2185 start_time = FFMIN(start_time, start_time1);
2186 end_time1 = AV_NOPTS_VALUE;
2187 if (st->duration != AV_NOPTS_VALUE) {
2188 end_time1 = start_time1
2189 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2190 end_time = FFMAX(end_time, end_time1);
2192 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2193 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2194 p->start_time = start_time1;
2195 if(p->end_time < end_time1)
2196 p->end_time = end_time1;
2199 if (st->duration != AV_NOPTS_VALUE) {
2200 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2201 duration = FFMAX(duration, duration1);
2204 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2205 start_time = start_time_text;
2206 else if(start_time > start_time_text)
2207 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2209 if (start_time != INT64_MAX) {
2210 ic->start_time = start_time;
2211 if (end_time != INT64_MIN) {
2212 if (ic->nb_programs) {
2213 for (i=0; i<ic->nb_programs; i++) {
2214 p = ic->programs[i];
2215 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2216 duration = FFMAX(duration, p->end_time - p->start_time);
2219 duration = FFMAX(duration, end_time - start_time);
2222 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2223 ic->duration = duration;
2225 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2226 /* compute the bitrate */
2227 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2228 (double)ic->duration;
2232 static void fill_all_stream_timings(AVFormatContext *ic)
2237 update_stream_timings(ic);
2238 for(i = 0;i < ic->nb_streams; i++) {
2239 st = ic->streams[i];
2240 if (st->start_time == AV_NOPTS_VALUE) {
2241 if(ic->start_time != AV_NOPTS_VALUE)
2242 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2243 if(ic->duration != AV_NOPTS_VALUE)
2244 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2249 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2251 int64_t filesize, duration;
2255 /* if bit_rate is already set, we believe it */
2256 if (ic->bit_rate <= 0) {
2258 for(i=0;i<ic->nb_streams;i++) {
2259 st = ic->streams[i];
2260 if (st->codec->bit_rate > 0)
2261 bit_rate += st->codec->bit_rate;
2263 ic->bit_rate = bit_rate;
2266 /* if duration is already set, we believe it */
2267 if (ic->duration == AV_NOPTS_VALUE &&
2268 ic->bit_rate != 0) {
2269 filesize = ic->pb ? avio_size(ic->pb) : 0;
2271 for(i = 0; i < ic->nb_streams; i++) {
2272 st = ic->streams[i];
2273 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2274 if (st->duration == AV_NOPTS_VALUE)
2275 st->duration = duration;
2281 #define DURATION_MAX_READ_SIZE 250000LL
2282 #define DURATION_MAX_RETRY 4
2284 /* only usable for MPEG-PS streams */
2285 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2287 AVPacket pkt1, *pkt = &pkt1;
2289 int read_size, i, ret;
2291 int64_t filesize, offset, duration;
2294 /* flush packet queue */
2295 flush_packet_queue(ic);
2297 for (i=0; i<ic->nb_streams; i++) {
2298 st = ic->streams[i];
2299 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2300 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2303 av_parser_close(st->parser);
2308 /* estimate the end time (duration) */
2309 /* XXX: may need to support wrapping */
2310 filesize = ic->pb ? avio_size(ic->pb) : 0;
2311 end_time = AV_NOPTS_VALUE;
2313 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2317 avio_seek(ic->pb, offset, SEEK_SET);
2320 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2324 ret = ff_read_packet(ic, pkt);
2325 } while(ret == AVERROR(EAGAIN));
2328 read_size += pkt->size;
2329 st = ic->streams[pkt->stream_index];
2330 if (pkt->pts != AV_NOPTS_VALUE &&
2331 (st->start_time != AV_NOPTS_VALUE ||
2332 st->first_dts != AV_NOPTS_VALUE)) {
2333 duration = end_time = pkt->pts;
2334 if (st->start_time != AV_NOPTS_VALUE)
2335 duration -= st->start_time;
2337 duration -= st->first_dts;
2339 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2340 st->duration = duration;
2343 av_free_packet(pkt);
2345 }while( end_time==AV_NOPTS_VALUE
2346 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2347 && ++retry <= DURATION_MAX_RETRY);
2349 fill_all_stream_timings(ic);
2351 avio_seek(ic->pb, old_offset, SEEK_SET);
2352 for (i=0; i<ic->nb_streams; i++) {
2354 st->cur_dts= st->first_dts;
2355 st->last_IP_pts = AV_NOPTS_VALUE;
2356 st->reference_dts = AV_NOPTS_VALUE;
2360 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2364 /* get the file size, if possible */
2365 if (ic->iformat->flags & AVFMT_NOFILE) {
2368 file_size = avio_size(ic->pb);
2369 file_size = FFMAX(0, file_size);
2372 if ((!strcmp(ic->iformat->name, "mpeg") ||
2373 !strcmp(ic->iformat->name, "mpegts")) &&
2374 file_size && ic->pb->seekable) {
2375 /* get accurate estimate from the PTSes */
2376 estimate_timings_from_pts(ic, old_offset);
2377 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2378 } else if (has_duration(ic)) {
2379 /* at least one component has timings - we use them for all
2381 fill_all_stream_timings(ic);
2382 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2384 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2385 /* less precise: use bitrate info */
2386 estimate_timings_from_bit_rate(ic);
2387 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2389 update_stream_timings(ic);
2393 AVStream av_unused *st;
2394 for(i = 0;i < ic->nb_streams; i++) {
2395 st = ic->streams[i];
2396 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2397 (double) st->start_time / AV_TIME_BASE,
2398 (double) st->duration / AV_TIME_BASE);
2400 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2401 (double) ic->start_time / AV_TIME_BASE,
2402 (double) ic->duration / AV_TIME_BASE,
2403 ic->bit_rate / 1000);
2407 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2409 AVCodecContext *avctx = st->codec;
2411 #define FAIL(errmsg) do { \
2413 *errmsg_ptr = errmsg; \
2417 switch (avctx->codec_type) {
2418 case AVMEDIA_TYPE_AUDIO:
2419 if (!avctx->frame_size && determinable_frame_size(avctx))
2420 FAIL("unspecified frame size");
2421 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2422 FAIL("unspecified sample format");
2423 if (!avctx->sample_rate)
2424 FAIL("unspecified sample rate");
2425 if (!avctx->channels)
2426 FAIL("unspecified number of channels");
2427 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2428 FAIL("no decodable DTS frames");
2430 case AVMEDIA_TYPE_VIDEO:
2432 FAIL("unspecified size");
2433 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2434 FAIL("unspecified pixel format");
2436 case AVMEDIA_TYPE_SUBTITLE:
2437 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2438 FAIL("unspecified size");
2440 case AVMEDIA_TYPE_DATA:
2441 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2444 if (avctx->codec_id == AV_CODEC_ID_NONE)
2445 FAIL("unknown codec");
2449 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2450 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2452 const AVCodec *codec;
2453 int got_picture = 1, ret = 0;
2454 AVFrame *frame = avcodec_alloc_frame();
2455 AVSubtitle subtitle;
2456 AVPacket pkt = *avpkt;
2459 return AVERROR(ENOMEM);
2461 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2462 AVDictionary *thread_opt = NULL;
2464 codec = st->codec->codec ? st->codec->codec :
2465 avcodec_find_decoder(st->codec->codec_id);
2468 st->info->found_decoder = -1;
2473 /* force thread count to 1 since the h264 decoder will not extract SPS
2474 * and PPS to extradata during multi-threaded decoding */
2475 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2476 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2478 av_dict_free(&thread_opt);
2480 st->info->found_decoder = -1;
2483 st->info->found_decoder = 1;
2484 } else if (!st->info->found_decoder)
2485 st->info->found_decoder = 1;
2487 if (st->info->found_decoder < 0) {
2492 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2494 (!has_codec_parameters(st, NULL) ||
2495 !has_decode_delay_been_guessed(st) ||
2496 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2498 avcodec_get_frame_defaults(frame);
2499 switch(st->codec->codec_type) {
2500 case AVMEDIA_TYPE_VIDEO:
2501 ret = avcodec_decode_video2(st->codec, frame,
2502 &got_picture, &pkt);
2504 case AVMEDIA_TYPE_AUDIO:
2505 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2507 case AVMEDIA_TYPE_SUBTITLE:
2508 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2509 &got_picture, &pkt);
2517 st->nb_decoded_frames++;
2524 if(!pkt.data && !got_picture)
2528 avcodec_free_frame(&frame);
2532 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2534 while (tags->id != AV_CODEC_ID_NONE) {
2542 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2545 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2546 if(tag == tags[i].tag)
2549 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2550 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2553 return AV_CODEC_ID_NONE;
2556 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2560 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2561 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2562 default: return AV_CODEC_ID_NONE;
2567 if (sflags & (1 << (bps - 1))) {
2569 case 1: return AV_CODEC_ID_PCM_S8;
2570 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2571 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2572 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2573 default: return AV_CODEC_ID_NONE;
2577 case 1: return AV_CODEC_ID_PCM_U8;
2578 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2579 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2580 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2581 default: return AV_CODEC_ID_NONE;
2587 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2590 if (!av_codec_get_tag2(tags, id, &tag))
2595 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2599 for(i=0; tags && tags[i]; i++){
2600 const AVCodecTag *codec_tags = tags[i];
2601 while (codec_tags->id != AV_CODEC_ID_NONE) {
2602 if (codec_tags->id == id) {
2603 *tag = codec_tags->tag;
2612 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2615 for(i=0; tags && tags[i]; i++){
2616 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2617 if(id!=AV_CODEC_ID_NONE) return id;
2619 return AV_CODEC_ID_NONE;
2622 static void compute_chapters_end(AVFormatContext *s)
2625 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2627 for (i = 0; i < s->nb_chapters; i++)
2628 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2629 AVChapter *ch = s->chapters[i];
2630 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2633 for (j = 0; j < s->nb_chapters; j++) {
2634 AVChapter *ch1 = s->chapters[j];
2635 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2636 if (j != i && next_start > ch->start && next_start < end)
2639 ch->end = (end == INT64_MAX) ? ch->start : end;
2643 static int get_std_framerate(int i){
2644 if(i<60*12) return (i+1)*1001;
2645 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2649 * Is the time base unreliable.
2650 * This is a heuristic to balance between quick acceptance of the values in
2651 * the headers vs. some extra checks.
2652 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2653 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2654 * And there are "variable" fps files this needs to detect as well.
2656 static int tb_unreliable(AVCodecContext *c){
2657 if( c->time_base.den >= 101L*c->time_base.num
2658 || c->time_base.den < 5L*c->time_base.num
2659 /* || c->codec_tag == AV_RL32("DIVX")
2660 || c->codec_tag == AV_RL32("XVID")*/
2661 || c->codec_tag == AV_RL32("mp4v")
2662 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2663 || c->codec_id == AV_CODEC_ID_H264
2669 #if FF_API_FORMAT_PARAMETERS
2670 int av_find_stream_info(AVFormatContext *ic)
2672 return avformat_find_stream_info(ic, NULL);
2676 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2678 int i, count, ret, read_size, j;
2680 AVPacket pkt1, *pkt;
2681 int64_t old_offset = avio_tell(ic->pb);
2682 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2683 int flush_codecs = ic->probesize > 0;
2686 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2688 for(i=0;i<ic->nb_streams;i++) {
2689 const AVCodec *codec;
2690 AVDictionary *thread_opt = NULL;
2691 st = ic->streams[i];
2693 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2694 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2695 /* if(!st->time_base.num)
2697 if(!st->codec->time_base.num)
2698 st->codec->time_base= st->time_base;
2700 //only for the split stuff
2701 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2702 st->parser = av_parser_init(st->codec->codec_id);
2704 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2705 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2706 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2707 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2709 } else if (st->need_parsing) {
2710 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2711 "%s, packets or times may be invalid.\n",
2712 avcodec_get_name(st->codec->codec_id));
2715 codec = st->codec->codec ? st->codec->codec :
2716 avcodec_find_decoder(st->codec->codec_id);
2718 /* force thread count to 1 since the h264 decoder will not extract SPS
2719 * and PPS to extradata during multi-threaded decoding */
2720 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2722 /* Ensure that subtitle_header is properly set. */
2723 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2724 && codec && !st->codec->codec)
2725 avcodec_open2(st->codec, codec, options ? &options[i]
2728 //try to just open decoders, in case this is enough to get parameters
2729 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2730 if (codec && !st->codec->codec)
2731 avcodec_open2(st->codec, codec, options ? &options[i]
2735 av_dict_free(&thread_opt);
2738 for (i=0; i<ic->nb_streams; i++) {
2739 #if FF_API_R_FRAME_RATE
2740 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2742 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2743 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2749 if (ff_check_interrupt(&ic->interrupt_callback)){
2751 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2755 /* check if one codec still needs to be handled */
2756 for(i=0;i<ic->nb_streams;i++) {
2757 int fps_analyze_framecount = 20;
2759 st = ic->streams[i];
2760 if (!has_codec_parameters(st, NULL))
2762 /* if the timebase is coarse (like the usual millisecond precision
2763 of mkv), we need to analyze more frames to reliably arrive at
2765 if (av_q2d(st->time_base) > 0.0005)
2766 fps_analyze_framecount *= 2;
2767 if (ic->fps_probe_size >= 0)
2768 fps_analyze_framecount = ic->fps_probe_size;
2769 /* variable fps and no guess at the real fps */
2770 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2771 && st->info->duration_count < fps_analyze_framecount
2772 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2774 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2776 if (st->first_dts == AV_NOPTS_VALUE &&
2777 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2778 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2781 if (i == ic->nb_streams) {
2782 /* NOTE: if the format has no header, then we need to read
2783 some packets to get most of the streams, so we cannot
2785 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2786 /* if we found the info for all the codecs, we can stop */
2788 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2793 /* we did not get all the codec info, but we read too much data */
2794 if (read_size >= ic->probesize) {
2796 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2797 for (i = 0; i < ic->nb_streams; i++)
2798 if (!ic->streams[i]->r_frame_rate.num &&
2799 ic->streams[i]->info->duration_count <= 1)
2800 av_log(ic, AV_LOG_WARNING,
2801 "Stream #%d: not enough frames to estimate rate; "
2802 "consider increasing probesize\n", i);
2806 /* NOTE: a new stream can be added there if no header in file
2807 (AVFMTCTX_NOHEADER) */
2808 ret = read_frame_internal(ic, &pkt1);
2809 if (ret == AVERROR(EAGAIN))
2817 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2820 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2821 &ic->packet_buffer_end);
2822 if ((ret = av_dup_packet(pkt)) < 0)
2823 goto find_stream_info_err;
2826 read_size += pkt->size;
2828 st = ic->streams[pkt->stream_index];
2829 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2830 /* check for non-increasing dts */
2831 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2832 st->info->fps_last_dts >= pkt->dts) {
2833 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2834 "packet %d with DTS %"PRId64", packet %d with DTS "
2835 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2836 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2837 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2839 /* check for a discontinuity in dts - if the difference in dts
2840 * is more than 1000 times the average packet duration in the sequence,
2841 * we treat it as a discontinuity */
2842 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2843 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2844 (pkt->dts - st->info->fps_last_dts) / 1000 >
2845 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2846 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2847 "packet %d with DTS %"PRId64", packet %d with DTS "
2848 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2849 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2850 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2853 /* update stored dts values */
2854 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2855 st->info->fps_first_dts = pkt->dts;
2856 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2858 st->info->fps_last_dts = pkt->dts;
2859 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2861 if (st->codec_info_nb_frames>1) {
2863 if (st->time_base.den > 0)
2864 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2865 if (st->avg_frame_rate.num > 0)
2866 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2868 if (t >= ic->max_analyze_duration) {
2869 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2872 if (pkt->duration) {
2873 st->info->codec_info_duration += pkt->duration;
2874 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2877 #if FF_API_R_FRAME_RATE
2879 int64_t last = st->info->last_dts;
2881 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2882 && pkt->dts - (uint64_t)last < INT64_MAX){
2883 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2884 int64_t duration= pkt->dts - last;
2886 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2887 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2888 for (i=0; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2889 int framerate= get_std_framerate(i);
2890 double sdts= dts*framerate/(1001*12);
2892 int64_t ticks= llrint(sdts+j*0.5);
2893 double error= sdts - ticks + j*0.5;
2894 st->info->duration_error[j][0][i] += error;
2895 st->info->duration_error[j][1][i] += error*error;
2898 st->info->duration_count++;
2899 // ignore the first 4 values, they might have some random jitter
2900 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2901 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2903 if (pkt->dts != AV_NOPTS_VALUE)
2904 st->info->last_dts = pkt->dts;
2907 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2908 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2909 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2910 st->codec->extradata_size= i;
2911 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2912 if (!st->codec->extradata)
2913 return AVERROR(ENOMEM);
2914 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2915 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2919 /* if still no information, we try to open the codec and to
2920 decompress the frame. We try to avoid that in most cases as
2921 it takes longer and uses more memory. For MPEG-4, we need to
2922 decompress for QuickTime.
2924 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2925 least one frame of codec data, this makes sure the codec initializes
2926 the channel configuration and does not only trust the values from the container.
2928 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2930 st->codec_info_nb_frames++;
2935 AVPacket empty_pkt = { 0 };
2937 av_init_packet(&empty_pkt);
2939 ret = -1; /* we could not have all the codec parameters before EOF */
2940 for(i=0;i<ic->nb_streams;i++) {
2943 st = ic->streams[i];
2945 /* flush the decoders */
2946 if (st->info->found_decoder == 1) {
2948 err = try_decode_frame(st, &empty_pkt,
2949 (options && i < orig_nb_streams) ?
2950 &options[i] : NULL);
2951 } while (err > 0 && !has_codec_parameters(st, NULL));
2954 av_log(ic, AV_LOG_INFO,
2955 "decoding for stream %d failed\n", st->index);
2959 if (!has_codec_parameters(st, &errmsg)) {
2961 avcodec_string(buf, sizeof(buf), st->codec, 0);
2962 av_log(ic, AV_LOG_WARNING,
2963 "Could not find codec parameters for stream %d (%s): %s\n"
2964 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
2972 // close codecs which were opened in try_decode_frame()
2973 for(i=0;i<ic->nb_streams;i++) {
2974 st = ic->streams[i];
2975 avcodec_close(st->codec);
2977 for(i=0;i<ic->nb_streams;i++) {
2978 st = ic->streams[i];
2979 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2980 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2981 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2982 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2983 st->codec->codec_tag= tag;
2986 /* estimate average framerate if not set by demuxer */
2987 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
2989 double best_error = 0.01;
2991 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2992 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
2993 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
2995 /* round guessed framerate to a "standard" framerate if it's
2996 * within 1% of the original estimate*/
2997 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2998 AVRational std_fps = { get_std_framerate(j), 12*1001 };
2999 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3001 if (error < best_error) {
3003 best_fps = std_fps.num;
3007 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3008 best_fps, 12*1001, INT_MAX);
3011 // the check for tb_unreliable() is not completely correct, since this is not about handling
3012 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3013 // ipmovie.c produces.
3014 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)
3015 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);
3016 if (st->info->duration_count>1 && !st->r_frame_rate.num
3017 && tb_unreliable(st->codec)) {
3019 double best_error= 0.01;
3021 for (j=0; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
3024 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3026 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3029 int n= st->info->duration_count;
3030 double a= st->info->duration_error[k][0][j] / n;
3031 double error= st->info->duration_error[k][1][j]/n - a*a;
3033 if(error < best_error && best_error> 0.000000001){
3035 num = get_std_framerate(j);
3038 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3041 // do not increase frame rate by more than 1 % in order to match a standard rate.
3042 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3043 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3046 if (!st->r_frame_rate.num){
3047 if( st->codec->time_base.den * (int64_t)st->time_base.num
3048 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3049 st->r_frame_rate.num = st->codec->time_base.den;
3050 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3052 st->r_frame_rate.num = st->time_base.den;
3053 st->r_frame_rate.den = st->time_base.num;
3056 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3057 if(!st->codec->bits_per_coded_sample)
3058 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3059 // set stream disposition based on audio service type
3060 switch (st->codec->audio_service_type) {
3061 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3062 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3063 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3064 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3065 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3066 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3067 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3068 st->disposition = AV_DISPOSITION_COMMENT; break;
3069 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3070 st->disposition = AV_DISPOSITION_KARAOKE; break;
3076 estimate_timings(ic, old_offset);
3078 compute_chapters_end(ic);
3080 find_stream_info_err:
3081 for (i=0; i < ic->nb_streams; i++) {
3082 if (ic->streams[i]->codec)
3083 ic->streams[i]->codec->thread_count = 0;
3084 av_freep(&ic->streams[i]->info);
3087 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3091 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3095 for (i = 0; i < ic->nb_programs; i++) {
3096 if (ic->programs[i] == last) {
3100 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3101 if (ic->programs[i]->stream_index[j] == s)
3102 return ic->programs[i];
3108 int av_find_best_stream(AVFormatContext *ic,
3109 enum AVMediaType type,
3110 int wanted_stream_nb,
3112 AVCodec **decoder_ret,
3115 int i, nb_streams = ic->nb_streams;
3116 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3117 unsigned *program = NULL;
3118 AVCodec *decoder = NULL, *best_decoder = NULL;
3120 if (related_stream >= 0 && wanted_stream_nb < 0) {
3121 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3123 program = p->stream_index;
3124 nb_streams = p->nb_stream_indexes;
3127 for (i = 0; i < nb_streams; i++) {
3128 int real_stream_index = program ? program[i] : i;
3129 AVStream *st = ic->streams[real_stream_index];
3130 AVCodecContext *avctx = st->codec;
3131 if (avctx->codec_type != type)
3133 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3135 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3138 decoder = avcodec_find_decoder(st->codec->codec_id);
3141 ret = AVERROR_DECODER_NOT_FOUND;
3145 count = st->codec_info_nb_frames;
3146 bitrate = avctx->bit_rate;
3147 multiframe = FFMIN(5, count);
3148 if ((best_multiframe > multiframe) ||
3149 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3150 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3153 best_bitrate = bitrate;
3154 best_multiframe = multiframe;
3155 ret = real_stream_index;
3156 best_decoder = decoder;
3157 if (program && i == nb_streams - 1 && ret < 0) {
3159 nb_streams = ic->nb_streams;
3160 i = 0; /* no related stream found, try again with everything */
3164 *decoder_ret = best_decoder;
3168 /*******************************************************/
3170 int av_read_play(AVFormatContext *s)
3172 if (s->iformat->read_play)
3173 return s->iformat->read_play(s);
3175 return avio_pause(s->pb, 0);
3176 return AVERROR(ENOSYS);
3179 int av_read_pause(AVFormatContext *s)
3181 if (s->iformat->read_pause)
3182 return s->iformat->read_pause(s);
3184 return avio_pause(s->pb, 1);
3185 return AVERROR(ENOSYS);
3188 void ff_free_stream(AVFormatContext *s, AVStream *st){
3189 av_assert0(s->nb_streams>0);
3190 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3193 av_parser_close(st->parser);
3195 if (st->attached_pic.data)
3196 av_free_packet(&st->attached_pic);
3197 av_dict_free(&st->metadata);
3198 av_freep(&st->index_entries);
3199 av_freep(&st->codec->extradata);
3200 av_freep(&st->codec->subtitle_header);
3201 av_freep(&st->codec);
3202 av_freep(&st->priv_data);
3203 av_freep(&st->info);
3204 av_freep(&st->probe_data.buf);
3205 av_freep(&s->streams[ --s->nb_streams ]);
3208 void avformat_free_context(AVFormatContext *s)
3216 if (s->iformat && s->iformat->priv_class && s->priv_data)
3217 av_opt_free(s->priv_data);
3219 for(i=s->nb_streams-1; i>=0; i--) {
3220 ff_free_stream(s, s->streams[i]);
3222 for(i=s->nb_programs-1; i>=0; i--) {
3223 av_dict_free(&s->programs[i]->metadata);
3224 av_freep(&s->programs[i]->stream_index);
3225 av_freep(&s->programs[i]);
3227 av_freep(&s->programs);
3228 av_freep(&s->priv_data);
3229 while(s->nb_chapters--) {
3230 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3231 av_freep(&s->chapters[s->nb_chapters]);
3233 av_freep(&s->chapters);
3234 av_dict_free(&s->metadata);
3235 av_freep(&s->streams);
3239 #if FF_API_CLOSE_INPUT_FILE
3240 void av_close_input_file(AVFormatContext *s)
3242 avformat_close_input(&s);
3246 void avformat_close_input(AVFormatContext **ps)
3248 AVFormatContext *s = *ps;
3249 AVIOContext *pb = s->pb;
3251 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3252 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3255 flush_packet_queue(s);
3258 if (s->iformat->read_close)
3259 s->iformat->read_close(s);
3262 avformat_free_context(s);
3269 #if FF_API_NEW_STREAM
3270 AVStream *av_new_stream(AVFormatContext *s, int id)
3272 AVStream *st = avformat_new_stream(s, NULL);
3279 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3285 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3287 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3290 s->streams = streams;
3292 st = av_mallocz(sizeof(AVStream));
3295 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3299 st->info->last_dts = AV_NOPTS_VALUE;
3301 st->codec = avcodec_alloc_context3(c);
3303 /* no default bitrate if decoding */
3304 st->codec->bit_rate = 0;
3306 st->index = s->nb_streams;
3307 st->start_time = AV_NOPTS_VALUE;
3308 st->duration = AV_NOPTS_VALUE;
3309 /* we set the current DTS to 0 so that formats without any timestamps
3310 but durations get some timestamps, formats with some unknown
3311 timestamps have their first few packets buffered and the
3312 timestamps corrected before they are returned to the user */
3313 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3314 st->first_dts = AV_NOPTS_VALUE;
3315 st->probe_packets = MAX_PROBE_PACKETS;
3316 st->pts_wrap_reference = AV_NOPTS_VALUE;
3317 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3319 /* default pts setting is MPEG-like */
3320 avpriv_set_pts_info(st, 33, 1, 90000);
3321 st->last_IP_pts = AV_NOPTS_VALUE;
3322 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3323 st->pts_buffer[i]= AV_NOPTS_VALUE;
3324 st->reference_dts = AV_NOPTS_VALUE;
3326 st->sample_aspect_ratio = (AVRational){0,1};
3328 #if FF_API_R_FRAME_RATE
3329 st->info->last_dts = AV_NOPTS_VALUE;
3331 st->info->fps_first_dts = AV_NOPTS_VALUE;
3332 st->info->fps_last_dts = AV_NOPTS_VALUE;
3334 s->streams[s->nb_streams++] = st;
3338 AVProgram *av_new_program(AVFormatContext *ac, int id)
3340 AVProgram *program=NULL;
3343 av_dlog(ac, "new_program: id=0x%04x\n", id);
3345 for(i=0; i<ac->nb_programs; i++)
3346 if(ac->programs[i]->id == id)
3347 program = ac->programs[i];
3350 program = av_mallocz(sizeof(AVProgram));
3353 dynarray_add(&ac->programs, &ac->nb_programs, program);
3354 program->discard = AVDISCARD_NONE;
3357 program->pts_wrap_reference = AV_NOPTS_VALUE;
3358 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3360 program->start_time =
3361 program->end_time = AV_NOPTS_VALUE;
3366 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3368 AVChapter *chapter = NULL;
3371 for(i=0; i<s->nb_chapters; i++)
3372 if(s->chapters[i]->id == id)
3373 chapter = s->chapters[i];
3376 chapter= av_mallocz(sizeof(AVChapter));
3379 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3381 av_dict_set(&chapter->metadata, "title", title, 0);
3383 chapter->time_base= time_base;
3384 chapter->start = start;
3390 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3393 AVProgram *program=NULL;
3396 if (idx >= ac->nb_streams) {
3397 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3401 for(i=0; i<ac->nb_programs; i++){
3402 if(ac->programs[i]->id != progid)
3404 program = ac->programs[i];
3405 for(j=0; j<program->nb_stream_indexes; j++)
3406 if(program->stream_index[j] == idx)
3409 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3412 program->stream_index = tmp;
3413 program->stream_index[program->nb_stream_indexes++] = idx;
3418 static void print_fps(double d, const char *postfix){
3419 uint64_t v= lrintf(d*100);
3420 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3421 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3422 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3425 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3427 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3428 AVDictionaryEntry *tag=NULL;
3430 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3431 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3432 if(strcmp("language", tag->key)){
3433 const char *p = tag->value;
3434 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3437 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3438 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3439 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3441 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3442 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3445 av_log(ctx, AV_LOG_INFO, "\n");
3451 /* "user interface" functions */
3452 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3455 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3456 AVStream *st = ic->streams[i];
3457 int g = av_gcd(st->time_base.num, st->time_base.den);
3458 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3459 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3460 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3461 /* the pid is an important information, so we display it */
3462 /* XXX: add a generic system */
3463 if (flags & AVFMT_SHOW_IDS)
3464 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3466 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3467 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3468 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3469 if (st->sample_aspect_ratio.num && // default
3470 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3471 AVRational display_aspect_ratio;
3472 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3473 st->codec->width*st->sample_aspect_ratio.num,
3474 st->codec->height*st->sample_aspect_ratio.den,
3476 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3477 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3478 display_aspect_ratio.num, display_aspect_ratio.den);
3480 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3481 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3482 print_fps(av_q2d(st->avg_frame_rate), "fps");
3483 #if FF_API_R_FRAME_RATE
3484 if(st->r_frame_rate.den && st->r_frame_rate.num)
3485 print_fps(av_q2d(st->r_frame_rate), "tbr");
3487 if(st->time_base.den && st->time_base.num)
3488 print_fps(1/av_q2d(st->time_base), "tbn");
3489 if(st->codec->time_base.den && st->codec->time_base.num)
3490 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3492 if (st->disposition & AV_DISPOSITION_DEFAULT)
3493 av_log(NULL, AV_LOG_INFO, " (default)");
3494 if (st->disposition & AV_DISPOSITION_DUB)
3495 av_log(NULL, AV_LOG_INFO, " (dub)");
3496 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3497 av_log(NULL, AV_LOG_INFO, " (original)");
3498 if (st->disposition & AV_DISPOSITION_COMMENT)
3499 av_log(NULL, AV_LOG_INFO, " (comment)");
3500 if (st->disposition & AV_DISPOSITION_LYRICS)
3501 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3502 if (st->disposition & AV_DISPOSITION_KARAOKE)
3503 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3504 if (st->disposition & AV_DISPOSITION_FORCED)
3505 av_log(NULL, AV_LOG_INFO, " (forced)");
3506 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3507 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3508 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3509 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3510 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3511 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3512 av_log(NULL, AV_LOG_INFO, "\n");
3513 dump_metadata(NULL, st->metadata, " ");
3516 void av_dump_format(AVFormatContext *ic,
3522 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3523 if (ic->nb_streams && !printed)
3526 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3527 is_output ? "Output" : "Input",
3529 is_output ? ic->oformat->name : ic->iformat->name,
3530 is_output ? "to" : "from", url);
3531 dump_metadata(NULL, ic->metadata, " ");
3533 av_log(NULL, AV_LOG_INFO, " Duration: ");
3534 if (ic->duration != AV_NOPTS_VALUE) {
3535 int hours, mins, secs, us;
3536 int64_t duration = ic->duration + 5000;
3537 secs = duration / AV_TIME_BASE;
3538 us = duration % AV_TIME_BASE;
3543 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3544 (100 * us) / AV_TIME_BASE);
3546 av_log(NULL, AV_LOG_INFO, "N/A");
3548 if (ic->start_time != AV_NOPTS_VALUE) {
3550 av_log(NULL, AV_LOG_INFO, ", start: ");
3551 secs = ic->start_time / AV_TIME_BASE;
3552 us = abs(ic->start_time % AV_TIME_BASE);
3553 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3554 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3556 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3558 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3560 av_log(NULL, AV_LOG_INFO, "N/A");
3562 av_log(NULL, AV_LOG_INFO, "\n");
3564 for (i = 0; i < ic->nb_chapters; i++) {
3565 AVChapter *ch = ic->chapters[i];
3566 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3567 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3568 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3570 dump_metadata(NULL, ch->metadata, " ");
3572 if(ic->nb_programs) {
3573 int j, k, total = 0;
3574 for(j=0; j<ic->nb_programs; j++) {
3575 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3577 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3578 name ? name->value : "");
3579 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3580 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3581 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3582 printed[ic->programs[j]->stream_index[k]] = 1;
3584 total += ic->programs[j]->nb_stream_indexes;
3586 if (total < ic->nb_streams)
3587 av_log(NULL, AV_LOG_INFO, " No Program\n");
3589 for(i=0;i<ic->nb_streams;i++)
3591 dump_stream_format(ic, i, index, is_output);
3596 #if FF_API_AV_GETTIME && CONFIG_SHARED && HAVE_SYMVER
3597 FF_SYMVER(int64_t, av_gettime, (void), "LIBAVFORMAT_54")
3599 return av_gettime();
3603 uint64_t ff_ntp_time(void)
3605 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3608 int av_get_frame_filename(char *buf, int buf_size,
3609 const char *path, int number)
3612 char *q, buf1[20], c;
3613 int nd, len, percentd_found;
3625 while (isdigit(*p)) {
3626 nd = nd * 10 + *p++ - '0';
3629 } while (isdigit(c));
3638 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3640 if ((q - buf + len) > buf_size - 1)
3642 memcpy(q, buf1, len);
3650 if ((q - buf) < buf_size - 1)
3654 if (!percentd_found)
3663 static void hex_dump_internal(void *avcl, FILE *f, int level,
3664 const uint8_t *buf, int size)
3667 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3669 for(i=0;i<size;i+=16) {
3676 PRINT(" %02x", buf[i+j]);
3681 for(j=0;j<len;j++) {
3683 if (c < ' ' || c > '~')
3692 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3694 hex_dump_internal(NULL, f, 0, buf, size);
3697 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3699 hex_dump_internal(avcl, NULL, level, buf, size);
3702 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3704 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3705 PRINT("stream #%d:\n", pkt->stream_index);
3706 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3707 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3708 /* DTS is _always_ valid after av_read_frame() */
3710 if (pkt->dts == AV_NOPTS_VALUE)
3713 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3714 /* PTS may not be known if B-frames are present. */
3716 if (pkt->pts == AV_NOPTS_VALUE)
3719 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3721 PRINT(" size=%d\n", pkt->size);
3724 av_hex_dump(f, pkt->data, pkt->size);
3728 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3730 AVRational tb = { 1, AV_TIME_BASE };
3731 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3735 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3737 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3741 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3743 AVRational tb = { 1, AV_TIME_BASE };
3744 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3748 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3751 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3754 void av_url_split(char *proto, int proto_size,
3755 char *authorization, int authorization_size,
3756 char *hostname, int hostname_size,
3758 char *path, int path_size,
3761 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3763 if (port_ptr) *port_ptr = -1;
3764 if (proto_size > 0) proto[0] = 0;
3765 if (authorization_size > 0) authorization[0] = 0;
3766 if (hostname_size > 0) hostname[0] = 0;
3767 if (path_size > 0) path[0] = 0;
3769 /* parse protocol */
3770 if ((p = strchr(url, ':'))) {
3771 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3776 /* no protocol means plain filename */
3777 av_strlcpy(path, url, path_size);
3781 /* separate path from hostname */
3782 ls = strchr(p, '/');
3783 ls2 = strchr(p, '?');
3787 ls = FFMIN(ls, ls2);
3789 av_strlcpy(path, ls, path_size);
3791 ls = &p[strlen(p)]; // XXX
3793 /* the rest is hostname, use that to parse auth/port */
3795 /* authorization (user[:pass]@hostname) */
3797 while ((at = strchr(p, '@')) && at < ls) {
3798 av_strlcpy(authorization, at2,
3799 FFMIN(authorization_size, at + 1 - at2));
3800 p = at + 1; /* skip '@' */
3803 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3805 av_strlcpy(hostname, p + 1,
3806 FFMIN(hostname_size, brk - p));
3807 if (brk[1] == ':' && port_ptr)
3808 *port_ptr = atoi(brk + 2);
3809 } else if ((col = strchr(p, ':')) && col < ls) {
3810 av_strlcpy(hostname, p,
3811 FFMIN(col + 1 - p, hostname_size));
3812 if (port_ptr) *port_ptr = atoi(col + 1);
3814 av_strlcpy(hostname, p,
3815 FFMIN(ls + 1 - p, hostname_size));
3819 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3822 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3825 'C', 'D', 'E', 'F' };
3826 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3829 'c', 'd', 'e', 'f' };
3830 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3832 for(i = 0; i < s; i++) {
3833 buff[i * 2] = hex_table[src[i] >> 4];
3834 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3840 int ff_hex_to_data(uint8_t *data, const char *p)
3847 p += strspn(p, SPACE_CHARS);
3850 c = toupper((unsigned char) *p++);
3851 if (c >= '0' && c <= '9')
3853 else if (c >= 'A' && c <= 'F')
3868 #if FF_API_SET_PTS_INFO
3869 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3870 unsigned int pts_num, unsigned int pts_den)
3872 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3876 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3877 unsigned int pts_num, unsigned int pts_den)
3880 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3881 if(new_tb.num != pts_num)
3882 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3884 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3886 if(new_tb.num <= 0 || new_tb.den <= 0) {
3887 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);
3890 s->time_base = new_tb;
3891 av_codec_set_pkt_timebase(s->codec, new_tb);
3892 s->pts_wrap_bits = pts_wrap_bits;
3895 int ff_url_join(char *str, int size, const char *proto,
3896 const char *authorization, const char *hostname,
3897 int port, const char *fmt, ...)
3900 struct addrinfo hints = { 0 }, *ai;
3905 av_strlcatf(str, size, "%s://", proto);
3906 if (authorization && authorization[0])
3907 av_strlcatf(str, size, "%s@", authorization);
3908 #if CONFIG_NETWORK && defined(AF_INET6)
3909 /* Determine if hostname is a numerical IPv6 address,
3910 * properly escape it within [] in that case. */
3911 hints.ai_flags = AI_NUMERICHOST;
3912 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3913 if (ai->ai_family == AF_INET6) {
3914 av_strlcat(str, "[", size);
3915 av_strlcat(str, hostname, size);
3916 av_strlcat(str, "]", size);
3918 av_strlcat(str, hostname, size);
3923 /* Not an IPv6 address, just output the plain string. */
3924 av_strlcat(str, hostname, size);
3927 av_strlcatf(str, size, ":%d", port);
3930 int len = strlen(str);
3933 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3939 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3940 AVFormatContext *src)
3945 local_pkt.stream_index = dst_stream;
3946 if (pkt->pts != AV_NOPTS_VALUE)
3947 local_pkt.pts = av_rescale_q(pkt->pts,
3948 src->streams[pkt->stream_index]->time_base,
3949 dst->streams[dst_stream]->time_base);
3950 if (pkt->dts != AV_NOPTS_VALUE)
3951 local_pkt.dts = av_rescale_q(pkt->dts,
3952 src->streams[pkt->stream_index]->time_base,
3953 dst->streams[dst_stream]->time_base);
3954 return av_write_frame(dst, &local_pkt);
3957 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3960 const char *ptr = str;
3962 /* Parse key=value pairs. */
3965 char *dest = NULL, *dest_end;
3966 int key_len, dest_len = 0;
3968 /* Skip whitespace and potential commas. */
3969 while (*ptr && (isspace(*ptr) || *ptr == ','))
3976 if (!(ptr = strchr(key, '=')))
3979 key_len = ptr - key;
3981 callback_get_buf(context, key, key_len, &dest, &dest_len);
3982 dest_end = dest + dest_len - 1;
3986 while (*ptr && *ptr != '\"') {
3990 if (dest && dest < dest_end)
3994 if (dest && dest < dest_end)
4002 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4003 if (dest && dest < dest_end)
4011 int ff_find_stream_index(AVFormatContext *s, int id)
4014 for (i = 0; i < s->nb_streams; i++) {
4015 if (s->streams[i]->id == id)
4021 void ff_make_absolute_url(char *buf, int size, const char *base,
4024 char *sep, *path_query;
4025 /* Absolute path, relative to the current server */
4026 if (base && strstr(base, "://") && rel[0] == '/') {
4028 av_strlcpy(buf, base, size);
4029 sep = strstr(buf, "://");
4031 /* Take scheme from base url */
4032 if (rel[1] == '/') {
4035 /* Take scheme and host from base url */
4037 sep = strchr(sep, '/');
4042 av_strlcat(buf, rel, size);
4045 /* If rel actually is an absolute url, just copy it */
4046 if (!base || strstr(rel, "://") || rel[0] == '/') {
4047 av_strlcpy(buf, rel, size);
4051 av_strlcpy(buf, base, size);
4053 /* Strip off any query string from base */
4054 path_query = strchr(buf, '?');
4055 if (path_query != NULL)
4058 /* Is relative path just a new query part? */
4059 if (rel[0] == '?') {
4060 av_strlcat(buf, rel, size);
4064 /* Remove the file name from the base url */
4065 sep = strrchr(buf, '/');
4070 while (av_strstart(rel, "../", NULL) && sep) {
4071 /* Remove the path delimiter at the end */
4073 sep = strrchr(buf, '/');
4074 /* If the next directory name to pop off is "..", break here */
4075 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4076 /* Readd the slash we just removed */
4077 av_strlcat(buf, "/", size);
4080 /* Cut off the directory name */
4087 av_strlcat(buf, rel, size);
4090 int64_t ff_iso8601_to_unix_time(const char *datestr)
4092 struct tm time1 = {0}, time2 = {0};
4094 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4095 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4097 return av_timegm(&time2);
4099 return av_timegm(&time1);
4102 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4105 if (ofmt->query_codec)
4106 return ofmt->query_codec(codec_id, std_compliance);
4107 else if (ofmt->codec_tag)
4108 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4109 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4110 codec_id == ofmt->subtitle_codec)
4113 return AVERROR_PATCHWELCOME;
4116 int avformat_network_init(void)
4120 ff_network_inited_globally = 1;
4121 if ((ret = ff_network_init()) < 0)
4128 int avformat_network_deinit(void)
4137 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4138 uint64_t channel_layout, int32_t sample_rate,
4139 int32_t width, int32_t height)
4145 return AVERROR(EINVAL);
4148 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4150 if (channel_layout) {
4152 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4156 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4158 if (width || height) {
4160 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4162 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4164 return AVERROR(ENOMEM);
4165 bytestream_put_le32(&data, flags);
4167 bytestream_put_le32(&data, channels);
4169 bytestream_put_le64(&data, channel_layout);
4171 bytestream_put_le32(&data, sample_rate);
4172 if (width || height) {
4173 bytestream_put_le32(&data, width);
4174 bytestream_put_le32(&data, height);
4179 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4181 return ff_codec_bmp_tags;
4183 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4185 return ff_codec_wav_tags;
4188 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4190 AVRational undef = {0, 1};
4191 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4192 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4193 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4195 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4196 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4197 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4198 stream_sample_aspect_ratio = undef;
4200 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4201 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4202 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4203 frame_sample_aspect_ratio = undef;
4205 if (stream_sample_aspect_ratio.num)
4206 return stream_sample_aspect_ratio;
4208 return frame_sample_aspect_ratio;
4211 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4214 if (*spec <= '9' && *spec >= '0') /* opt:index */
4215 return strtol(spec, NULL, 0) == st->index;
4216 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4217 *spec == 't') { /* opt:[vasdt] */
4218 enum AVMediaType type;
4221 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4222 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4223 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4224 case 'd': type = AVMEDIA_TYPE_DATA; break;
4225 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4226 default: av_assert0(0);
4228 if (type != st->codec->codec_type)
4230 if (*spec++ == ':') { /* possibly followed by :index */
4231 int i, index = strtol(spec, NULL, 0);
4232 for (i = 0; i < s->nb_streams; i++)
4233 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4234 return i == st->index;
4238 } else if (*spec == 'p' && *(spec + 1) == ':') {
4242 prog_id = strtol(spec, &endptr, 0);
4243 for (i = 0; i < s->nb_programs; i++) {
4244 if (s->programs[i]->id != prog_id)
4247 if (*endptr++ == ':') {
4248 int stream_idx = strtol(endptr, NULL, 0);
4249 return stream_idx >= 0 &&
4250 stream_idx < s->programs[i]->nb_stream_indexes &&
4251 st->index == s->programs[i]->stream_index[stream_idx];
4254 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4255 if (st->index == s->programs[i]->stream_index[j])
4259 } else if (*spec == '#') {
4262 sid = strtol(spec + 1, &endptr, 0);
4264 return st->id == sid;
4265 } else if (!*spec) /* empty specifier, matches everything */
4268 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4269 return AVERROR(EINVAL);
4272 void ff_generate_avci_extradata(AVStream *st)
4274 static const uint8_t avci100_1080p_extradata[] = {
4276 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4277 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4278 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4279 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4280 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4281 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4282 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4283 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4284 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4286 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4289 static const uint8_t avci100_1080i_extradata[] = {
4291 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4292 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4293 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4294 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4295 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4296 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4297 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4298 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4299 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4300 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4301 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4303 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4306 static const uint8_t avci50_1080i_extradata[] = {
4308 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4309 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4310 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4311 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4312 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4313 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4314 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4315 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4316 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4317 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4318 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4320 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4323 static const uint8_t avci100_720p_extradata[] = {
4325 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4326 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4327 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4328 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4329 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4330 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4331 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4332 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4333 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4334 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4336 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4340 const uint8_t *data = 0;
4341 if (st->codec->width == 1920) {
4342 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4343 data = avci100_1080p_extradata;
4344 size = sizeof(avci100_1080p_extradata);
4346 data = avci100_1080i_extradata;
4347 size = sizeof(avci100_1080i_extradata);
4349 } else if (st->codec->width == 1440) {
4350 data = avci50_1080i_extradata;
4351 size = sizeof(avci50_1080i_extradata);
4352 } else if (st->codec->width == 1280) {
4353 data = avci100_720p_extradata;
4354 size = sizeof(avci100_720p_extradata);
4358 av_freep(&st->codec->extradata);
4359 st->codec->extradata_size = 0;
4360 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4361 if (!st->codec->extradata)
4363 memcpy(st->codec->extradata, data, size);
4364 st->codec->extradata_size = size;