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
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
64 return LIBAVFORMAT_VERSION_INT;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts) {
81 return ts > (RELATIVE_TS_BASE - (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
94 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
95 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
96 timestamp < st->pts_wrap_reference)
97 return timestamp + (1ULL << st->pts_wrap_bits);
98 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99 timestamp >= st->pts_wrap_reference)
100 return timestamp - (1ULL << st->pts_wrap_bits);
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
113 int64_t av_stream_get_end_pts(const AVStream *st)
118 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
123 void av_format_inject_global_side_data(AVFormatContext *s)
126 s->internal->inject_global_side_data = 1;
127 for (i = 0; i < s->nb_streams; i++) {
128 AVStream *st = s->streams[i];
129 st->inject_global_side_data = 1;
133 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
135 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
136 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
137 dst->format_whitelist = av_strdup(src->format_whitelist);
138 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
139 || (src->format_whitelist && !dst->format_whitelist)) {
140 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
141 return AVERROR(ENOMEM);
146 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
148 if (st->codec->codec)
149 return st->codec->codec;
151 switch (st->codec->codec_type) {
152 case AVMEDIA_TYPE_VIDEO:
153 if (s->video_codec) return s->video_codec;
155 case AVMEDIA_TYPE_AUDIO:
156 if (s->audio_codec) return s->audio_codec;
158 case AVMEDIA_TYPE_SUBTITLE:
159 if (s->subtitle_codec) return s->subtitle_codec;
163 return avcodec_find_decoder(codec_id);
166 int av_format_get_probe_score(const AVFormatContext *s)
168 return s->probe_score;
171 /* an arbitrarily chosen "sane" max packet size -- 50M */
172 #define SANE_CHUNK_SIZE (50000000)
174 int ffio_limit(AVIOContext *s, int size)
176 if (s->maxsize>= 0) {
177 int64_t remaining= s->maxsize - avio_tell(s);
178 if (remaining < size) {
179 int64_t newsize = avio_size(s);
180 if (!s->maxsize || s->maxsize<newsize)
181 s->maxsize = newsize - !newsize;
182 remaining= s->maxsize - avio_tell(s);
183 remaining= FFMAX(remaining, 0);
186 if (s->maxsize>= 0 && remaining+1 < size) {
187 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
194 /* Read the data in sane-sized chunks and append to pkt.
195 * Return the number of bytes read or an error. */
196 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
198 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
199 int orig_size = pkt->size;
203 int prev_size = pkt->size;
206 /* When the caller requests a lot of data, limit it to the amount
207 * left in file or SANE_CHUNK_SIZE when it is not known. */
209 if (read_size > SANE_CHUNK_SIZE/10) {
210 read_size = ffio_limit(s, read_size);
211 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
213 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
216 ret = av_grow_packet(pkt, read_size);
220 ret = avio_read(s, pkt->data + prev_size, read_size);
221 if (ret != read_size) {
222 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
229 pkt->flags |= AV_PKT_FLAG_CORRUPT;
234 return pkt->size > orig_size ? pkt->size - orig_size : ret;
237 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
242 pkt->pos = avio_tell(s);
244 return append_packet_chunked(s, pkt, size);
247 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
250 return av_get_packet(s, pkt, size);
251 return append_packet_chunked(s, pkt, size);
254 int av_filename_number_test(const char *filename)
258 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
261 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
264 static const struct {
267 enum AVMediaType type;
269 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
270 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
271 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
272 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
273 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
274 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
275 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
276 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
277 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
278 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
282 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
284 if (fmt && st->request_probe <= score) {
286 av_log(s, AV_LOG_DEBUG,
287 "Probe with size=%d, packets=%d detected %s with score=%d\n",
288 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
290 for (i = 0; fmt_id_type[i].name; i++) {
291 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
292 st->codec->codec_id = fmt_id_type[i].id;
293 st->codec->codec_type = fmt_id_type[i].type;
301 /************************************************************/
302 /* input media file */
304 int av_demuxer_open(AVFormatContext *ic) {
307 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
308 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
309 return AVERROR(EINVAL);
312 if (ic->iformat->read_header) {
313 err = ic->iformat->read_header(ic);
318 if (ic->pb && !ic->data_offset)
319 ic->data_offset = avio_tell(ic->pb);
324 /* Open input file and probe the format if necessary. */
325 static int init_input(AVFormatContext *s, const char *filename,
326 AVDictionary **options)
329 AVProbeData pd = { filename, NULL, 0 };
330 int score = AVPROBE_SCORE_RETRY;
333 s->flags |= AVFMT_FLAG_CUSTOM_IO;
335 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
336 s, 0, s->format_probesize);
337 else if (s->iformat->flags & AVFMT_NOFILE)
338 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
339 "will be ignored with AVFMT_NOFILE format.\n");
343 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
344 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
347 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
348 &s->interrupt_callback, options)) < 0)
352 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
353 s, 0, s->format_probesize);
356 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
357 AVPacketList **plast_pktl)
359 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
364 (*plast_pktl)->next = pktl;
366 *packet_buffer = pktl;
368 /* Add the packet in the buffered packet list. */
374 int avformat_queue_attached_pictures(AVFormatContext *s)
377 for (i = 0; i < s->nb_streams; i++)
378 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
379 s->streams[i]->discard < AVDISCARD_ALL) {
380 AVPacket copy = s->streams[i]->attached_pic;
381 if (copy.size <= 0) {
382 av_log(s, AV_LOG_WARNING,
383 "Attached picture on stream %d has invalid size, "
387 copy.buf = av_buffer_ref(copy.buf);
389 return AVERROR(ENOMEM);
391 add_to_pktbuf(&s->raw_packet_buffer, ©,
392 &s->raw_packet_buffer_end);
397 int avformat_open_input(AVFormatContext **ps, const char *filename,
398 AVInputFormat *fmt, AVDictionary **options)
400 AVFormatContext *s = *ps;
402 AVDictionary *tmp = NULL;
403 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
405 if (!s && !(s = avformat_alloc_context()))
406 return AVERROR(ENOMEM);
408 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
409 return AVERROR(EINVAL);
415 av_dict_copy(&tmp, *options, 0);
417 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
420 if ((ret = init_input(s, filename, &tmp)) < 0)
422 s->probe_score = ret;
424 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
425 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
426 ret = AVERROR(EINVAL);
430 avio_skip(s->pb, s->skip_initial_bytes);
432 /* Check filename in case an image number is expected. */
433 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
434 if (!av_filename_number_test(filename)) {
435 ret = AVERROR(EINVAL);
440 s->duration = s->start_time = AV_NOPTS_VALUE;
441 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
443 /* Allocate private data. */
444 if (s->iformat->priv_data_size > 0) {
445 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
446 ret = AVERROR(ENOMEM);
449 if (s->iformat->priv_class) {
450 *(const AVClass **) s->priv_data = s->iformat->priv_class;
451 av_opt_set_defaults(s->priv_data);
452 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
457 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
459 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
461 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
462 if ((ret = s->iformat->read_header(s)) < 0)
465 if (id3v2_extra_meta) {
466 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
467 !strcmp(s->iformat->name, "tta")) {
468 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
471 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
473 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
475 if ((ret = avformat_queue_attached_pictures(s)) < 0)
478 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
479 s->data_offset = avio_tell(s->pb);
481 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
484 av_dict_free(options);
491 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
493 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
495 avformat_free_context(s);
500 /*******************************************************/
502 static void force_codec_ids(AVFormatContext *s, AVStream *st)
504 switch (st->codec->codec_type) {
505 case AVMEDIA_TYPE_VIDEO:
506 if (s->video_codec_id)
507 st->codec->codec_id = s->video_codec_id;
509 case AVMEDIA_TYPE_AUDIO:
510 if (s->audio_codec_id)
511 st->codec->codec_id = s->audio_codec_id;
513 case AVMEDIA_TYPE_SUBTITLE:
514 if (s->subtitle_codec_id)
515 st->codec->codec_id = s->subtitle_codec_id;
520 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
522 if (st->request_probe>0) {
523 AVProbeData *pd = &st->probe_data;
525 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
529 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
531 av_log(s, AV_LOG_WARNING,
532 "Failed to reallocate probe buffer for stream %d\n",
537 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
538 pd->buf_size += pkt->size;
539 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
542 st->probe_packets = 0;
544 av_log(s, AV_LOG_WARNING,
545 "nothing to probe for stream %d\n", st->index);
549 end= s->raw_packet_buffer_remaining_size <= 0
550 || st->probe_packets<= 0;
552 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
553 int score = set_codec_from_probe_data(s, st, pd);
554 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
558 st->request_probe = -1;
559 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
560 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
562 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
564 force_codec_ids(s, st);
570 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
572 int64_t ref = pkt->dts;
573 int i, pts_wrap_behavior;
574 int64_t pts_wrap_reference;
575 AVProgram *first_program;
577 if (ref == AV_NOPTS_VALUE)
579 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
581 ref &= (1LL << st->pts_wrap_bits)-1;
583 // reference time stamp should be 60 s before first time stamp
584 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
585 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
586 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
587 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
588 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
590 first_program = av_find_program_from_stream(s, NULL, stream_index);
592 if (!first_program) {
593 int default_stream_index = av_find_default_stream_index(s);
594 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
595 for (i = 0; i < s->nb_streams; i++) {
596 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
597 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
601 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
602 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
606 AVProgram *program = first_program;
608 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
609 pts_wrap_reference = program->pts_wrap_reference;
610 pts_wrap_behavior = program->pts_wrap_behavior;
613 program = av_find_program_from_stream(s, program, stream_index);
616 // update every program with differing pts_wrap_reference
617 program = first_program;
619 if (program->pts_wrap_reference != pts_wrap_reference) {
620 for (i = 0; i<program->nb_stream_indexes; i++) {
621 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
622 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
625 program->pts_wrap_reference = pts_wrap_reference;
626 program->pts_wrap_behavior = pts_wrap_behavior;
628 program = av_find_program_from_stream(s, program, stream_index);
634 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
640 AVPacketList *pktl = s->raw_packet_buffer;
644 st = s->streams[pkt->stream_index];
645 if (s->raw_packet_buffer_remaining_size <= 0)
646 if ((err = probe_codec(s, st, NULL)) < 0)
648 if (st->request_probe <= 0) {
649 s->raw_packet_buffer = pktl->next;
650 s->raw_packet_buffer_remaining_size += pkt->size;
659 ret = s->iformat->read_packet(s, pkt);
661 if (!pktl || ret == AVERROR(EAGAIN))
663 for (i = 0; i < s->nb_streams; i++) {
665 if (st->probe_packets)
666 if ((err = probe_codec(s, st, NULL)) < 0)
668 av_assert0(st->request_probe <= 0);
673 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
674 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
675 av_log(s, AV_LOG_WARNING,
676 "Dropped corrupted packet (stream = %d)\n",
682 if (pkt->stream_index >= (unsigned)s->nb_streams) {
683 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
687 st = s->streams[pkt->stream_index];
689 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
690 // correct first time stamps to negative values
691 if (!is_relative(st->first_dts))
692 st->first_dts = wrap_timestamp(st, st->first_dts);
693 if (!is_relative(st->start_time))
694 st->start_time = wrap_timestamp(st, st->start_time);
695 if (!is_relative(st->cur_dts))
696 st->cur_dts = wrap_timestamp(st, st->cur_dts);
699 pkt->dts = wrap_timestamp(st, pkt->dts);
700 pkt->pts = wrap_timestamp(st, pkt->pts);
702 force_codec_ids(s, st);
704 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
705 if (s->use_wallclock_as_timestamps)
706 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
708 if (!pktl && st->request_probe <= 0)
711 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
712 s->raw_packet_buffer_remaining_size -= pkt->size;
714 if ((err = probe_codec(s, st, pkt)) < 0)
720 /**********************************************************/
722 static int determinable_frame_size(AVCodecContext *avctx)
724 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
725 avctx->codec_id == AV_CODEC_ID_MP1 ||
726 avctx->codec_id == AV_CODEC_ID_MP2 ||
727 avctx->codec_id == AV_CODEC_ID_MP3/* ||
728 avctx->codec_id == AV_CODEC_ID_CELT*/)
734 * Return the frame duration in seconds. Return 0 if not available.
736 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
737 AVCodecParserContext *pc, AVPacket *pkt)
739 AVRational codec_framerate = s->iformat ? st->codec->framerate :
740 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
745 switch (st->codec->codec_type) {
746 case AVMEDIA_TYPE_VIDEO:
747 if (st->r_frame_rate.num && !pc) {
748 *pnum = st->r_frame_rate.den;
749 *pden = st->r_frame_rate.num;
750 } else if (st->time_base.num * 1000LL > st->time_base.den) {
751 *pnum = st->time_base.num;
752 *pden = st->time_base.den;
753 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
754 av_assert0(st->codec->ticks_per_frame);
755 av_reduce(pnum, pden,
757 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
760 if (pc && pc->repeat_pict) {
761 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
762 av_reduce(pnum, pden,
763 (*pnum) * (1LL + pc->repeat_pict),
767 /* If this codec can be interlaced or progressive then we need
768 * a parser to compute duration of a packet. Thus if we have
769 * no parser in such case leave duration undefined. */
770 if (st->codec->ticks_per_frame > 1 && !pc)
774 case AVMEDIA_TYPE_AUDIO:
775 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
776 if (frame_size <= 0 || st->codec->sample_rate <= 0)
779 *pden = st->codec->sample_rate;
786 static int is_intra_only(AVCodecContext *enc) {
787 const AVCodecDescriptor *desc;
789 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
792 desc = av_codec_get_codec_descriptor(enc);
794 desc = avcodec_descriptor_get(enc->codec_id);
795 av_codec_set_codec_descriptor(enc, desc);
798 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
802 static int has_decode_delay_been_guessed(AVStream *st)
804 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
805 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
807 #if CONFIG_H264_DECODER
808 if (st->codec->has_b_frames &&
809 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
812 if (st->codec->has_b_frames<3)
813 return st->nb_decoded_frames >= 7;
814 else if (st->codec->has_b_frames<4)
815 return st->nb_decoded_frames >= 18;
817 return st->nb_decoded_frames >= 20;
820 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
824 if (pktl == s->packet_buffer_end)
825 return s->parse_queue;
829 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
830 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
831 st->codec->codec_id != AV_CODEC_ID_HEVC;
834 int delay = st->codec->has_b_frames;
837 if (dts == AV_NOPTS_VALUE) {
838 int64_t best_score = INT64_MAX;
839 for (i = 0; i<delay; i++) {
840 if (st->pts_reorder_error_count[i]) {
841 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
842 if (score < best_score) {
849 for (i = 0; i<delay; i++) {
850 if (pts_buffer[i] != AV_NOPTS_VALUE) {
851 int64_t diff = FFABS(pts_buffer[i] - dts)
852 + (uint64_t)st->pts_reorder_error[i];
853 diff = FFMAX(diff, st->pts_reorder_error[i]);
854 st->pts_reorder_error[i] = diff;
855 st->pts_reorder_error_count[i]++;
856 if (st->pts_reorder_error_count[i] > 250) {
857 st->pts_reorder_error[i] >>= 1;
858 st->pts_reorder_error_count[i] >>= 1;
865 if (dts == AV_NOPTS_VALUE)
871 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
872 int64_t dts, int64_t pts, AVPacket *pkt)
874 AVStream *st = s->streams[stream_index];
875 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
876 int64_t pts_buffer[MAX_REORDER_DELAY+1];
880 if (st->first_dts != AV_NOPTS_VALUE ||
881 dts == AV_NOPTS_VALUE ||
882 st->cur_dts == AV_NOPTS_VALUE ||
886 delay = st->codec->has_b_frames;
887 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
889 shift = st->first_dts - RELATIVE_TS_BASE;
891 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
892 pts_buffer[i] = AV_NOPTS_VALUE;
894 if (is_relative(pts))
897 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
898 if (pktl->pkt.stream_index != stream_index)
900 if (is_relative(pktl->pkt.pts))
901 pktl->pkt.pts += shift;
903 if (is_relative(pktl->pkt.dts))
904 pktl->pkt.dts += shift;
906 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
907 st->start_time = pktl->pkt.pts;
909 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
910 pts_buffer[0] = pktl->pkt.pts;
911 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
912 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
914 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
918 if (st->start_time == AV_NOPTS_VALUE)
919 st->start_time = pts;
922 static void update_initial_durations(AVFormatContext *s, AVStream *st,
923 int stream_index, int duration)
925 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
926 int64_t cur_dts = RELATIVE_TS_BASE;
928 if (st->first_dts != AV_NOPTS_VALUE) {
929 if (st->update_initial_durations_done)
931 st->update_initial_durations_done = 1;
932 cur_dts = st->first_dts;
933 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
934 if (pktl->pkt.stream_index == stream_index) {
935 if (pktl->pkt.pts != pktl->pkt.dts ||
936 pktl->pkt.dts != AV_NOPTS_VALUE ||
942 if (pktl && pktl->pkt.dts != st->first_dts) {
943 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
944 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
948 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
951 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
952 st->first_dts = cur_dts;
953 } else if (st->cur_dts != RELATIVE_TS_BASE)
956 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
957 if (pktl->pkt.stream_index != stream_index)
959 if (pktl->pkt.pts == pktl->pkt.dts &&
960 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
961 !pktl->pkt.duration) {
962 pktl->pkt.dts = cur_dts;
963 if (!st->codec->has_b_frames)
964 pktl->pkt.pts = cur_dts;
965 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
966 pktl->pkt.duration = duration;
969 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
972 st->cur_dts = cur_dts;
975 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
976 AVCodecParserContext *pc, AVPacket *pkt)
978 int num, den, presentation_delayed, delay, i;
981 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
982 st->codec->codec_id != AV_CODEC_ID_HEVC;
984 if (s->flags & AVFMT_FLAG_NOFILLIN)
987 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
988 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
989 if (st->last_dts_for_order_check <= pkt->dts) {
992 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
993 "DTS %"PRIi64" < %"PRIi64" out of order\n",
995 st->last_dts_for_order_check);
996 st->dts_misordered++;
998 if (st->dts_ordered + st->dts_misordered > 250) {
999 st->dts_ordered >>= 1;
1000 st->dts_misordered >>= 1;
1004 st->last_dts_for_order_check = pkt->dts;
1005 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1006 pkt->dts = AV_NOPTS_VALUE;
1009 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1010 pkt->dts = AV_NOPTS_VALUE;
1012 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1013 && !st->codec->has_b_frames)
1014 //FIXME Set low_delay = 0 when has_b_frames = 1
1015 st->codec->has_b_frames = 1;
1017 /* do we have a video B-frame ? */
1018 delay = st->codec->has_b_frames;
1019 presentation_delayed = 0;
1021 /* XXX: need has_b_frame, but cannot get it if the codec is
1022 * not initialized */
1024 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1025 presentation_delayed = 1;
1027 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1028 st->pts_wrap_bits < 63 &&
1029 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1030 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1031 pkt->dts -= 1LL << st->pts_wrap_bits;
1033 pkt->pts += 1LL << st->pts_wrap_bits;
1036 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1037 * We take the conservative approach and discard both.
1038 * Note: If this is misbehaving for an H.264 file, then possibly
1039 * presentation_delayed is not set correctly. */
1040 if (delay == 1 && pkt->dts == pkt->pts &&
1041 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1042 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1043 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1044 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1045 pkt->dts = AV_NOPTS_VALUE;
1048 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1049 if (pkt->duration == 0) {
1050 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1052 duration = (AVRational) {num, den};
1053 pkt->duration = av_rescale_rnd(1,
1054 num * (int64_t) st->time_base.den,
1055 den * (int64_t) st->time_base.num,
1060 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1061 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1063 /* Correct timestamps with byte offset if demuxers only have timestamps
1064 * on packet boundaries */
1065 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1066 /* this will estimate bitrate based on this frame's duration and size */
1067 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1068 if (pkt->pts != AV_NOPTS_VALUE)
1070 if (pkt->dts != AV_NOPTS_VALUE)
1074 /* This may be redundant, but it should not hurt. */
1075 if (pkt->dts != AV_NOPTS_VALUE &&
1076 pkt->pts != AV_NOPTS_VALUE &&
1077 pkt->pts > pkt->dts)
1078 presentation_delayed = 1;
1081 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1082 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1083 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1084 /* Interpolate PTS and DTS if they are not present. We skip H264
1085 * currently because delay and has_b_frames are not reliably set. */
1086 if ((delay == 0 || (delay == 1 && pc)) &&
1088 if (presentation_delayed) {
1089 /* DTS = decompression timestamp */
1090 /* PTS = presentation timestamp */
1091 if (pkt->dts == AV_NOPTS_VALUE)
1092 pkt->dts = st->last_IP_pts;
1093 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1094 if (pkt->dts == AV_NOPTS_VALUE)
1095 pkt->dts = st->cur_dts;
1097 /* This is tricky: the dts must be incremented by the duration
1098 * of the frame we are displaying, i.e. the last I- or P-frame. */
1099 if (st->last_IP_duration == 0)
1100 st->last_IP_duration = pkt->duration;
1101 if (pkt->dts != AV_NOPTS_VALUE)
1102 st->cur_dts = pkt->dts + st->last_IP_duration;
1103 st->last_IP_duration = pkt->duration;
1104 st->last_IP_pts = pkt->pts;
1105 /* Cannot compute PTS if not present (we can compute it only
1106 * by knowing the future. */
1107 } else if (pkt->pts != AV_NOPTS_VALUE ||
1108 pkt->dts != AV_NOPTS_VALUE ||
1111 /* presentation is not delayed : PTS and DTS are the same */
1112 if (pkt->pts == AV_NOPTS_VALUE)
1113 pkt->pts = pkt->dts;
1114 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1116 if (pkt->pts == AV_NOPTS_VALUE)
1117 pkt->pts = st->cur_dts;
1118 pkt->dts = pkt->pts;
1119 if (pkt->pts != AV_NOPTS_VALUE)
1120 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1124 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1125 st->pts_buffer[0] = pkt->pts;
1126 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1127 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1129 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1131 // We skipped it above so we try here.
1133 // This should happen on the first packet
1134 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1135 if (pkt->dts > st->cur_dts)
1136 st->cur_dts = pkt->dts;
1138 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1139 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1142 if (is_intra_only(st->codec))
1143 pkt->flags |= AV_PKT_FLAG_KEY;
1145 pkt->convergence_duration = pc->convergence_duration;
1148 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1151 AVPacketList *pktl = *pkt_buf;
1152 *pkt_buf = pktl->next;
1153 av_free_packet(&pktl->pkt);
1156 *pkt_buf_end = NULL;
1160 * Parse a packet, add all split parts to parse_queue.
1162 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1164 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1166 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1167 AVStream *st = s->streams[stream_index];
1168 uint8_t *data = pkt ? pkt->data : NULL;
1169 int size = pkt ? pkt->size : 0;
1170 int ret = 0, got_output = 0;
1173 av_init_packet(&flush_pkt);
1176 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1177 // preserve 0-size sync packets
1178 compute_pkt_fields(s, st, st->parser, pkt);
1181 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1184 av_init_packet(&out_pkt);
1185 len = av_parser_parse2(st->parser, st->codec,
1186 &out_pkt.data, &out_pkt.size, data, size,
1187 pkt->pts, pkt->dts, pkt->pos);
1189 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1191 /* increment read pointer */
1195 got_output = !!out_pkt.size;
1200 if (pkt->side_data) {
1201 out_pkt.side_data = pkt->side_data;
1202 out_pkt.side_data_elems = pkt->side_data_elems;
1203 pkt->side_data = NULL;
1204 pkt->side_data_elems = 0;
1207 /* set the duration */
1208 out_pkt.duration = 0;
1209 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1210 if (st->codec->sample_rate > 0) {
1212 av_rescale_q_rnd(st->parser->duration,
1213 (AVRational) { 1, st->codec->sample_rate },
1219 out_pkt.stream_index = st->index;
1220 out_pkt.pts = st->parser->pts;
1221 out_pkt.dts = st->parser->dts;
1222 out_pkt.pos = st->parser->pos;
1224 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1225 out_pkt.pos = st->parser->frame_offset;
1227 if (st->parser->key_frame == 1 ||
1228 (st->parser->key_frame == -1 &&
1229 st->parser->pict_type == AV_PICTURE_TYPE_I))
1230 out_pkt.flags |= AV_PKT_FLAG_KEY;
1232 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1233 out_pkt.flags |= AV_PKT_FLAG_KEY;
1235 compute_pkt_fields(s, st, st->parser, &out_pkt);
1237 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1238 out_pkt.buf = pkt->buf;
1240 #if FF_API_DESTRUCT_PACKET
1241 FF_DISABLE_DEPRECATION_WARNINGS
1242 out_pkt.destruct = pkt->destruct;
1243 pkt->destruct = NULL;
1244 FF_ENABLE_DEPRECATION_WARNINGS
1247 if ((ret = av_dup_packet(&out_pkt)) < 0)
1250 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1251 av_free_packet(&out_pkt);
1252 ret = AVERROR(ENOMEM);
1257 /* end of the stream => close and free the parser */
1258 if (pkt == &flush_pkt) {
1259 av_parser_close(st->parser);
1264 av_free_packet(pkt);
1268 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1269 AVPacketList **pkt_buffer_end,
1273 av_assert0(*pkt_buffer);
1276 *pkt_buffer = pktl->next;
1278 *pkt_buffer_end = NULL;
1283 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1285 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1288 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1290 int ret = 0, i, got_packet = 0;
1291 AVDictionary *metadata = NULL;
1293 av_init_packet(pkt);
1295 while (!got_packet && !s->parse_queue) {
1299 /* read next packet */
1300 ret = ff_read_packet(s, &cur_pkt);
1302 if (ret == AVERROR(EAGAIN))
1304 /* flush the parsers */
1305 for (i = 0; i < s->nb_streams; i++) {
1307 if (st->parser && st->need_parsing)
1308 parse_packet(s, NULL, st->index);
1310 /* all remaining packets are now in parse_queue =>
1311 * really terminate parsing */
1315 st = s->streams[cur_pkt.stream_index];
1317 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1318 cur_pkt.dts != AV_NOPTS_VALUE &&
1319 cur_pkt.pts < cur_pkt.dts) {
1320 av_log(s, AV_LOG_WARNING,
1321 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1322 cur_pkt.stream_index,
1323 av_ts2str(cur_pkt.pts),
1324 av_ts2str(cur_pkt.dts),
1327 if (s->debug & FF_FDEBUG_TS)
1328 av_log(s, AV_LOG_DEBUG,
1329 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1330 cur_pkt.stream_index,
1331 av_ts2str(cur_pkt.pts),
1332 av_ts2str(cur_pkt.dts),
1333 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1335 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1336 st->parser = av_parser_init(st->codec->codec_id);
1338 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1339 "%s, packets or times may be invalid.\n",
1340 avcodec_get_name(st->codec->codec_id));
1341 /* no parser available: just output the raw packets */
1342 st->need_parsing = AVSTREAM_PARSE_NONE;
1343 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1344 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1345 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1346 st->parser->flags |= PARSER_FLAG_ONCE;
1347 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1348 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1351 if (!st->need_parsing || !st->parser) {
1352 /* no parsing needed: we just output the packet as is */
1354 compute_pkt_fields(s, st, NULL, pkt);
1355 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1356 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1357 ff_reduce_index(s, st->index);
1358 av_add_index_entry(st, pkt->pos, pkt->dts,
1359 0, 0, AVINDEX_KEYFRAME);
1362 } else if (st->discard < AVDISCARD_ALL) {
1363 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1367 av_free_packet(&cur_pkt);
1369 if (pkt->flags & AV_PKT_FLAG_KEY)
1370 st->skip_to_keyframe = 0;
1371 if (st->skip_to_keyframe) {
1372 av_free_packet(&cur_pkt);
1380 if (!got_packet && s->parse_queue)
1381 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1384 AVStream *st = s->streams[pkt->stream_index];
1385 int discard_padding = 0;
1386 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1387 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1388 int64_t sample = ts_to_samples(st, pts);
1389 int duration = ts_to_samples(st, pkt->duration);
1390 int64_t end_sample = sample + duration;
1391 if (duration > 0 && end_sample >= st->first_discard_sample &&
1392 sample < st->last_discard_sample)
1393 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1395 if (st->skip_samples || discard_padding) {
1396 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1398 AV_WL32(p, st->skip_samples);
1399 AV_WL32(p + 4, discard_padding);
1400 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1402 st->skip_samples = 0;
1405 if (st->inject_global_side_data) {
1406 for (i = 0; i < st->nb_side_data; i++) {
1407 AVPacketSideData *src_sd = &st->side_data[i];
1410 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1413 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1415 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1419 memcpy(dst_data, src_sd->data, src_sd->size);
1421 st->inject_global_side_data = 0;
1424 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1425 av_packet_merge_side_data(pkt);
1428 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1430 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1431 av_dict_copy(&s->metadata, metadata, 0);
1432 av_dict_free(&metadata);
1433 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1436 if (s->debug & FF_FDEBUG_TS)
1437 av_log(s, AV_LOG_DEBUG,
1438 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1439 "size=%d, duration=%d, flags=%d\n",
1441 av_ts2str(pkt->pts),
1442 av_ts2str(pkt->dts),
1443 pkt->size, pkt->duration, pkt->flags);
1448 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1450 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1456 ret = s->packet_buffer
1457 ? read_from_packet_buffer(&s->packet_buffer,
1458 &s->packet_buffer_end, pkt)
1459 : read_frame_internal(s, pkt);
1466 AVPacketList *pktl = s->packet_buffer;
1469 AVPacket *next_pkt = &pktl->pkt;
1471 if (next_pkt->dts != AV_NOPTS_VALUE) {
1472 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1473 // last dts seen for this stream. if any of packets following
1474 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1475 int64_t last_dts = next_pkt->dts;
1476 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1477 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1478 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1479 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1481 next_pkt->pts = pktl->pkt.dts;
1483 if (last_dts != AV_NOPTS_VALUE) {
1484 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1485 last_dts = pktl->pkt.dts;
1490 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1491 // Fixing the last reference frame had none pts issue (For MXF etc).
1492 // We only do this when
1494 // 2. we are not able to resolve a pts value for current packet.
1495 // 3. the packets for this stream at the end of the files had valid dts.
1496 next_pkt->pts = last_dts + next_pkt->duration;
1498 pktl = s->packet_buffer;
1501 /* read packet from packet buffer, if there is data */
1502 st = s->streams[next_pkt->stream_index];
1503 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1504 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1505 ret = read_from_packet_buffer(&s->packet_buffer,
1506 &s->packet_buffer_end, pkt);
1511 ret = read_frame_internal(s, pkt);
1513 if (pktl && ret != AVERROR(EAGAIN)) {
1520 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1521 &s->packet_buffer_end)) < 0)
1522 return AVERROR(ENOMEM);
1527 st = s->streams[pkt->stream_index];
1528 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1529 ff_reduce_index(s, st->index);
1530 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1533 if (is_relative(pkt->dts))
1534 pkt->dts -= RELATIVE_TS_BASE;
1535 if (is_relative(pkt->pts))
1536 pkt->pts -= RELATIVE_TS_BASE;
1541 /* XXX: suppress the packet queue */
1542 static void flush_packet_queue(AVFormatContext *s)
1544 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1545 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1546 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1548 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1551 /*******************************************************/
1554 int av_find_default_stream_index(AVFormatContext *s)
1558 int best_stream = 0;
1559 int best_score = -1;
1561 if (s->nb_streams <= 0)
1563 for (i = 0; i < s->nb_streams; i++) {
1566 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1567 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1568 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1573 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1574 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1580 if (score > best_score) {
1588 /** Flush the frame reader. */
1589 void ff_read_frame_flush(AVFormatContext *s)
1594 flush_packet_queue(s);
1596 /* Reset read state for each stream. */
1597 for (i = 0; i < s->nb_streams; i++) {
1601 av_parser_close(st->parser);
1604 st->last_IP_pts = AV_NOPTS_VALUE;
1605 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1606 if (st->first_dts == AV_NOPTS_VALUE)
1607 st->cur_dts = RELATIVE_TS_BASE;
1609 /* We set the current DTS to an unspecified origin. */
1610 st->cur_dts = AV_NOPTS_VALUE;
1612 st->probe_packets = MAX_PROBE_PACKETS;
1614 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1615 st->pts_buffer[j] = AV_NOPTS_VALUE;
1617 if (s->internal->inject_global_side_data)
1618 st->inject_global_side_data = 1;
1622 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1626 for (i = 0; i < s->nb_streams; i++) {
1627 AVStream *st = s->streams[i];
1630 av_rescale(timestamp,
1631 st->time_base.den * (int64_t) ref_st->time_base.num,
1632 st->time_base.num * (int64_t) ref_st->time_base.den);
1636 void ff_reduce_index(AVFormatContext *s, int stream_index)
1638 AVStream *st = s->streams[stream_index];
1639 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1641 if ((unsigned) st->nb_index_entries >= max_entries) {
1643 for (i = 0; 2 * i < st->nb_index_entries; i++)
1644 st->index_entries[i] = st->index_entries[2 * i];
1645 st->nb_index_entries = i;
1649 int ff_add_index_entry(AVIndexEntry **index_entries,
1650 int *nb_index_entries,
1651 unsigned int *index_entries_allocated_size,
1652 int64_t pos, int64_t timestamp,
1653 int size, int distance, int flags)
1655 AVIndexEntry *entries, *ie;
1658 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1661 if (timestamp == AV_NOPTS_VALUE)
1662 return AVERROR(EINVAL);
1664 if (size < 0 || size > 0x3FFFFFFF)
1665 return AVERROR(EINVAL);
1667 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1668 timestamp -= RELATIVE_TS_BASE;
1670 entries = av_fast_realloc(*index_entries,
1671 index_entries_allocated_size,
1672 (*nb_index_entries + 1) *
1673 sizeof(AVIndexEntry));
1677 *index_entries = entries;
1679 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1680 timestamp, AVSEEK_FLAG_ANY);
1683 index = (*nb_index_entries)++;
1684 ie = &entries[index];
1685 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1687 ie = &entries[index];
1688 if (ie->timestamp != timestamp) {
1689 if (ie->timestamp <= timestamp)
1691 memmove(entries + index + 1, entries + index,
1692 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1693 (*nb_index_entries)++;
1694 } else if (ie->pos == pos && distance < ie->min_distance)
1695 // do not reduce the distance
1696 distance = ie->min_distance;
1700 ie->timestamp = timestamp;
1701 ie->min_distance = distance;
1708 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1709 int size, int distance, int flags)
1711 timestamp = wrap_timestamp(st, timestamp);
1712 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1713 &st->index_entries_allocated_size, pos,
1714 timestamp, size, distance, flags);
1717 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1718 int64_t wanted_timestamp, int flags)
1726 // Optimize appending index entries at the end.
1727 if (b && entries[b - 1].timestamp < wanted_timestamp)
1732 timestamp = entries[m].timestamp;
1733 if (timestamp >= wanted_timestamp)
1735 if (timestamp <= wanted_timestamp)
1738 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1740 if (!(flags & AVSEEK_FLAG_ANY))
1741 while (m >= 0 && m < nb_entries &&
1742 !(entries[m].flags & AVINDEX_KEYFRAME))
1743 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1745 if (m == nb_entries)
1750 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1752 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1753 wanted_timestamp, flags);
1756 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1757 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1759 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1760 if (stream_index >= 0)
1761 ts = wrap_timestamp(s->streams[stream_index], ts);
1765 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1766 int64_t target_ts, int flags)
1768 AVInputFormat *avif = s->iformat;
1769 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1770 int64_t ts_min, ts_max, ts;
1775 if (stream_index < 0)
1778 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1781 ts_min = AV_NOPTS_VALUE;
1782 pos_limit = -1; // GCC falsely says it may be uninitialized.
1784 st = s->streams[stream_index];
1785 if (st->index_entries) {
1788 /* FIXME: Whole function must be checked for non-keyframe entries in
1789 * index case, especially read_timestamp(). */
1790 index = av_index_search_timestamp(st, target_ts,
1791 flags | AVSEEK_FLAG_BACKWARD);
1792 index = FFMAX(index, 0);
1793 e = &st->index_entries[index];
1795 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1797 ts_min = e->timestamp;
1798 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1799 pos_min, av_ts2str(ts_min));
1801 av_assert1(index == 0);
1804 index = av_index_search_timestamp(st, target_ts,
1805 flags & ~AVSEEK_FLAG_BACKWARD);
1806 av_assert0(index < st->nb_index_entries);
1808 e = &st->index_entries[index];
1809 av_assert1(e->timestamp >= target_ts);
1811 ts_max = e->timestamp;
1812 pos_limit = pos_max - e->min_distance;
1813 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1814 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1818 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1819 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1824 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1827 ff_read_frame_flush(s);
1828 ff_update_cur_dts(s, st, ts);
1833 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1834 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1836 int64_t step = 1024;
1837 int64_t limit, ts_max;
1838 int64_t filesize = avio_size(s->pb);
1839 int64_t pos_max = filesize - 1;
1842 pos_max = FFMAX(0, (pos_max) - step);
1843 ts_max = ff_read_timestamp(s, stream_index,
1844 &pos_max, limit, read_timestamp);
1846 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1847 if (ts_max == AV_NOPTS_VALUE)
1851 int64_t tmp_pos = pos_max + 1;
1852 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1853 &tmp_pos, INT64_MAX, read_timestamp);
1854 if (tmp_ts == AV_NOPTS_VALUE)
1856 av_assert0(tmp_pos > pos_max);
1859 if (tmp_pos >= filesize)
1871 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1872 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1873 int64_t ts_min, int64_t ts_max,
1874 int flags, int64_t *ts_ret,
1875 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1876 int64_t *, int64_t))
1883 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1885 if (ts_min == AV_NOPTS_VALUE) {
1886 pos_min = s->data_offset;
1887 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1888 if (ts_min == AV_NOPTS_VALUE)
1892 if (ts_min >= target_ts) {
1897 if (ts_max == AV_NOPTS_VALUE) {
1898 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1900 pos_limit = pos_max;
1903 if (ts_max <= target_ts) {
1908 if (ts_min > ts_max)
1910 else if (ts_min == ts_max)
1911 pos_limit = pos_min;
1914 while (pos_min < pos_limit) {
1916 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1917 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1918 assert(pos_limit <= pos_max);
1920 if (no_change == 0) {
1921 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1922 // interpolate position (better than dichotomy)
1923 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1925 pos_min - approximate_keyframe_distance;
1926 } else if (no_change == 1) {
1927 // bisection if interpolation did not change min / max pos last time
1928 pos = (pos_min + pos_limit) >> 1;
1930 /* linear search if bisection failed, can only happen if there
1931 * are very few or no keyframes between min/max */
1936 else if (pos > pos_limit)
1940 // May pass pos_limit instead of -1.
1941 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1946 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1947 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1948 pos_min, pos, pos_max,
1949 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1950 pos_limit, start_pos, no_change);
1951 if (ts == AV_NOPTS_VALUE) {
1952 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1955 if (target_ts <= ts) {
1956 pos_limit = start_pos - 1;
1960 if (target_ts >= ts) {
1966 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1967 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1970 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1972 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1973 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1974 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1980 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1981 int64_t pos, int flags)
1983 int64_t pos_min, pos_max;
1985 pos_min = s->data_offset;
1986 pos_max = avio_size(s->pb) - 1;
1990 else if (pos > pos_max)
1993 avio_seek(s->pb, pos, SEEK_SET);
1995 s->io_repositioned = 1;
2000 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2001 int64_t timestamp, int flags)
2008 st = s->streams[stream_index];
2010 index = av_index_search_timestamp(st, timestamp, flags);
2012 if (index < 0 && st->nb_index_entries &&
2013 timestamp < st->index_entries[0].timestamp)
2016 if (index < 0 || index == st->nb_index_entries - 1) {
2020 if (st->nb_index_entries) {
2021 av_assert0(st->index_entries);
2022 ie = &st->index_entries[st->nb_index_entries - 1];
2023 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2025 ff_update_cur_dts(s, st, ie->timestamp);
2027 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2033 read_status = av_read_frame(s, &pkt);
2034 } while (read_status == AVERROR(EAGAIN));
2035 if (read_status < 0)
2037 av_free_packet(&pkt);
2038 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2039 if (pkt.flags & AV_PKT_FLAG_KEY)
2041 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2042 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);
2047 index = av_index_search_timestamp(st, timestamp, flags);
2052 ff_read_frame_flush(s);
2053 if (s->iformat->read_seek)
2054 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2056 ie = &st->index_entries[index];
2057 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2059 ff_update_cur_dts(s, st, ie->timestamp);
2064 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2065 int64_t timestamp, int flags)
2070 if (flags & AVSEEK_FLAG_BYTE) {
2071 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2073 ff_read_frame_flush(s);
2074 return seek_frame_byte(s, stream_index, timestamp, flags);
2077 if (stream_index < 0) {
2078 stream_index = av_find_default_stream_index(s);
2079 if (stream_index < 0)
2082 st = s->streams[stream_index];
2083 /* timestamp for default must be expressed in AV_TIME_BASE units */
2084 timestamp = av_rescale(timestamp, st->time_base.den,
2085 AV_TIME_BASE * (int64_t) st->time_base.num);
2088 /* first, we try the format specific seek */
2089 if (s->iformat->read_seek) {
2090 ff_read_frame_flush(s);
2091 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2097 if (s->iformat->read_timestamp &&
2098 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2099 ff_read_frame_flush(s);
2100 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2101 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2102 ff_read_frame_flush(s);
2103 return seek_frame_generic(s, stream_index, timestamp, flags);
2108 int av_seek_frame(AVFormatContext *s, int stream_index,
2109 int64_t timestamp, int flags)
2113 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2114 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2115 if ((flags & AVSEEK_FLAG_BACKWARD))
2119 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2120 flags & ~AVSEEK_FLAG_BACKWARD);
2123 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2126 ret = avformat_queue_attached_pictures(s);
2131 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2132 int64_t ts, int64_t max_ts, int flags)
2134 if (min_ts > ts || max_ts < ts)
2136 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2137 return AVERROR(EINVAL);
2140 flags |= AVSEEK_FLAG_ANY;
2141 flags &= ~AVSEEK_FLAG_BACKWARD;
2143 if (s->iformat->read_seek2) {
2145 ff_read_frame_flush(s);
2147 if (stream_index == -1 && s->nb_streams == 1) {
2148 AVRational time_base = s->streams[0]->time_base;
2149 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2150 min_ts = av_rescale_rnd(min_ts, time_base.den,
2151 time_base.num * (int64_t)AV_TIME_BASE,
2152 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2153 max_ts = av_rescale_rnd(max_ts, time_base.den,
2154 time_base.num * (int64_t)AV_TIME_BASE,
2155 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2158 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2162 ret = avformat_queue_attached_pictures(s);
2166 if (s->iformat->read_timestamp) {
2167 // try to seek via read_timestamp()
2170 // Fall back on old API if new is not implemented but old is.
2171 // Note the old API has somewhat different semantics.
2172 if (s->iformat->read_seek || 1) {
2173 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2174 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2175 if (ret<0 && ts != min_ts && max_ts != ts) {
2176 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2178 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2183 // try some generic seek like seek_frame_generic() but with new ts semantics
2184 return -1; //unreachable
2187 /*******************************************************/
2190 * Return TRUE if the stream has accurate duration in any stream.
2192 * @return TRUE if the stream has accurate duration for at least one component.
2194 static int has_duration(AVFormatContext *ic)
2199 for (i = 0; i < ic->nb_streams; i++) {
2200 st = ic->streams[i];
2201 if (st->duration != AV_NOPTS_VALUE)
2204 if (ic->duration != AV_NOPTS_VALUE)
2210 * Estimate the stream timings from the one of each components.
2212 * Also computes the global bitrate if possible.
2214 static void update_stream_timings(AVFormatContext *ic)
2216 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2217 int64_t duration, duration1, filesize;
2222 start_time = INT64_MAX;
2223 start_time_text = INT64_MAX;
2224 end_time = INT64_MIN;
2225 duration = INT64_MIN;
2226 for (i = 0; i < ic->nb_streams; i++) {
2227 st = ic->streams[i];
2228 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2229 start_time1 = av_rescale_q(st->start_time, st->time_base,
2231 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2232 if (start_time1 < start_time_text)
2233 start_time_text = start_time1;
2235 start_time = FFMIN(start_time, start_time1);
2236 end_time1 = AV_NOPTS_VALUE;
2237 if (st->duration != AV_NOPTS_VALUE) {
2238 end_time1 = start_time1 +
2239 av_rescale_q(st->duration, st->time_base,
2241 end_time = FFMAX(end_time, end_time1);
2243 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2244 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2245 p->start_time = start_time1;
2246 if (p->end_time < end_time1)
2247 p->end_time = end_time1;
2250 if (st->duration != AV_NOPTS_VALUE) {
2251 duration1 = av_rescale_q(st->duration, st->time_base,
2253 duration = FFMAX(duration, duration1);
2256 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2257 start_time = start_time_text;
2258 else if (start_time > start_time_text)
2259 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2261 if (start_time != INT64_MAX) {
2262 ic->start_time = start_time;
2263 if (end_time != INT64_MIN) {
2264 if (ic->nb_programs) {
2265 for (i = 0; i < ic->nb_programs; i++) {
2266 p = ic->programs[i];
2267 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2268 duration = FFMAX(duration, p->end_time - p->start_time);
2271 duration = FFMAX(duration, end_time - start_time);
2274 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2275 ic->duration = duration;
2277 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2278 /* compute the bitrate */
2279 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2280 (double) ic->duration;
2281 if (bitrate >= 0 && bitrate <= INT_MAX)
2282 ic->bit_rate = bitrate;
2286 static void fill_all_stream_timings(AVFormatContext *ic)
2291 update_stream_timings(ic);
2292 for (i = 0; i < ic->nb_streams; i++) {
2293 st = ic->streams[i];
2294 if (st->start_time == AV_NOPTS_VALUE) {
2295 if (ic->start_time != AV_NOPTS_VALUE)
2296 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2298 if (ic->duration != AV_NOPTS_VALUE)
2299 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2305 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2307 int64_t filesize, duration;
2308 int i, show_warning = 0;
2311 /* if bit_rate is already set, we believe it */
2312 if (ic->bit_rate <= 0) {
2314 for (i = 0; i < ic->nb_streams; i++) {
2315 st = ic->streams[i];
2316 if (st->codec->bit_rate > 0) {
2317 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2321 bit_rate += st->codec->bit_rate;
2324 ic->bit_rate = bit_rate;
2327 /* if duration is already set, we believe it */
2328 if (ic->duration == AV_NOPTS_VALUE &&
2329 ic->bit_rate != 0) {
2330 filesize = ic->pb ? avio_size(ic->pb) : 0;
2331 if (filesize > ic->data_offset) {
2332 filesize -= ic->data_offset;
2333 for (i = 0; i < ic->nb_streams; i++) {
2334 st = ic->streams[i];
2335 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2336 && st->duration == AV_NOPTS_VALUE) {
2337 duration = av_rescale(8 * filesize, st->time_base.den,
2339 (int64_t) st->time_base.num);
2340 st->duration = duration;
2347 av_log(ic, AV_LOG_WARNING,
2348 "Estimating duration from bitrate, this may be inaccurate\n");
2351 #define DURATION_MAX_READ_SIZE 250000LL
2352 #define DURATION_MAX_RETRY 4
2354 /* only usable for MPEG-PS streams */
2355 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2357 AVPacket pkt1, *pkt = &pkt1;
2359 int num, den, read_size, i, ret;
2360 int found_duration = 0;
2362 int64_t filesize, offset, duration;
2365 /* flush packet queue */
2366 flush_packet_queue(ic);
2368 for (i = 0; i < ic->nb_streams; i++) {
2369 st = ic->streams[i];
2370 if (st->start_time == AV_NOPTS_VALUE &&
2371 st->first_dts == AV_NOPTS_VALUE &&
2372 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2373 av_log(st->codec, AV_LOG_WARNING,
2374 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2377 av_parser_close(st->parser);
2382 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2383 /* estimate the end time (duration) */
2384 /* XXX: may need to support wrapping */
2385 filesize = ic->pb ? avio_size(ic->pb) : 0;
2387 is_end = found_duration;
2388 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2392 avio_seek(ic->pb, offset, SEEK_SET);
2395 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2399 ret = ff_read_packet(ic, pkt);
2400 } while (ret == AVERROR(EAGAIN));
2403 read_size += pkt->size;
2404 st = ic->streams[pkt->stream_index];
2405 if (pkt->pts != AV_NOPTS_VALUE &&
2406 (st->start_time != AV_NOPTS_VALUE ||
2407 st->first_dts != AV_NOPTS_VALUE)) {
2408 if (pkt->duration == 0) {
2409 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2411 pkt->duration = av_rescale_rnd(1,
2412 num * (int64_t) st->time_base.den,
2413 den * (int64_t) st->time_base.num,
2417 duration = pkt->pts + pkt->duration;
2419 if (st->start_time != AV_NOPTS_VALUE)
2420 duration -= st->start_time;
2422 duration -= st->first_dts;
2424 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2425 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2426 st->duration = duration;
2427 st->info->last_duration = duration;
2430 av_free_packet(pkt);
2433 /* check if all audio/video streams have valid duration */
2436 for (i = 0; i < ic->nb_streams; i++) {
2437 st = ic->streams[i];
2438 switch (st->codec->codec_type) {
2439 case AVMEDIA_TYPE_VIDEO:
2440 case AVMEDIA_TYPE_AUDIO:
2441 if (st->duration == AV_NOPTS_VALUE)
2448 ++retry <= DURATION_MAX_RETRY);
2450 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2452 /* warn about audio/video streams which duration could not be estimated */
2453 for (i = 0; i < ic->nb_streams; i++) {
2454 st = ic->streams[i];
2455 if (st->duration == AV_NOPTS_VALUE) {
2456 switch (st->codec->codec_type) {
2457 case AVMEDIA_TYPE_VIDEO:
2458 case AVMEDIA_TYPE_AUDIO:
2459 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2460 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2462 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2466 fill_all_stream_timings(ic);
2468 avio_seek(ic->pb, old_offset, SEEK_SET);
2469 for (i = 0; i < ic->nb_streams; i++) {
2472 st = ic->streams[i];
2473 st->cur_dts = st->first_dts;
2474 st->last_IP_pts = AV_NOPTS_VALUE;
2475 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2476 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2477 st->pts_buffer[j] = AV_NOPTS_VALUE;
2481 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2485 /* get the file size, if possible */
2486 if (ic->iformat->flags & AVFMT_NOFILE) {
2489 file_size = avio_size(ic->pb);
2490 file_size = FFMAX(0, file_size);
2493 if ((!strcmp(ic->iformat->name, "mpeg") ||
2494 !strcmp(ic->iformat->name, "mpegts")) &&
2495 file_size && ic->pb->seekable) {
2496 /* get accurate estimate from the PTSes */
2497 estimate_timings_from_pts(ic, old_offset);
2498 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2499 } else if (has_duration(ic)) {
2500 /* at least one component has timings - we use them for all
2502 fill_all_stream_timings(ic);
2503 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2505 /* less precise: use bitrate info */
2506 estimate_timings_from_bit_rate(ic);
2507 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2509 update_stream_timings(ic);
2513 AVStream av_unused *st;
2514 for (i = 0; i < ic->nb_streams; i++) {
2515 st = ic->streams[i];
2516 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2517 (double) st->start_time / AV_TIME_BASE,
2518 (double) st->duration / AV_TIME_BASE);
2521 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2522 (double) ic->start_time / AV_TIME_BASE,
2523 (double) ic->duration / AV_TIME_BASE,
2524 ic->bit_rate / 1000);
2528 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2530 AVCodecContext *avctx = st->codec;
2532 #define FAIL(errmsg) do { \
2534 *errmsg_ptr = errmsg; \
2538 if ( avctx->codec_id == AV_CODEC_ID_NONE
2539 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2540 FAIL("unknown codec");
2541 switch (avctx->codec_type) {
2542 case AVMEDIA_TYPE_AUDIO:
2543 if (!avctx->frame_size && determinable_frame_size(avctx))
2544 FAIL("unspecified frame size");
2545 if (st->info->found_decoder >= 0 &&
2546 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2547 FAIL("unspecified sample format");
2548 if (!avctx->sample_rate)
2549 FAIL("unspecified sample rate");
2550 if (!avctx->channels)
2551 FAIL("unspecified number of channels");
2552 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2553 FAIL("no decodable DTS frames");
2555 case AVMEDIA_TYPE_VIDEO:
2557 FAIL("unspecified size");
2558 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2559 FAIL("unspecified pixel format");
2560 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2561 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2562 FAIL("no frame in rv30/40 and no sar");
2564 case AVMEDIA_TYPE_SUBTITLE:
2565 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2566 FAIL("unspecified size");
2568 case AVMEDIA_TYPE_DATA:
2569 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2575 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2576 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2577 AVDictionary **options)
2579 const AVCodec *codec;
2580 int got_picture = 1, ret = 0;
2581 AVFrame *frame = av_frame_alloc();
2582 AVSubtitle subtitle;
2583 AVPacket pkt = *avpkt;
2586 return AVERROR(ENOMEM);
2588 if (!avcodec_is_open(st->codec) &&
2589 st->info->found_decoder <= 0 &&
2590 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2591 AVDictionary *thread_opt = NULL;
2593 codec = find_decoder(s, st, st->codec->codec_id);
2596 st->info->found_decoder = -st->codec->codec_id;
2601 /* Force thread count to 1 since the H.264 decoder will not extract
2602 * SPS and PPS to extradata during multi-threaded decoding. */
2603 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2604 if (s->codec_whitelist)
2605 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2606 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2608 av_dict_free(&thread_opt);
2610 st->info->found_decoder = -st->codec->codec_id;
2613 st->info->found_decoder = 1;
2614 } else if (!st->info->found_decoder)
2615 st->info->found_decoder = 1;
2617 if (st->info->found_decoder < 0) {
2622 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2624 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2625 (!st->codec_info_nb_frames &&
2626 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2628 switch (st->codec->codec_type) {
2629 case AVMEDIA_TYPE_VIDEO:
2630 ret = avcodec_decode_video2(st->codec, frame,
2631 &got_picture, &pkt);
2633 case AVMEDIA_TYPE_AUDIO:
2634 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2636 case AVMEDIA_TYPE_SUBTITLE:
2637 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2638 &got_picture, &pkt);
2646 st->nb_decoded_frames++;
2653 if (!pkt.data && !got_picture)
2657 av_frame_free(&frame);
2661 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2663 while (tags->id != AV_CODEC_ID_NONE) {
2671 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2674 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2675 if (tag == tags[i].tag)
2677 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2678 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2680 return AV_CODEC_ID_NONE;
2683 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2688 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2690 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2692 return AV_CODEC_ID_NONE;
2697 if (sflags & (1 << (bps - 1))) {
2700 return AV_CODEC_ID_PCM_S8;
2702 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2704 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2706 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2708 return AV_CODEC_ID_NONE;
2713 return AV_CODEC_ID_PCM_U8;
2715 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2717 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2719 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2721 return AV_CODEC_ID_NONE;
2727 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2730 if (!av_codec_get_tag2(tags, id, &tag))
2735 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2739 for (i = 0; tags && tags[i]; i++) {
2740 const AVCodecTag *codec_tags = tags[i];
2741 while (codec_tags->id != AV_CODEC_ID_NONE) {
2742 if (codec_tags->id == id) {
2743 *tag = codec_tags->tag;
2752 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2755 for (i = 0; tags && tags[i]; i++) {
2756 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2757 if (id != AV_CODEC_ID_NONE)
2760 return AV_CODEC_ID_NONE;
2763 static void compute_chapters_end(AVFormatContext *s)
2766 int64_t max_time = s->duration +
2767 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2769 for (i = 0; i < s->nb_chapters; i++)
2770 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2771 AVChapter *ch = s->chapters[i];
2772 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2776 for (j = 0; j < s->nb_chapters; j++) {
2777 AVChapter *ch1 = s->chapters[j];
2778 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2780 if (j != i && next_start > ch->start && next_start < end)
2783 ch->end = (end == INT64_MAX) ? ch->start : end;
2787 static int get_std_framerate(int i)
2790 return (i + 1) * 1001;
2792 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2795 /* Is the time base unreliable?
2796 * This is a heuristic to balance between quick acceptance of the values in
2797 * the headers vs. some extra checks.
2798 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2799 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2800 * And there are "variable" fps files this needs to detect as well. */
2801 static int tb_unreliable(AVCodecContext *c)
2803 if (c->time_base.den >= 101L * c->time_base.num ||
2804 c->time_base.den < 5L * c->time_base.num ||
2805 // c->codec_tag == AV_RL32("DIVX") ||
2806 // c->codec_tag == AV_RL32("XVID") ||
2807 c->codec_tag == AV_RL32("mp4v") ||
2808 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2809 c->codec_id == AV_CODEC_ID_GIF ||
2810 c->codec_id == AV_CODEC_ID_H264)
2815 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2819 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2820 avctx->extradata_size = 0;
2821 return AVERROR(EINVAL);
2823 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2824 if (avctx->extradata) {
2825 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2826 avctx->extradata_size = size;
2829 avctx->extradata_size = 0;
2830 ret = AVERROR(ENOMEM);
2835 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2837 int ret = ff_alloc_extradata(avctx, size);
2840 ret = avio_read(pb, avctx->extradata, size);
2842 av_freep(&avctx->extradata);
2843 avctx->extradata_size = 0;
2844 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2845 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2851 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2854 int64_t last = st->info->last_dts;
2856 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2857 && ts - (uint64_t)last < INT64_MAX) {
2858 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2859 int64_t duration = ts - last;
2861 if (!st->info->duration_error)
2862 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2863 if (!st->info->duration_error)
2864 return AVERROR(ENOMEM);
2866 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2867 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2868 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2869 if (st->info->duration_error[0][1][i] < 1e10) {
2870 int framerate = get_std_framerate(i);
2871 double sdts = dts*framerate/(1001*12);
2872 for (j= 0; j<2; j++) {
2873 int64_t ticks = llrint(sdts+j*0.5);
2874 double error= sdts - ticks + j*0.5;
2875 st->info->duration_error[j][0][i] += error;
2876 st->info->duration_error[j][1][i] += error*error;
2880 st->info->duration_count++;
2881 st->info->rfps_duration_sum += duration;
2883 if (st->info->duration_count % 10 == 0) {
2884 int n = st->info->duration_count;
2885 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2886 if (st->info->duration_error[0][1][i] < 1e10) {
2887 double a0 = st->info->duration_error[0][0][i] / n;
2888 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2889 double a1 = st->info->duration_error[1][0][i] / n;
2890 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2891 if (error0 > 0.04 && error1 > 0.04) {
2892 st->info->duration_error[0][1][i] = 2e10;
2893 st->info->duration_error[1][1][i] = 2e10;
2899 // ignore the first 4 values, they might have some random jitter
2900 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2901 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2903 if (ts != AV_NOPTS_VALUE)
2904 st->info->last_dts = ts;
2909 void ff_rfps_calculate(AVFormatContext *ic)
2913 for (i = 0; i < ic->nb_streams; i++) {
2914 AVStream *st = ic->streams[i];
2916 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2918 // the check for tb_unreliable() is not completely correct, since this is not about handling
2919 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2920 // ipmovie.c produces.
2921 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)
2922 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);
2923 if (st->info->duration_count>1 && !st->r_frame_rate.num
2924 && tb_unreliable(st->codec)) {
2926 double best_error= 0.01;
2927 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2929 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2932 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2934 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2937 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2940 for (k= 0; k<2; k++) {
2941 int n = st->info->duration_count;
2942 double a= st->info->duration_error[k][0][j] / n;
2943 double error= st->info->duration_error[k][1][j]/n - a*a;
2945 if (error < best_error && best_error> 0.000000001) {
2947 num = get_std_framerate(j);
2950 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2953 // do not increase frame rate by more than 1 % in order to match a standard rate.
2954 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2955 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2957 if ( !st->avg_frame_rate.num
2958 && st->r_frame_rate.num && st->info->rfps_duration_sum
2959 && st->info->codec_info_duration <= 0
2960 && st->info->duration_count > 2
2961 && fabs(1.0 / (av_q2d(st->r_frame_rate) * av_q2d(st->time_base)) - st->info->rfps_duration_sum / (double)st->info->duration_count) <= 1.0
2963 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2964 st->avg_frame_rate = st->r_frame_rate;
2967 av_freep(&st->info->duration_error);
2968 st->info->last_dts = AV_NOPTS_VALUE;
2969 st->info->duration_count = 0;
2970 st->info->rfps_duration_sum = 0;
2974 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2976 int i, count, ret = 0, j;
2979 AVPacket pkt1, *pkt;
2980 int64_t old_offset = avio_tell(ic->pb);
2981 // new streams might appear, no options for those
2982 int orig_nb_streams = ic->nb_streams;
2984 int64_t max_analyze_duration = ic->max_analyze_duration2;
2985 int64_t probesize = ic->probesize2;
2987 if (!max_analyze_duration)
2988 max_analyze_duration = ic->max_analyze_duration;
2990 probesize = ic->probesize;
2991 flush_codecs = probesize > 0;
2993 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
2995 if (!max_analyze_duration) {
2996 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2997 max_analyze_duration = 10*AV_TIME_BASE;
2999 max_analyze_duration = 5*AV_TIME_BASE;
3003 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3004 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3006 for (i = 0; i < ic->nb_streams; i++) {
3007 const AVCodec *codec;
3008 AVDictionary *thread_opt = NULL;
3009 st = ic->streams[i];
3011 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3012 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3013 /* if (!st->time_base.num)
3015 if (!st->codec->time_base.num)
3016 st->codec->time_base = st->time_base;
3018 // only for the split stuff
3019 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3020 st->parser = av_parser_init(st->codec->codec_id);
3022 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3023 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3024 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3025 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3027 } else if (st->need_parsing) {
3028 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3029 "%s, packets or times may be invalid.\n",
3030 avcodec_get_name(st->codec->codec_id));
3033 codec = find_decoder(ic, st, st->codec->codec_id);
3035 /* Force thread count to 1 since the H.264 decoder will not extract
3036 * SPS and PPS to extradata during multi-threaded decoding. */
3037 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3039 if (ic->codec_whitelist)
3040 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3042 /* Ensure that subtitle_header is properly set. */
3043 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3044 && codec && !st->codec->codec) {
3045 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3046 av_log(ic, AV_LOG_WARNING,
3047 "Failed to open codec in av_find_stream_info\n");
3050 // Try to just open decoders, in case this is enough to get parameters.
3051 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3052 if (codec && !st->codec->codec)
3053 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3054 av_log(ic, AV_LOG_WARNING,
3055 "Failed to open codec in av_find_stream_info\n");
3058 av_dict_free(&thread_opt);
3061 for (i = 0; i < ic->nb_streams; i++) {
3062 #if FF_API_R_FRAME_RATE
3063 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3065 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3066 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3072 if (ff_check_interrupt(&ic->interrupt_callback)) {
3074 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3078 /* check if one codec still needs to be handled */
3079 for (i = 0; i < ic->nb_streams; i++) {
3080 int fps_analyze_framecount = 20;
3082 st = ic->streams[i];
3083 if (!has_codec_parameters(st, NULL))
3085 /* If the timebase is coarse (like the usual millisecond precision
3086 * of mkv), we need to analyze more frames to reliably arrive at
3087 * the correct fps. */
3088 if (av_q2d(st->time_base) > 0.0005)
3089 fps_analyze_framecount *= 2;
3090 if (!tb_unreliable(st->codec))
3091 fps_analyze_framecount = 0;
3092 if (ic->fps_probe_size >= 0)
3093 fps_analyze_framecount = ic->fps_probe_size;
3094 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3095 fps_analyze_framecount = 0;
3096 /* variable fps and no guess at the real fps */
3097 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3098 st->info->duration_count < fps_analyze_framecount &&
3099 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3101 if (st->parser && st->parser->parser->split &&
3102 !st->codec->extradata)
3104 if (st->first_dts == AV_NOPTS_VALUE &&
3105 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3106 st->codec_info_nb_frames < ic->max_ts_probe &&
3107 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3108 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3111 if (i == ic->nb_streams) {
3112 /* NOTE: If the format has no header, then we need to read some
3113 * packets to get most of the streams, so we cannot stop here. */
3114 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3115 /* If we found the info for all the codecs, we can stop. */
3117 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3122 /* We did not get all the codec info, but we read too much data. */
3123 if (read_size >= probesize) {
3125 av_log(ic, AV_LOG_DEBUG,
3126 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3127 for (i = 0; i < ic->nb_streams; i++)
3128 if (!ic->streams[i]->r_frame_rate.num &&
3129 ic->streams[i]->info->duration_count <= 1 &&
3130 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3131 strcmp(ic->iformat->name, "image2"))
3132 av_log(ic, AV_LOG_WARNING,
3133 "Stream #%d: not enough frames to estimate rate; "
3134 "consider increasing probesize\n", i);
3138 /* NOTE: A new stream can be added there if no header in file
3139 * (AVFMTCTX_NOHEADER). */
3140 ret = read_frame_internal(ic, &pkt1);
3141 if (ret == AVERROR(EAGAIN))
3149 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3150 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3152 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3153 &ic->packet_buffer_end);
3155 ret = AVERROR(ENOMEM);
3156 goto find_stream_info_err;
3158 if ((ret = av_dup_packet(pkt)) < 0)
3159 goto find_stream_info_err;
3162 st = ic->streams[pkt->stream_index];
3163 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3164 read_size += pkt->size;
3166 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3167 /* check for non-increasing dts */
3168 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3169 st->info->fps_last_dts >= pkt->dts) {
3170 av_log(ic, AV_LOG_DEBUG,
3171 "Non-increasing DTS in stream %d: packet %d with DTS "
3172 "%"PRId64", packet %d with DTS %"PRId64"\n",
3173 st->index, st->info->fps_last_dts_idx,
3174 st->info->fps_last_dts, st->codec_info_nb_frames,
3176 st->info->fps_first_dts =
3177 st->info->fps_last_dts = AV_NOPTS_VALUE;
3179 /* Check for a discontinuity in dts. If the difference in dts
3180 * is more than 1000 times the average packet duration in the
3181 * sequence, we treat it as a discontinuity. */
3182 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3183 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3184 (pkt->dts - st->info->fps_last_dts) / 1000 >
3185 (st->info->fps_last_dts - st->info->fps_first_dts) /
3186 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3187 av_log(ic, AV_LOG_WARNING,
3188 "DTS discontinuity in stream %d: packet %d with DTS "
3189 "%"PRId64", packet %d with DTS %"PRId64"\n",
3190 st->index, st->info->fps_last_dts_idx,
3191 st->info->fps_last_dts, st->codec_info_nb_frames,
3193 st->info->fps_first_dts =
3194 st->info->fps_last_dts = AV_NOPTS_VALUE;
3197 /* update stored dts values */
3198 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3199 st->info->fps_first_dts = pkt->dts;
3200 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3202 st->info->fps_last_dts = pkt->dts;
3203 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3205 if (st->codec_info_nb_frames>1) {
3208 if (st->time_base.den > 0)
3209 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3210 if (st->avg_frame_rate.num > 0)
3211 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3214 && st->codec_info_nb_frames>30
3215 && st->info->fps_first_dts != AV_NOPTS_VALUE
3216 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3217 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3219 if (t >= max_analyze_duration) {
3220 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3221 max_analyze_duration,
3223 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3224 av_packet_unref(pkt);
3227 if (pkt->duration) {
3228 st->info->codec_info_duration += pkt->duration;
3229 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3232 #if FF_API_R_FRAME_RATE
3233 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3234 ff_rfps_add_frame(ic, st, pkt->dts);
3236 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3237 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3238 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3239 if (ff_alloc_extradata(st->codec, i))
3240 return AVERROR(ENOMEM);
3241 memcpy(st->codec->extradata, pkt->data,
3242 st->codec->extradata_size);
3246 /* If still no information, we try to open the codec and to
3247 * decompress the frame. We try to avoid that in most cases as
3248 * it takes longer and uses more memory. For MPEG-4, we need to
3249 * decompress for QuickTime.
3251 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3252 * least one frame of codec data, this makes sure the codec initializes
3253 * the channel configuration and does not only trust the values from
3255 try_decode_frame(ic, st, pkt,
3256 (options && i < orig_nb_streams) ? &options[i] : NULL);
3258 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3259 av_packet_unref(pkt);
3261 st->codec_info_nb_frames++;
3266 AVPacket empty_pkt = { 0 };
3268 av_init_packet(&empty_pkt);
3270 for (i = 0; i < ic->nb_streams; i++) {
3272 st = ic->streams[i];
3274 /* flush the decoders */
3275 if (st->info->found_decoder == 1) {
3277 err = try_decode_frame(ic, st, &empty_pkt,
3278 (options && i < orig_nb_streams)
3279 ? &options[i] : NULL);
3280 } while (err > 0 && !has_codec_parameters(st, NULL));
3283 av_log(ic, AV_LOG_INFO,
3284 "decoding for stream %d failed\n", st->index);
3289 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3291 // close codecs which were opened in try_decode_frame()
3292 for (i = 0; i < ic->nb_streams; i++) {
3293 st = ic->streams[i];
3294 avcodec_close(st->codec);
3297 ff_rfps_calculate(ic);
3299 for (i = 0; i < ic->nb_streams; i++) {
3300 st = ic->streams[i];
3301 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3302 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3303 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3304 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3305 st->codec->codec_tag= tag;
3308 /* estimate average framerate if not set by demuxer */
3309 if (st->info->codec_info_duration_fields &&
3310 !st->avg_frame_rate.num &&
3311 st->info->codec_info_duration) {
3313 double best_error = 0.01;
3315 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3316 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3317 st->info->codec_info_duration < 0)
3319 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3320 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3321 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3323 /* Round guessed framerate to a "standard" framerate if it's
3324 * within 1% of the original estimate. */
3325 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3326 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3327 double error = fabs(av_q2d(st->avg_frame_rate) /
3328 av_q2d(std_fps) - 1);
3330 if (error < best_error) {
3332 best_fps = std_fps.num;
3336 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3337 best_fps, 12 * 1001, INT_MAX);
3340 if (!st->r_frame_rate.num) {
3341 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3342 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3343 st->r_frame_rate.num = st->codec->time_base.den;
3344 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3346 st->r_frame_rate.num = st->time_base.den;
3347 st->r_frame_rate.den = st->time_base.num;
3350 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3351 if (!st->codec->bits_per_coded_sample)
3352 st->codec->bits_per_coded_sample =
3353 av_get_bits_per_sample(st->codec->codec_id);
3354 // set stream disposition based on audio service type
3355 switch (st->codec->audio_service_type) {
3356 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3357 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3359 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3360 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3362 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3363 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3365 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3366 st->disposition = AV_DISPOSITION_COMMENT;
3368 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3369 st->disposition = AV_DISPOSITION_KARAOKE;
3376 estimate_timings(ic, old_offset);
3378 if (ret >= 0 && ic->nb_streams)
3379 /* We could not have all the codec parameters before EOF. */
3381 for (i = 0; i < ic->nb_streams; i++) {
3383 st = ic->streams[i];
3384 if (!has_codec_parameters(st, &errmsg)) {
3386 avcodec_string(buf, sizeof(buf), st->codec, 0);
3387 av_log(ic, AV_LOG_WARNING,
3388 "Could not find codec parameters for stream %d (%s): %s\n"
3389 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3396 compute_chapters_end(ic);
3398 find_stream_info_err:
3399 for (i = 0; i < ic->nb_streams; i++) {
3400 st = ic->streams[i];
3401 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3402 ic->streams[i]->codec->thread_count = 0;
3404 av_freep(&st->info->duration_error);
3405 av_freep(&ic->streams[i]->info);
3408 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3409 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3413 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3417 for (i = 0; i < ic->nb_programs; i++) {
3418 if (ic->programs[i] == last) {
3422 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3423 if (ic->programs[i]->stream_index[j] == s)
3424 return ic->programs[i];
3430 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3431 int wanted_stream_nb, int related_stream,
3432 AVCodec **decoder_ret, int flags)
3434 int i, nb_streams = ic->nb_streams;
3435 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3436 unsigned *program = NULL;
3437 const AVCodec *decoder = NULL, *best_decoder = NULL;
3439 if (related_stream >= 0 && wanted_stream_nb < 0) {
3440 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3442 program = p->stream_index;
3443 nb_streams = p->nb_stream_indexes;
3446 for (i = 0; i < nb_streams; i++) {
3447 int real_stream_index = program ? program[i] : i;
3448 AVStream *st = ic->streams[real_stream_index];
3449 AVCodecContext *avctx = st->codec;
3450 if (avctx->codec_type != type)
3452 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3454 if (wanted_stream_nb != real_stream_index &&
3455 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3456 AV_DISPOSITION_VISUAL_IMPAIRED))
3458 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3461 decoder = find_decoder(ic, st, st->codec->codec_id);
3464 ret = AVERROR_DECODER_NOT_FOUND;
3468 count = st->codec_info_nb_frames;
3469 bitrate = avctx->bit_rate;
3471 bitrate = avctx->rc_max_rate;
3472 multiframe = FFMIN(5, count);
3473 if ((best_multiframe > multiframe) ||
3474 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3475 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3478 best_bitrate = bitrate;
3479 best_multiframe = multiframe;
3480 ret = real_stream_index;
3481 best_decoder = decoder;
3482 if (program && i == nb_streams - 1 && ret < 0) {
3484 nb_streams = ic->nb_streams;
3485 /* no related stream found, try again with everything */
3490 *decoder_ret = (AVCodec*)best_decoder;
3494 /*******************************************************/
3496 int av_read_play(AVFormatContext *s)
3498 if (s->iformat->read_play)
3499 return s->iformat->read_play(s);
3501 return avio_pause(s->pb, 0);
3502 return AVERROR(ENOSYS);
3505 int av_read_pause(AVFormatContext *s)
3507 if (s->iformat->read_pause)
3508 return s->iformat->read_pause(s);
3510 return avio_pause(s->pb, 1);
3511 return AVERROR(ENOSYS);
3514 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3516 av_assert0(s->nb_streams>0);
3517 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3519 for (j = 0; j < st->nb_side_data; j++)
3520 av_freep(&st->side_data[j].data);
3521 av_freep(&st->side_data);
3522 st->nb_side_data = 0;
3525 av_parser_close(st->parser);
3527 if (st->attached_pic.data)
3528 av_free_packet(&st->attached_pic);
3529 av_dict_free(&st->metadata);
3530 av_freep(&st->probe_data.buf);
3531 av_freep(&st->index_entries);
3532 av_freep(&st->codec->extradata);
3533 av_freep(&st->codec->subtitle_header);
3534 av_freep(&st->codec);
3535 av_freep(&st->priv_data);
3537 av_freep(&st->info->duration_error);
3538 av_freep(&st->info);
3539 av_freep(&s->streams[ --s->nb_streams ]);
3542 void avformat_free_context(AVFormatContext *s)
3550 if (s->iformat && s->iformat->priv_class && s->priv_data)
3551 av_opt_free(s->priv_data);
3552 if (s->oformat && s->oformat->priv_class && s->priv_data)
3553 av_opt_free(s->priv_data);
3555 for (i = s->nb_streams - 1; i >= 0; i--) {
3556 ff_free_stream(s, s->streams[i]);
3558 for (i = s->nb_programs - 1; i >= 0; i--) {
3559 av_dict_free(&s->programs[i]->metadata);
3560 av_freep(&s->programs[i]->stream_index);
3561 av_freep(&s->programs[i]);
3563 av_freep(&s->programs);
3564 av_freep(&s->priv_data);
3565 while (s->nb_chapters--) {
3566 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3567 av_freep(&s->chapters[s->nb_chapters]);
3569 av_freep(&s->chapters);
3570 av_dict_free(&s->metadata);
3571 av_freep(&s->streams);
3572 av_freep(&s->internal);
3573 flush_packet_queue(s);
3577 void avformat_close_input(AVFormatContext **ps)
3588 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3589 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3592 flush_packet_queue(s);
3595 if (s->iformat->read_close)
3596 s->iformat->read_close(s);
3598 avformat_free_context(s);
3605 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3611 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3613 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3616 s->streams = streams;
3618 st = av_mallocz(sizeof(AVStream));
3621 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3625 st->info->last_dts = AV_NOPTS_VALUE;
3627 st->codec = avcodec_alloc_context3(c);
3629 /* no default bitrate if decoding */
3630 st->codec->bit_rate = 0;
3632 /* default pts setting is MPEG-like */
3633 avpriv_set_pts_info(st, 33, 1, 90000);
3636 st->index = s->nb_streams;
3637 st->start_time = AV_NOPTS_VALUE;
3638 st->duration = AV_NOPTS_VALUE;
3639 /* we set the current DTS to 0 so that formats without any timestamps
3640 * but durations get some timestamps, formats with some unknown
3641 * timestamps have their first few packets buffered and the
3642 * timestamps corrected before they are returned to the user */
3643 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3644 st->first_dts = AV_NOPTS_VALUE;
3645 st->probe_packets = MAX_PROBE_PACKETS;
3646 st->pts_wrap_reference = AV_NOPTS_VALUE;
3647 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3649 st->last_IP_pts = AV_NOPTS_VALUE;
3650 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3651 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3652 st->pts_buffer[i] = AV_NOPTS_VALUE;
3654 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3656 #if FF_API_R_FRAME_RATE
3657 st->info->last_dts = AV_NOPTS_VALUE;
3659 st->info->fps_first_dts = AV_NOPTS_VALUE;
3660 st->info->fps_last_dts = AV_NOPTS_VALUE;
3662 st->inject_global_side_data = s->internal->inject_global_side_data;
3664 s->streams[s->nb_streams++] = st;
3668 AVProgram *av_new_program(AVFormatContext *ac, int id)
3670 AVProgram *program = NULL;
3673 av_dlog(ac, "new_program: id=0x%04x\n", id);
3675 for (i = 0; i < ac->nb_programs; i++)
3676 if (ac->programs[i]->id == id)
3677 program = ac->programs[i];
3680 program = av_mallocz(sizeof(AVProgram));
3683 dynarray_add(&ac->programs, &ac->nb_programs, program);
3684 program->discard = AVDISCARD_NONE;
3687 program->pts_wrap_reference = AV_NOPTS_VALUE;
3688 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3690 program->start_time =
3691 program->end_time = AV_NOPTS_VALUE;
3696 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3697 int64_t start, int64_t end, const char *title)
3699 AVChapter *chapter = NULL;
3702 if (end != AV_NOPTS_VALUE && start > end) {
3703 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3707 for (i = 0; i < s->nb_chapters; i++)
3708 if (s->chapters[i]->id == id)
3709 chapter = s->chapters[i];
3712 chapter = av_mallocz(sizeof(AVChapter));
3715 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3717 av_dict_set(&chapter->metadata, "title", title, 0);
3719 chapter->time_base = time_base;
3720 chapter->start = start;
3726 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3729 AVProgram *program = NULL;
3732 if (idx >= ac->nb_streams) {
3733 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3737 for (i = 0; i < ac->nb_programs; i++) {
3738 if (ac->programs[i]->id != progid)
3740 program = ac->programs[i];
3741 for (j = 0; j < program->nb_stream_indexes; j++)
3742 if (program->stream_index[j] == idx)
3745 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3748 program->stream_index = tmp;
3749 program->stream_index[program->nb_stream_indexes++] = idx;
3754 uint64_t ff_ntp_time(void)
3756 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3759 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3762 char *q, buf1[20], c;
3763 int nd, len, percentd_found;
3775 while (av_isdigit(*p))
3776 nd = nd * 10 + *p++ - '0';
3778 } while (av_isdigit(c));
3787 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3789 if ((q - buf + len) > buf_size - 1)
3791 memcpy(q, buf1, len);
3799 if ((q - buf) < buf_size - 1)
3803 if (!percentd_found)
3812 void av_url_split(char *proto, int proto_size,
3813 char *authorization, int authorization_size,
3814 char *hostname, int hostname_size,
3815 int *port_ptr, char *path, int path_size, const char *url)
3817 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3823 if (authorization_size > 0)
3824 authorization[0] = 0;
3825 if (hostname_size > 0)
3830 /* parse protocol */
3831 if ((p = strchr(url, ':'))) {
3832 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3839 /* no protocol means plain filename */
3840 av_strlcpy(path, url, path_size);
3844 /* separate path from hostname */
3845 ls = strchr(p, '/');
3846 ls2 = strchr(p, '?');
3850 ls = FFMIN(ls, ls2);
3852 av_strlcpy(path, ls, path_size);
3854 ls = &p[strlen(p)]; // XXX
3856 /* the rest is hostname, use that to parse auth/port */
3858 /* authorization (user[:pass]@hostname) */
3860 while ((at = strchr(p, '@')) && at < ls) {
3861 av_strlcpy(authorization, at2,
3862 FFMIN(authorization_size, at + 1 - at2));
3863 p = at + 1; /* skip '@' */
3866 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3868 av_strlcpy(hostname, p + 1,
3869 FFMIN(hostname_size, brk - p));
3870 if (brk[1] == ':' && port_ptr)
3871 *port_ptr = atoi(brk + 2);
3872 } else if ((col = strchr(p, ':')) && col < ls) {
3873 av_strlcpy(hostname, p,
3874 FFMIN(col + 1 - p, hostname_size));
3876 *port_ptr = atoi(col + 1);
3878 av_strlcpy(hostname, p,
3879 FFMIN(ls + 1 - p, hostname_size));
3883 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3886 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3889 'C', 'D', 'E', 'F' };
3890 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3893 'c', 'd', 'e', 'f' };
3894 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3896 for (i = 0; i < s; i++) {
3897 buff[i * 2] = hex_table[src[i] >> 4];
3898 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3904 int ff_hex_to_data(uint8_t *data, const char *p)
3911 p += strspn(p, SPACE_CHARS);
3914 c = av_toupper((unsigned char) *p++);
3915 if (c >= '0' && c <= '9')
3917 else if (c >= 'A' && c <= 'F')
3932 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3933 unsigned int pts_num, unsigned int pts_den)
3936 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3937 if (new_tb.num != pts_num)
3938 av_log(NULL, AV_LOG_DEBUG,
3939 "st:%d removing common factor %d from timebase\n",
3940 s->index, pts_num / new_tb.num);
3942 av_log(NULL, AV_LOG_WARNING,
3943 "st:%d has too large timebase, reducing\n", s->index);
3945 if (new_tb.num <= 0 || new_tb.den <= 0) {
3946 av_log(NULL, AV_LOG_ERROR,
3947 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3948 new_tb.num, new_tb.den,
3952 s->time_base = new_tb;
3953 av_codec_set_pkt_timebase(s->codec, new_tb);
3954 s->pts_wrap_bits = pts_wrap_bits;
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 && (av_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 && !(av_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)
4020 int64_t ff_iso8601_to_unix_time(const char *datestr)
4022 struct tm time1 = { 0 }, time2 = { 0 };
4024 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4025 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4027 return av_timegm(&time2);
4029 return av_timegm(&time1);
4032 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4036 if (ofmt->query_codec)
4037 return ofmt->query_codec(codec_id, std_compliance);
4038 else if (ofmt->codec_tag)
4039 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4040 else if (codec_id == ofmt->video_codec ||
4041 codec_id == ofmt->audio_codec ||
4042 codec_id == ofmt->subtitle_codec)
4045 return AVERROR_PATCHWELCOME;
4048 int avformat_network_init(void)
4052 ff_network_inited_globally = 1;
4053 if ((ret = ff_network_init()) < 0)
4060 int avformat_network_deinit(void)
4069 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4070 uint64_t channel_layout, int32_t sample_rate,
4071 int32_t width, int32_t height)
4077 return AVERROR(EINVAL);
4080 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4082 if (channel_layout) {
4084 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4088 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4090 if (width || height) {
4092 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4094 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4096 return AVERROR(ENOMEM);
4097 bytestream_put_le32(&data, flags);
4099 bytestream_put_le32(&data, channels);
4101 bytestream_put_le64(&data, channel_layout);
4103 bytestream_put_le32(&data, sample_rate);
4104 if (width || height) {
4105 bytestream_put_le32(&data, width);
4106 bytestream_put_le32(&data, height);
4111 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4113 AVRational undef = {0, 1};
4114 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4115 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4116 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4118 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4119 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4120 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4121 stream_sample_aspect_ratio = undef;
4123 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4124 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4125 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4126 frame_sample_aspect_ratio = undef;
4128 if (stream_sample_aspect_ratio.num)
4129 return stream_sample_aspect_ratio;
4131 return frame_sample_aspect_ratio;
4134 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4136 AVRational fr = st->r_frame_rate;
4137 AVRational codec_fr = st->codec->framerate;
4138 AVRational avg_fr = st->avg_frame_rate;
4140 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4141 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4146 if (st->codec->ticks_per_frame > 1) {
4147 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4148 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4155 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4158 if (*spec <= '9' && *spec >= '0') /* opt:index */
4159 return strtol(spec, NULL, 0) == st->index;
4160 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4161 *spec == 't') { /* opt:[vasdt] */
4162 enum AVMediaType type;
4165 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4166 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4167 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4168 case 'd': type = AVMEDIA_TYPE_DATA; break;
4169 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4170 default: av_assert0(0);
4172 if (type != st->codec->codec_type)
4174 if (*spec++ == ':') { /* possibly followed by :index */
4175 int i, index = strtol(spec, NULL, 0);
4176 for (i = 0; i < s->nb_streams; i++)
4177 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4178 return i == st->index;
4182 } else if (*spec == 'p' && *(spec + 1) == ':') {
4186 prog_id = strtol(spec, &endptr, 0);
4187 for (i = 0; i < s->nb_programs; i++) {
4188 if (s->programs[i]->id != prog_id)
4191 if (*endptr++ == ':') {
4192 int stream_idx = strtol(endptr, NULL, 0);
4193 return stream_idx >= 0 &&
4194 stream_idx < s->programs[i]->nb_stream_indexes &&
4195 st->index == s->programs[i]->stream_index[stream_idx];
4198 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4199 if (st->index == s->programs[i]->stream_index[j])
4203 } else if (*spec == '#' ||
4204 (*spec == 'i' && *(spec + 1) == ':')) {
4207 spec += 1 + (*spec == 'i');
4208 stream_id = strtol(spec, &endptr, 0);
4210 return stream_id == st->id;
4211 } else if (*spec == 'm' && *(spec + 1) == ':') {
4212 AVDictionaryEntry *tag;
4217 val = strchr(spec, ':');
4219 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4221 return AVERROR(ENOMEM);
4223 tag = av_dict_get(st->metadata, key, NULL, 0);
4225 if (!val || !strcmp(tag->value, val + 1))
4234 } else if (!*spec) /* empty specifier, matches everything */
4237 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4238 return AVERROR(EINVAL);
4241 int ff_generate_avci_extradata(AVStream *st)
4243 static const uint8_t avci100_1080p_extradata[] = {
4245 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4246 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4247 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4248 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4249 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4250 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4251 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4252 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4253 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4255 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4258 static const uint8_t avci100_1080i_extradata[] = {
4260 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4261 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4262 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4263 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4264 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4265 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4266 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4267 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4268 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4269 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4270 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4272 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4275 static const uint8_t avci50_1080p_extradata[] = {
4277 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4278 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4279 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4280 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4281 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4282 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4283 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4284 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4285 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4287 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4290 static const uint8_t avci50_1080i_extradata[] = {
4292 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4293 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4294 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4295 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4296 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4297 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4298 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4299 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4300 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4301 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4302 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4304 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4307 static const uint8_t avci100_720p_extradata[] = {
4309 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4310 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4311 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4312 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4313 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4314 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4315 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4316 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4317 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4318 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4320 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4323 static const uint8_t avci50_720p_extradata[] = {
4325 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4326 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4327 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4328 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4329 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4330 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4331 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4332 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4333 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4335 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4339 const uint8_t *data = NULL;
4342 if (st->codec->width == 1920) {
4343 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4344 data = avci100_1080p_extradata;
4345 size = sizeof(avci100_1080p_extradata);
4347 data = avci100_1080i_extradata;
4348 size = sizeof(avci100_1080i_extradata);
4350 } else if (st->codec->width == 1440) {
4351 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4352 data = avci50_1080p_extradata;
4353 size = sizeof(avci50_1080p_extradata);
4355 data = avci50_1080i_extradata;
4356 size = sizeof(avci50_1080i_extradata);
4358 } else if (st->codec->width == 1280) {
4359 data = avci100_720p_extradata;
4360 size = sizeof(avci100_720p_extradata);
4361 } else if (st->codec->width == 960) {
4362 data = avci50_720p_extradata;
4363 size = sizeof(avci50_720p_extradata);
4369 av_freep(&st->codec->extradata);
4370 if (ff_alloc_extradata(st->codec, size))
4371 return AVERROR(ENOMEM);
4372 memcpy(st->codec->extradata, data, size);
4377 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4382 for (i = 0; i < st->nb_side_data; i++) {
4383 if (st->side_data[i].type == type) {
4385 *size = st->side_data[i].size;
4386 return st->side_data[i].data;