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(AVStream, stream, char *, recommended_encoder_configuration)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
110 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
111 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
112 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
114 int64_t av_stream_get_end_pts(const AVStream *st)
119 struct AVCodecParserContext *av_stream_get_parser(const AVStream *st)
124 void av_format_inject_global_side_data(AVFormatContext *s)
127 s->internal->inject_global_side_data = 1;
128 for (i = 0; i < s->nb_streams; i++) {
129 AVStream *st = s->streams[i];
130 st->inject_global_side_data = 1;
134 int ff_copy_whitelists(AVFormatContext *dst, AVFormatContext *src)
136 av_assert0(!dst->codec_whitelist && !dst->format_whitelist);
137 dst-> codec_whitelist = av_strdup(src->codec_whitelist);
138 dst->format_whitelist = av_strdup(src->format_whitelist);
139 if ( (src-> codec_whitelist && !dst-> codec_whitelist)
140 || (src->format_whitelist && !dst->format_whitelist)) {
141 av_log(dst, AV_LOG_ERROR, "Failed to duplicate whitelist\n");
142 return AVERROR(ENOMEM);
147 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
149 if (st->codec->codec)
150 return st->codec->codec;
152 switch (st->codec->codec_type) {
153 case AVMEDIA_TYPE_VIDEO:
154 if (s->video_codec) return s->video_codec;
156 case AVMEDIA_TYPE_AUDIO:
157 if (s->audio_codec) return s->audio_codec;
159 case AVMEDIA_TYPE_SUBTITLE:
160 if (s->subtitle_codec) return s->subtitle_codec;
164 return avcodec_find_decoder(codec_id);
167 int av_format_get_probe_score(const AVFormatContext *s)
169 return s->probe_score;
172 /* an arbitrarily chosen "sane" max packet size -- 50M */
173 #define SANE_CHUNK_SIZE (50000000)
175 int ffio_limit(AVIOContext *s, int size)
177 if (s->maxsize>= 0) {
178 int64_t remaining= s->maxsize - avio_tell(s);
179 if (remaining < size) {
180 int64_t newsize = avio_size(s);
181 if (!s->maxsize || s->maxsize<newsize)
182 s->maxsize = newsize - !newsize;
183 remaining= s->maxsize - avio_tell(s);
184 remaining= FFMAX(remaining, 0);
187 if (s->maxsize>= 0 && remaining+1 < size) {
188 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
195 /* Read the data in sane-sized chunks and append to pkt.
196 * Return the number of bytes read or an error. */
197 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
199 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
200 int orig_size = pkt->size;
204 int prev_size = pkt->size;
207 /* When the caller requests a lot of data, limit it to the amount
208 * left in file or SANE_CHUNK_SIZE when it is not known. */
210 if (read_size > SANE_CHUNK_SIZE/10) {
211 read_size = ffio_limit(s, read_size);
212 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
214 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
217 ret = av_grow_packet(pkt, read_size);
221 ret = avio_read(s, pkt->data + prev_size, read_size);
222 if (ret != read_size) {
223 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
230 pkt->flags |= AV_PKT_FLAG_CORRUPT;
235 return pkt->size > orig_size ? pkt->size - orig_size : ret;
238 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
243 pkt->pos = avio_tell(s);
245 return append_packet_chunked(s, pkt, size);
248 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
251 return av_get_packet(s, pkt, size);
252 return append_packet_chunked(s, pkt, size);
255 int av_filename_number_test(const char *filename)
259 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
262 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
265 static const struct {
268 enum AVMediaType type;
270 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
271 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
272 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
273 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
274 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
275 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
276 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
277 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
278 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
279 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
283 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
285 if (fmt && st->request_probe <= score) {
287 av_log(s, AV_LOG_DEBUG,
288 "Probe with size=%d, packets=%d detected %s with score=%d\n",
289 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
291 for (i = 0; fmt_id_type[i].name; i++) {
292 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
293 st->codec->codec_id = fmt_id_type[i].id;
294 st->codec->codec_type = fmt_id_type[i].type;
302 /************************************************************/
303 /* input media file */
305 int av_demuxer_open(AVFormatContext *ic) {
308 if (ic->format_whitelist && av_match_list(ic->iformat->name, ic->format_whitelist, ',') <= 0) {
309 av_log(ic, AV_LOG_ERROR, "Format not on whitelist\n");
310 return AVERROR(EINVAL);
313 if (ic->iformat->read_header) {
314 err = ic->iformat->read_header(ic);
319 if (ic->pb && !ic->data_offset)
320 ic->data_offset = avio_tell(ic->pb);
325 /* Open input file and probe the format if necessary. */
326 static int init_input(AVFormatContext *s, const char *filename,
327 AVDictionary **options)
330 AVProbeData pd = { filename, NULL, 0 };
331 int score = AVPROBE_SCORE_RETRY;
334 s->flags |= AVFMT_FLAG_CUSTOM_IO;
336 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
337 s, 0, s->format_probesize);
338 else if (s->iformat->flags & AVFMT_NOFILE)
339 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
340 "will be ignored with AVFMT_NOFILE format.\n");
344 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
345 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
348 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
349 &s->interrupt_callback, options)) < 0)
353 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
354 s, 0, s->format_probesize);
357 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
358 AVPacketList **plast_pktl)
360 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
365 (*plast_pktl)->next = pktl;
367 *packet_buffer = pktl;
369 /* Add the packet in the buffered packet list. */
375 int avformat_queue_attached_pictures(AVFormatContext *s)
378 for (i = 0; i < s->nb_streams; i++)
379 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
380 s->streams[i]->discard < AVDISCARD_ALL) {
381 AVPacket copy = s->streams[i]->attached_pic;
382 if (copy.size <= 0) {
383 av_log(s, AV_LOG_WARNING,
384 "Attached picture on stream %d has invalid size, "
388 copy.buf = av_buffer_ref(copy.buf);
390 return AVERROR(ENOMEM);
392 add_to_pktbuf(&s->raw_packet_buffer, ©,
393 &s->raw_packet_buffer_end);
398 int avformat_open_input(AVFormatContext **ps, const char *filename,
399 AVInputFormat *fmt, AVDictionary **options)
401 AVFormatContext *s = *ps;
403 AVDictionary *tmp = NULL;
404 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
406 if (!s && !(s = avformat_alloc_context()))
407 return AVERROR(ENOMEM);
409 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
410 return AVERROR(EINVAL);
416 av_dict_copy(&tmp, *options, 0);
418 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
421 if ((ret = init_input(s, filename, &tmp)) < 0)
423 s->probe_score = ret;
425 if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) {
426 av_log(s, AV_LOG_ERROR, "Format not on whitelist\n");
427 ret = AVERROR(EINVAL);
431 avio_skip(s->pb, s->skip_initial_bytes);
433 /* Check filename in case an image number is expected. */
434 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
435 if (!av_filename_number_test(filename)) {
436 ret = AVERROR(EINVAL);
441 s->duration = s->start_time = AV_NOPTS_VALUE;
442 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
444 /* Allocate private data. */
445 if (s->iformat->priv_data_size > 0) {
446 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
447 ret = AVERROR(ENOMEM);
450 if (s->iformat->priv_class) {
451 *(const AVClass **) s->priv_data = s->iformat->priv_class;
452 av_opt_set_defaults(s->priv_data);
453 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
458 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
460 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
462 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
463 if ((ret = s->iformat->read_header(s)) < 0)
466 if (id3v2_extra_meta) {
467 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
468 !strcmp(s->iformat->name, "tta")) {
469 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
472 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
474 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
476 if ((ret = avformat_queue_attached_pictures(s)) < 0)
479 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
480 s->data_offset = avio_tell(s->pb);
482 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
485 av_dict_free(options);
492 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
494 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
496 avformat_free_context(s);
501 /*******************************************************/
503 static void force_codec_ids(AVFormatContext *s, AVStream *st)
505 switch (st->codec->codec_type) {
506 case AVMEDIA_TYPE_VIDEO:
507 if (s->video_codec_id)
508 st->codec->codec_id = s->video_codec_id;
510 case AVMEDIA_TYPE_AUDIO:
511 if (s->audio_codec_id)
512 st->codec->codec_id = s->audio_codec_id;
514 case AVMEDIA_TYPE_SUBTITLE:
515 if (s->subtitle_codec_id)
516 st->codec->codec_id = s->subtitle_codec_id;
521 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
523 if (st->request_probe>0) {
524 AVProbeData *pd = &st->probe_data;
526 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
530 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
532 av_log(s, AV_LOG_WARNING,
533 "Failed to reallocate probe buffer for stream %d\n",
538 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
539 pd->buf_size += pkt->size;
540 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
543 st->probe_packets = 0;
545 av_log(s, AV_LOG_WARNING,
546 "nothing to probe for stream %d\n", st->index);
550 end= s->raw_packet_buffer_remaining_size <= 0
551 || st->probe_packets<= 0;
553 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
554 int score = set_codec_from_probe_data(s, st, pd);
555 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
559 st->request_probe = -1;
560 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
561 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
563 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
565 force_codec_ids(s, st);
571 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
573 int64_t ref = pkt->dts;
574 int i, pts_wrap_behavior;
575 int64_t pts_wrap_reference;
576 AVProgram *first_program;
578 if (ref == AV_NOPTS_VALUE)
580 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
582 ref &= (1LL << st->pts_wrap_bits)-1;
584 // reference time stamp should be 60 s before first time stamp
585 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
586 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
587 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
588 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
589 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
591 first_program = av_find_program_from_stream(s, NULL, stream_index);
593 if (!first_program) {
594 int default_stream_index = av_find_default_stream_index(s);
595 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
596 for (i = 0; i < s->nb_streams; i++) {
597 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
598 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
602 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
603 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
607 AVProgram *program = first_program;
609 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
610 pts_wrap_reference = program->pts_wrap_reference;
611 pts_wrap_behavior = program->pts_wrap_behavior;
614 program = av_find_program_from_stream(s, program, stream_index);
617 // update every program with differing pts_wrap_reference
618 program = first_program;
620 if (program->pts_wrap_reference != pts_wrap_reference) {
621 for (i = 0; i<program->nb_stream_indexes; i++) {
622 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
623 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
626 program->pts_wrap_reference = pts_wrap_reference;
627 program->pts_wrap_behavior = pts_wrap_behavior;
629 program = av_find_program_from_stream(s, program, stream_index);
635 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
641 AVPacketList *pktl = s->raw_packet_buffer;
645 st = s->streams[pkt->stream_index];
646 if (s->raw_packet_buffer_remaining_size <= 0)
647 if ((err = probe_codec(s, st, NULL)) < 0)
649 if (st->request_probe <= 0) {
650 s->raw_packet_buffer = pktl->next;
651 s->raw_packet_buffer_remaining_size += pkt->size;
660 ret = s->iformat->read_packet(s, pkt);
662 if (!pktl || ret == AVERROR(EAGAIN))
664 for (i = 0; i < s->nb_streams; i++) {
666 if (st->probe_packets)
667 if ((err = probe_codec(s, st, NULL)) < 0)
669 av_assert0(st->request_probe <= 0);
674 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
675 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
676 av_log(s, AV_LOG_WARNING,
677 "Dropped corrupted packet (stream = %d)\n",
683 if (pkt->stream_index >= (unsigned)s->nb_streams) {
684 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
688 st = s->streams[pkt->stream_index];
690 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
691 // correct first time stamps to negative values
692 if (!is_relative(st->first_dts))
693 st->first_dts = wrap_timestamp(st, st->first_dts);
694 if (!is_relative(st->start_time))
695 st->start_time = wrap_timestamp(st, st->start_time);
696 if (!is_relative(st->cur_dts))
697 st->cur_dts = wrap_timestamp(st, st->cur_dts);
700 pkt->dts = wrap_timestamp(st, pkt->dts);
701 pkt->pts = wrap_timestamp(st, pkt->pts);
703 force_codec_ids(s, st);
705 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
706 if (s->use_wallclock_as_timestamps)
707 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
709 if (!pktl && st->request_probe <= 0)
712 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
713 s->raw_packet_buffer_remaining_size -= pkt->size;
715 if ((err = probe_codec(s, st, pkt)) < 0)
721 /**********************************************************/
723 static int determinable_frame_size(AVCodecContext *avctx)
725 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
726 avctx->codec_id == AV_CODEC_ID_MP1 ||
727 avctx->codec_id == AV_CODEC_ID_MP2 ||
728 avctx->codec_id == AV_CODEC_ID_MP3/* ||
729 avctx->codec_id == AV_CODEC_ID_CELT*/)
735 * Return the frame duration in seconds. Return 0 if not available.
737 void ff_compute_frame_duration(AVFormatContext *s, int *pnum, int *pden, AVStream *st,
738 AVCodecParserContext *pc, AVPacket *pkt)
740 AVRational codec_framerate = s->iformat ? st->codec->framerate :
741 av_mul_q(av_inv_q(st->codec->time_base), (AVRational){1, st->codec->ticks_per_frame});
746 switch (st->codec->codec_type) {
747 case AVMEDIA_TYPE_VIDEO:
748 if (st->r_frame_rate.num && !pc) {
749 *pnum = st->r_frame_rate.den;
750 *pden = st->r_frame_rate.num;
751 } else if (st->time_base.num * 1000LL > st->time_base.den) {
752 *pnum = st->time_base.num;
753 *pden = st->time_base.den;
754 } else if (codec_framerate.den * 1000LL > codec_framerate.num) {
755 av_assert0(st->codec->ticks_per_frame);
756 av_reduce(pnum, pden,
758 codec_framerate.num * (int64_t)st->codec->ticks_per_frame,
761 if (pc && pc->repeat_pict) {
762 av_assert0(s->iformat); // this may be wrong for interlaced encoding but its not used for that case
763 av_reduce(pnum, pden,
764 (*pnum) * (1LL + pc->repeat_pict),
768 /* If this codec can be interlaced or progressive then we need
769 * a parser to compute duration of a packet. Thus if we have
770 * no parser in such case leave duration undefined. */
771 if (st->codec->ticks_per_frame > 1 && !pc)
775 case AVMEDIA_TYPE_AUDIO:
776 frame_size = av_get_audio_frame_duration(st->codec, pkt->size);
777 if (frame_size <= 0 || st->codec->sample_rate <= 0)
780 *pden = st->codec->sample_rate;
787 static int is_intra_only(AVCodecContext *enc) {
788 const AVCodecDescriptor *desc;
790 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
793 desc = av_codec_get_codec_descriptor(enc);
795 desc = avcodec_descriptor_get(enc->codec_id);
796 av_codec_set_codec_descriptor(enc, desc);
799 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
803 static int has_decode_delay_been_guessed(AVStream *st)
805 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
806 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
808 #if CONFIG_H264_DECODER
809 if (st->codec->has_b_frames &&
810 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
813 if (st->codec->has_b_frames<3)
814 return st->nb_decoded_frames >= 7;
815 else if (st->codec->has_b_frames<4)
816 return st->nb_decoded_frames >= 18;
818 return st->nb_decoded_frames >= 20;
821 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
825 if (pktl == s->packet_buffer_end)
826 return s->parse_queue;
830 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
831 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
832 st->codec->codec_id != AV_CODEC_ID_HEVC;
835 int delay = st->codec->has_b_frames;
838 if (dts == AV_NOPTS_VALUE) {
839 int64_t best_score = INT64_MAX;
840 for (i = 0; i<delay; i++) {
841 if (st->pts_reorder_error_count[i]) {
842 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
843 if (score < best_score) {
850 for (i = 0; i<delay; i++) {
851 if (pts_buffer[i] != AV_NOPTS_VALUE) {
852 int64_t diff = FFABS(pts_buffer[i] - dts)
853 + (uint64_t)st->pts_reorder_error[i];
854 diff = FFMAX(diff, st->pts_reorder_error[i]);
855 st->pts_reorder_error[i] = diff;
856 st->pts_reorder_error_count[i]++;
857 if (st->pts_reorder_error_count[i] > 250) {
858 st->pts_reorder_error[i] >>= 1;
859 st->pts_reorder_error_count[i] >>= 1;
866 if (dts == AV_NOPTS_VALUE)
872 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
873 int64_t dts, int64_t pts, AVPacket *pkt)
875 AVStream *st = s->streams[stream_index];
876 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
877 int64_t pts_buffer[MAX_REORDER_DELAY+1];
881 if (st->first_dts != AV_NOPTS_VALUE ||
882 dts == AV_NOPTS_VALUE ||
883 st->cur_dts == AV_NOPTS_VALUE ||
887 delay = st->codec->has_b_frames;
888 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
890 shift = st->first_dts - RELATIVE_TS_BASE;
892 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
893 pts_buffer[i] = AV_NOPTS_VALUE;
895 if (is_relative(pts))
898 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
899 if (pktl->pkt.stream_index != stream_index)
901 if (is_relative(pktl->pkt.pts))
902 pktl->pkt.pts += shift;
904 if (is_relative(pktl->pkt.dts))
905 pktl->pkt.dts += shift;
907 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
908 st->start_time = pktl->pkt.pts;
910 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
911 pts_buffer[0] = pktl->pkt.pts;
912 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
913 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
915 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
919 if (st->start_time == AV_NOPTS_VALUE)
920 st->start_time = pts;
923 static void update_initial_durations(AVFormatContext *s, AVStream *st,
924 int stream_index, int duration)
926 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
927 int64_t cur_dts = RELATIVE_TS_BASE;
929 if (st->first_dts != AV_NOPTS_VALUE) {
930 if (st->update_initial_durations_done)
932 st->update_initial_durations_done = 1;
933 cur_dts = st->first_dts;
934 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
935 if (pktl->pkt.stream_index == stream_index) {
936 if (pktl->pkt.pts != pktl->pkt.dts ||
937 pktl->pkt.dts != AV_NOPTS_VALUE ||
943 if (pktl && pktl->pkt.dts != st->first_dts) {
944 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
945 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
949 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
952 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
953 st->first_dts = cur_dts;
954 } else if (st->cur_dts != RELATIVE_TS_BASE)
957 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
958 if (pktl->pkt.stream_index != stream_index)
960 if (pktl->pkt.pts == pktl->pkt.dts &&
961 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
962 !pktl->pkt.duration) {
963 pktl->pkt.dts = cur_dts;
964 if (!st->codec->has_b_frames)
965 pktl->pkt.pts = cur_dts;
966 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
967 pktl->pkt.duration = duration;
970 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
973 st->cur_dts = cur_dts;
976 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
977 AVCodecParserContext *pc, AVPacket *pkt,
978 int64_t next_dts, int64_t next_pts)
980 int num, den, presentation_delayed, delay, i;
983 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
984 st->codec->codec_id != AV_CODEC_ID_HEVC;
986 if (s->flags & AVFMT_FLAG_NOFILLIN)
989 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
990 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
991 if (st->last_dts_for_order_check <= pkt->dts) {
994 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
995 "DTS %"PRIi64" < %"PRIi64" out of order\n",
997 st->last_dts_for_order_check);
998 st->dts_misordered++;
1000 if (st->dts_ordered + st->dts_misordered > 250) {
1001 st->dts_ordered >>= 1;
1002 st->dts_misordered >>= 1;
1006 st->last_dts_for_order_check = pkt->dts;
1007 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1008 pkt->dts = AV_NOPTS_VALUE;
1011 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1012 pkt->dts = AV_NOPTS_VALUE;
1014 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1015 && !st->codec->has_b_frames)
1016 //FIXME Set low_delay = 0 when has_b_frames = 1
1017 st->codec->has_b_frames = 1;
1019 /* do we have a video B-frame ? */
1020 delay = st->codec->has_b_frames;
1021 presentation_delayed = 0;
1023 /* XXX: need has_b_frame, but cannot get it if the codec is
1024 * not initialized */
1026 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1027 presentation_delayed = 1;
1029 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1030 st->pts_wrap_bits < 63 &&
1031 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1032 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1033 pkt->dts -= 1LL << st->pts_wrap_bits;
1035 pkt->pts += 1LL << st->pts_wrap_bits;
1038 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1039 * We take the conservative approach and discard both.
1040 * Note: If this is misbehaving for an H.264 file, then possibly
1041 * presentation_delayed is not set correctly. */
1042 if (delay == 1 && pkt->dts == pkt->pts &&
1043 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1044 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1045 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1046 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1047 pkt->dts = AV_NOPTS_VALUE;
1050 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1051 if (pkt->duration == 0) {
1052 ff_compute_frame_duration(s, &num, &den, st, pc, pkt);
1054 duration = (AVRational) {num, den};
1055 pkt->duration = av_rescale_rnd(1,
1056 num * (int64_t) st->time_base.den,
1057 den * (int64_t) st->time_base.num,
1062 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1063 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1065 /* Correct timestamps with byte offset if demuxers only have timestamps
1066 * on packet boundaries */
1067 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1068 /* this will estimate bitrate based on this frame's duration and size */
1069 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1070 if (pkt->pts != AV_NOPTS_VALUE)
1072 if (pkt->dts != AV_NOPTS_VALUE)
1076 /* This may be redundant, but it should not hurt. */
1077 if (pkt->dts != AV_NOPTS_VALUE &&
1078 pkt->pts != AV_NOPTS_VALUE &&
1079 pkt->pts > pkt->dts)
1080 presentation_delayed = 1;
1083 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d delay:%d onein_oneout:%d\n",
1084 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1085 pkt->stream_index, pc, pkt->duration, delay, onein_oneout);
1086 /* Interpolate PTS and DTS if they are not present. We skip H264
1087 * currently because delay and has_b_frames are not reliably set. */
1088 if ((delay == 0 || (delay == 1 && pc)) &&
1090 if (presentation_delayed) {
1091 /* DTS = decompression timestamp */
1092 /* PTS = presentation timestamp */
1093 if (pkt->dts == AV_NOPTS_VALUE)
1094 pkt->dts = st->last_IP_pts;
1095 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1096 if (pkt->dts == AV_NOPTS_VALUE)
1097 pkt->dts = st->cur_dts;
1099 /* This is tricky: the dts must be incremented by the duration
1100 * of the frame we are displaying, i.e. the last I- or P-frame. */
1101 if (st->last_IP_duration == 0)
1102 st->last_IP_duration = pkt->duration;
1103 if (pkt->dts != AV_NOPTS_VALUE)
1104 st->cur_dts = pkt->dts + st->last_IP_duration;
1105 if (pkt->dts != AV_NOPTS_VALUE &&
1106 pkt->pts == AV_NOPTS_VALUE &&
1107 st->last_IP_duration > 0 &&
1108 ((uint64_t)st->cur_dts - (uint64_t)next_dts + 1) <= 2 &&
1109 next_dts != next_pts &&
1110 next_pts != AV_NOPTS_VALUE)
1111 pkt->pts = next_dts;
1113 st->last_IP_duration = pkt->duration;
1114 st->last_IP_pts = pkt->pts;
1115 /* Cannot compute PTS if not present (we can compute it only
1116 * by knowing the future. */
1117 } else if (pkt->pts != AV_NOPTS_VALUE ||
1118 pkt->dts != AV_NOPTS_VALUE ||
1121 /* presentation is not delayed : PTS and DTS are the same */
1122 if (pkt->pts == AV_NOPTS_VALUE)
1123 pkt->pts = pkt->dts;
1124 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1126 if (pkt->pts == AV_NOPTS_VALUE)
1127 pkt->pts = st->cur_dts;
1128 pkt->dts = pkt->pts;
1129 if (pkt->pts != AV_NOPTS_VALUE)
1130 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1134 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1135 st->pts_buffer[0] = pkt->pts;
1136 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1137 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1139 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1141 // We skipped it above so we try here.
1143 // This should happen on the first packet
1144 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1145 if (pkt->dts > st->cur_dts)
1146 st->cur_dts = pkt->dts;
1148 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1149 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1152 if (is_intra_only(st->codec))
1153 pkt->flags |= AV_PKT_FLAG_KEY;
1155 pkt->convergence_duration = pc->convergence_duration;
1158 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1161 AVPacketList *pktl = *pkt_buf;
1162 *pkt_buf = pktl->next;
1163 av_free_packet(&pktl->pkt);
1166 *pkt_buf_end = NULL;
1170 * Parse a packet, add all split parts to parse_queue.
1172 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1174 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1176 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1177 AVStream *st = s->streams[stream_index];
1178 uint8_t *data = pkt ? pkt->data : NULL;
1179 int size = pkt ? pkt->size : 0;
1180 int ret = 0, got_output = 0;
1183 av_init_packet(&flush_pkt);
1186 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1187 // preserve 0-size sync packets
1188 compute_pkt_fields(s, st, st->parser, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1191 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1193 int64_t next_pts = pkt->pts;
1194 int64_t next_dts = pkt->dts;
1196 av_init_packet(&out_pkt);
1197 len = av_parser_parse2(st->parser, st->codec,
1198 &out_pkt.data, &out_pkt.size, data, size,
1199 pkt->pts, pkt->dts, pkt->pos);
1201 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1203 /* increment read pointer */
1207 got_output = !!out_pkt.size;
1212 if (pkt->side_data) {
1213 out_pkt.side_data = pkt->side_data;
1214 out_pkt.side_data_elems = pkt->side_data_elems;
1215 pkt->side_data = NULL;
1216 pkt->side_data_elems = 0;
1219 /* set the duration */
1220 out_pkt.duration = 0;
1221 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1222 if (st->codec->sample_rate > 0) {
1224 av_rescale_q_rnd(st->parser->duration,
1225 (AVRational) { 1, st->codec->sample_rate },
1231 out_pkt.stream_index = st->index;
1232 out_pkt.pts = st->parser->pts;
1233 out_pkt.dts = st->parser->dts;
1234 out_pkt.pos = st->parser->pos;
1236 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1237 out_pkt.pos = st->parser->frame_offset;
1239 if (st->parser->key_frame == 1 ||
1240 (st->parser->key_frame == -1 &&
1241 st->parser->pict_type == AV_PICTURE_TYPE_I))
1242 out_pkt.flags |= AV_PKT_FLAG_KEY;
1244 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1245 out_pkt.flags |= AV_PKT_FLAG_KEY;
1247 compute_pkt_fields(s, st, st->parser, &out_pkt, next_dts, next_pts);
1249 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1250 out_pkt.buf = pkt->buf;
1252 #if FF_API_DESTRUCT_PACKET
1253 FF_DISABLE_DEPRECATION_WARNINGS
1254 out_pkt.destruct = pkt->destruct;
1255 pkt->destruct = NULL;
1256 FF_ENABLE_DEPRECATION_WARNINGS
1259 if ((ret = av_dup_packet(&out_pkt)) < 0)
1262 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1263 av_free_packet(&out_pkt);
1264 ret = AVERROR(ENOMEM);
1269 /* end of the stream => close and free the parser */
1270 if (pkt == &flush_pkt) {
1271 av_parser_close(st->parser);
1276 av_free_packet(pkt);
1280 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1281 AVPacketList **pkt_buffer_end,
1285 av_assert0(*pkt_buffer);
1288 *pkt_buffer = pktl->next;
1290 *pkt_buffer_end = NULL;
1295 static int64_t ts_to_samples(AVStream *st, int64_t ts)
1297 return av_rescale(ts, st->time_base.num * st->codec->sample_rate, st->time_base.den);
1300 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1302 int ret = 0, i, got_packet = 0;
1303 AVDictionary *metadata = NULL;
1305 av_init_packet(pkt);
1307 while (!got_packet && !s->parse_queue) {
1311 /* read next packet */
1312 ret = ff_read_packet(s, &cur_pkt);
1314 if (ret == AVERROR(EAGAIN))
1316 /* flush the parsers */
1317 for (i = 0; i < s->nb_streams; i++) {
1319 if (st->parser && st->need_parsing)
1320 parse_packet(s, NULL, st->index);
1322 /* all remaining packets are now in parse_queue =>
1323 * really terminate parsing */
1327 st = s->streams[cur_pkt.stream_index];
1329 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1330 cur_pkt.dts != AV_NOPTS_VALUE &&
1331 cur_pkt.pts < cur_pkt.dts) {
1332 av_log(s, AV_LOG_WARNING,
1333 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1334 cur_pkt.stream_index,
1335 av_ts2str(cur_pkt.pts),
1336 av_ts2str(cur_pkt.dts),
1339 if (s->debug & FF_FDEBUG_TS)
1340 av_log(s, AV_LOG_DEBUG,
1341 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1342 cur_pkt.stream_index,
1343 av_ts2str(cur_pkt.pts),
1344 av_ts2str(cur_pkt.dts),
1345 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1347 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1348 st->parser = av_parser_init(st->codec->codec_id);
1350 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1351 "%s, packets or times may be invalid.\n",
1352 avcodec_get_name(st->codec->codec_id));
1353 /* no parser available: just output the raw packets */
1354 st->need_parsing = AVSTREAM_PARSE_NONE;
1355 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1356 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1357 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1358 st->parser->flags |= PARSER_FLAG_ONCE;
1359 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1360 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1363 if (!st->need_parsing || !st->parser) {
1364 /* no parsing needed: we just output the packet as is */
1366 compute_pkt_fields(s, st, NULL, pkt, AV_NOPTS_VALUE, AV_NOPTS_VALUE);
1367 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1368 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1369 ff_reduce_index(s, st->index);
1370 av_add_index_entry(st, pkt->pos, pkt->dts,
1371 0, 0, AVINDEX_KEYFRAME);
1374 } else if (st->discard < AVDISCARD_ALL) {
1375 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1379 av_free_packet(&cur_pkt);
1381 if (pkt->flags & AV_PKT_FLAG_KEY)
1382 st->skip_to_keyframe = 0;
1383 if (st->skip_to_keyframe) {
1384 av_free_packet(&cur_pkt);
1392 if (!got_packet && s->parse_queue)
1393 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1396 AVStream *st = s->streams[pkt->stream_index];
1397 int discard_padding = 0;
1398 if (st->first_discard_sample && pkt->pts != AV_NOPTS_VALUE) {
1399 int64_t pts = pkt->pts - (is_relative(pkt->pts) ? RELATIVE_TS_BASE : 0);
1400 int64_t sample = ts_to_samples(st, pts);
1401 int duration = ts_to_samples(st, pkt->duration);
1402 int64_t end_sample = sample + duration;
1403 if (duration > 0 && end_sample >= st->first_discard_sample &&
1404 sample < st->last_discard_sample)
1405 discard_padding = FFMIN(end_sample - st->first_discard_sample, duration);
1407 if (st->skip_samples || discard_padding) {
1408 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1410 AV_WL32(p, st->skip_samples);
1411 AV_WL32(p + 4, discard_padding);
1412 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1414 st->skip_samples = 0;
1417 if (st->inject_global_side_data) {
1418 for (i = 0; i < st->nb_side_data; i++) {
1419 AVPacketSideData *src_sd = &st->side_data[i];
1422 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1425 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1427 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1431 memcpy(dst_data, src_sd->data, src_sd->size);
1433 st->inject_global_side_data = 0;
1436 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1437 av_packet_merge_side_data(pkt);
1440 av_opt_get_dict_val(s, "metadata", AV_OPT_SEARCH_CHILDREN, &metadata);
1442 s->event_flags |= AVFMT_EVENT_FLAG_METADATA_UPDATED;
1443 av_dict_copy(&s->metadata, metadata, 0);
1444 av_dict_free(&metadata);
1445 av_opt_set_dict_val(s, "metadata", NULL, AV_OPT_SEARCH_CHILDREN);
1448 if (s->debug & FF_FDEBUG_TS)
1449 av_log(s, AV_LOG_DEBUG,
1450 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1451 "size=%d, duration=%d, flags=%d\n",
1453 av_ts2str(pkt->pts),
1454 av_ts2str(pkt->dts),
1455 pkt->size, pkt->duration, pkt->flags);
1460 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1462 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1468 ret = s->packet_buffer
1469 ? read_from_packet_buffer(&s->packet_buffer,
1470 &s->packet_buffer_end, pkt)
1471 : read_frame_internal(s, pkt);
1478 AVPacketList *pktl = s->packet_buffer;
1481 AVPacket *next_pkt = &pktl->pkt;
1483 if (next_pkt->dts != AV_NOPTS_VALUE) {
1484 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1485 // last dts seen for this stream. if any of packets following
1486 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1487 int64_t last_dts = next_pkt->dts;
1488 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1489 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1490 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1491 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1493 next_pkt->pts = pktl->pkt.dts;
1495 if (last_dts != AV_NOPTS_VALUE) {
1496 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1497 last_dts = pktl->pkt.dts;
1502 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1503 // Fixing the last reference frame had none pts issue (For MXF etc).
1504 // We only do this when
1506 // 2. we are not able to resolve a pts value for current packet.
1507 // 3. the packets for this stream at the end of the files had valid dts.
1508 next_pkt->pts = last_dts + next_pkt->duration;
1510 pktl = s->packet_buffer;
1513 /* read packet from packet buffer, if there is data */
1514 st = s->streams[next_pkt->stream_index];
1515 if (!(next_pkt->pts == AV_NOPTS_VALUE && st->discard < AVDISCARD_ALL &&
1516 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1517 ret = read_from_packet_buffer(&s->packet_buffer,
1518 &s->packet_buffer_end, pkt);
1523 ret = read_frame_internal(s, pkt);
1525 if (pktl && ret != AVERROR(EAGAIN)) {
1532 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1533 &s->packet_buffer_end)) < 0)
1534 return AVERROR(ENOMEM);
1539 st = s->streams[pkt->stream_index];
1540 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1541 ff_reduce_index(s, st->index);
1542 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1545 if (is_relative(pkt->dts))
1546 pkt->dts -= RELATIVE_TS_BASE;
1547 if (is_relative(pkt->pts))
1548 pkt->pts -= RELATIVE_TS_BASE;
1553 /* XXX: suppress the packet queue */
1554 static void flush_packet_queue(AVFormatContext *s)
1556 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1557 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1558 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1560 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1563 /*******************************************************/
1566 int av_find_default_stream_index(AVFormatContext *s)
1570 int best_stream = 0;
1571 int best_score = -1;
1573 if (s->nb_streams <= 0)
1575 for (i = 0; i < s->nb_streams; i++) {
1578 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1579 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1580 if (!st->codec->width && !st->codec->height && !st->codec_info_nb_frames)
1585 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1586 if (!st->codec->sample_rate && !st->codec_info_nb_frames)
1592 if (score > best_score) {
1600 /** Flush the frame reader. */
1601 void ff_read_frame_flush(AVFormatContext *s)
1606 flush_packet_queue(s);
1608 /* Reset read state for each stream. */
1609 for (i = 0; i < s->nb_streams; i++) {
1613 av_parser_close(st->parser);
1616 st->last_IP_pts = AV_NOPTS_VALUE;
1617 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1618 if (st->first_dts == AV_NOPTS_VALUE)
1619 st->cur_dts = RELATIVE_TS_BASE;
1621 /* We set the current DTS to an unspecified origin. */
1622 st->cur_dts = AV_NOPTS_VALUE;
1624 st->probe_packets = MAX_PROBE_PACKETS;
1626 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1627 st->pts_buffer[j] = AV_NOPTS_VALUE;
1629 if (s->internal->inject_global_side_data)
1630 st->inject_global_side_data = 1;
1634 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1638 for (i = 0; i < s->nb_streams; i++) {
1639 AVStream *st = s->streams[i];
1642 av_rescale(timestamp,
1643 st->time_base.den * (int64_t) ref_st->time_base.num,
1644 st->time_base.num * (int64_t) ref_st->time_base.den);
1648 void ff_reduce_index(AVFormatContext *s, int stream_index)
1650 AVStream *st = s->streams[stream_index];
1651 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1653 if ((unsigned) st->nb_index_entries >= max_entries) {
1655 for (i = 0; 2 * i < st->nb_index_entries; i++)
1656 st->index_entries[i] = st->index_entries[2 * i];
1657 st->nb_index_entries = i;
1661 int ff_add_index_entry(AVIndexEntry **index_entries,
1662 int *nb_index_entries,
1663 unsigned int *index_entries_allocated_size,
1664 int64_t pos, int64_t timestamp,
1665 int size, int distance, int flags)
1667 AVIndexEntry *entries, *ie;
1670 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1673 if (timestamp == AV_NOPTS_VALUE)
1674 return AVERROR(EINVAL);
1676 if (size < 0 || size > 0x3FFFFFFF)
1677 return AVERROR(EINVAL);
1679 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1680 timestamp -= RELATIVE_TS_BASE;
1682 entries = av_fast_realloc(*index_entries,
1683 index_entries_allocated_size,
1684 (*nb_index_entries + 1) *
1685 sizeof(AVIndexEntry));
1689 *index_entries = entries;
1691 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1692 timestamp, AVSEEK_FLAG_ANY);
1695 index = (*nb_index_entries)++;
1696 ie = &entries[index];
1697 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1699 ie = &entries[index];
1700 if (ie->timestamp != timestamp) {
1701 if (ie->timestamp <= timestamp)
1703 memmove(entries + index + 1, entries + index,
1704 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1705 (*nb_index_entries)++;
1706 } else if (ie->pos == pos && distance < ie->min_distance)
1707 // do not reduce the distance
1708 distance = ie->min_distance;
1712 ie->timestamp = timestamp;
1713 ie->min_distance = distance;
1720 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1721 int size, int distance, int flags)
1723 timestamp = wrap_timestamp(st, timestamp);
1724 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1725 &st->index_entries_allocated_size, pos,
1726 timestamp, size, distance, flags);
1729 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1730 int64_t wanted_timestamp, int flags)
1738 // Optimize appending index entries at the end.
1739 if (b && entries[b - 1].timestamp < wanted_timestamp)
1744 timestamp = entries[m].timestamp;
1745 if (timestamp >= wanted_timestamp)
1747 if (timestamp <= wanted_timestamp)
1750 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1752 if (!(flags & AVSEEK_FLAG_ANY))
1753 while (m >= 0 && m < nb_entries &&
1754 !(entries[m].flags & AVINDEX_KEYFRAME))
1755 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1757 if (m == nb_entries)
1762 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1764 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1765 wanted_timestamp, flags);
1768 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1769 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1771 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1772 if (stream_index >= 0)
1773 ts = wrap_timestamp(s->streams[stream_index], ts);
1777 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1778 int64_t target_ts, int flags)
1780 AVInputFormat *avif = s->iformat;
1781 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1782 int64_t ts_min, ts_max, ts;
1787 if (stream_index < 0)
1790 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1793 ts_min = AV_NOPTS_VALUE;
1794 pos_limit = -1; // GCC falsely says it may be uninitialized.
1796 st = s->streams[stream_index];
1797 if (st->index_entries) {
1800 /* FIXME: Whole function must be checked for non-keyframe entries in
1801 * index case, especially read_timestamp(). */
1802 index = av_index_search_timestamp(st, target_ts,
1803 flags | AVSEEK_FLAG_BACKWARD);
1804 index = FFMAX(index, 0);
1805 e = &st->index_entries[index];
1807 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1809 ts_min = e->timestamp;
1810 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1811 pos_min, av_ts2str(ts_min));
1813 av_assert1(index == 0);
1816 index = av_index_search_timestamp(st, target_ts,
1817 flags & ~AVSEEK_FLAG_BACKWARD);
1818 av_assert0(index < st->nb_index_entries);
1820 e = &st->index_entries[index];
1821 av_assert1(e->timestamp >= target_ts);
1823 ts_max = e->timestamp;
1824 pos_limit = pos_max - e->min_distance;
1825 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1826 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1830 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1831 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1836 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1839 ff_read_frame_flush(s);
1840 ff_update_cur_dts(s, st, ts);
1845 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1846 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1848 int64_t step = 1024;
1849 int64_t limit, ts_max;
1850 int64_t filesize = avio_size(s->pb);
1851 int64_t pos_max = filesize - 1;
1854 pos_max = FFMAX(0, (pos_max) - step);
1855 ts_max = ff_read_timestamp(s, stream_index,
1856 &pos_max, limit, read_timestamp);
1858 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1859 if (ts_max == AV_NOPTS_VALUE)
1863 int64_t tmp_pos = pos_max + 1;
1864 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1865 &tmp_pos, INT64_MAX, read_timestamp);
1866 if (tmp_ts == AV_NOPTS_VALUE)
1868 av_assert0(tmp_pos > pos_max);
1871 if (tmp_pos >= filesize)
1883 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1884 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1885 int64_t ts_min, int64_t ts_max,
1886 int flags, int64_t *ts_ret,
1887 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1888 int64_t *, int64_t))
1895 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1897 if (ts_min == AV_NOPTS_VALUE) {
1898 pos_min = s->data_offset;
1899 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1900 if (ts_min == AV_NOPTS_VALUE)
1904 if (ts_min >= target_ts) {
1909 if (ts_max == AV_NOPTS_VALUE) {
1910 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1912 pos_limit = pos_max;
1915 if (ts_max <= target_ts) {
1920 if (ts_min > ts_max)
1922 else if (ts_min == ts_max)
1923 pos_limit = pos_min;
1926 while (pos_min < pos_limit) {
1928 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1929 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1930 assert(pos_limit <= pos_max);
1932 if (no_change == 0) {
1933 int64_t approximate_keyframe_distance = pos_max - pos_limit;
1934 // interpolate position (better than dichotomy)
1935 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
1937 pos_min - approximate_keyframe_distance;
1938 } else if (no_change == 1) {
1939 // bisection if interpolation did not change min / max pos last time
1940 pos = (pos_min + pos_limit) >> 1;
1942 /* linear search if bisection failed, can only happen if there
1943 * are very few or no keyframes between min/max */
1948 else if (pos > pos_limit)
1952 // May pass pos_limit instead of -1.
1953 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
1958 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
1959 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1960 pos_min, pos, pos_max,
1961 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1962 pos_limit, start_pos, no_change);
1963 if (ts == AV_NOPTS_VALUE) {
1964 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1967 if (target_ts <= ts) {
1968 pos_limit = start_pos - 1;
1972 if (target_ts >= ts) {
1978 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1979 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1982 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1984 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1985 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1986 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1992 static int seek_frame_byte(AVFormatContext *s, int stream_index,
1993 int64_t pos, int flags)
1995 int64_t pos_min, pos_max;
1997 pos_min = s->data_offset;
1998 pos_max = avio_size(s->pb) - 1;
2002 else if (pos > pos_max)
2005 avio_seek(s->pb, pos, SEEK_SET);
2007 s->io_repositioned = 1;
2012 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2013 int64_t timestamp, int flags)
2020 st = s->streams[stream_index];
2022 index = av_index_search_timestamp(st, timestamp, flags);
2024 if (index < 0 && st->nb_index_entries &&
2025 timestamp < st->index_entries[0].timestamp)
2028 if (index < 0 || index == st->nb_index_entries - 1) {
2032 if (st->nb_index_entries) {
2033 av_assert0(st->index_entries);
2034 ie = &st->index_entries[st->nb_index_entries - 1];
2035 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2037 ff_update_cur_dts(s, st, ie->timestamp);
2039 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2045 read_status = av_read_frame(s, &pkt);
2046 } while (read_status == AVERROR(EAGAIN));
2047 if (read_status < 0)
2049 av_free_packet(&pkt);
2050 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2051 if (pkt.flags & AV_PKT_FLAG_KEY)
2053 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2054 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);
2059 index = av_index_search_timestamp(st, timestamp, flags);
2064 ff_read_frame_flush(s);
2065 if (s->iformat->read_seek)
2066 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2068 ie = &st->index_entries[index];
2069 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2071 ff_update_cur_dts(s, st, ie->timestamp);
2076 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2077 int64_t timestamp, int flags)
2082 if (flags & AVSEEK_FLAG_BYTE) {
2083 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2085 ff_read_frame_flush(s);
2086 return seek_frame_byte(s, stream_index, timestamp, flags);
2089 if (stream_index < 0) {
2090 stream_index = av_find_default_stream_index(s);
2091 if (stream_index < 0)
2094 st = s->streams[stream_index];
2095 /* timestamp for default must be expressed in AV_TIME_BASE units */
2096 timestamp = av_rescale(timestamp, st->time_base.den,
2097 AV_TIME_BASE * (int64_t) st->time_base.num);
2100 /* first, we try the format specific seek */
2101 if (s->iformat->read_seek) {
2102 ff_read_frame_flush(s);
2103 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2109 if (s->iformat->read_timestamp &&
2110 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2111 ff_read_frame_flush(s);
2112 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2113 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2114 ff_read_frame_flush(s);
2115 return seek_frame_generic(s, stream_index, timestamp, flags);
2120 int av_seek_frame(AVFormatContext *s, int stream_index,
2121 int64_t timestamp, int flags)
2125 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2126 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2127 if ((flags & AVSEEK_FLAG_BACKWARD))
2131 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2132 flags & ~AVSEEK_FLAG_BACKWARD);
2135 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2138 ret = avformat_queue_attached_pictures(s);
2143 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2144 int64_t ts, int64_t max_ts, int flags)
2146 if (min_ts > ts || max_ts < ts)
2148 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2149 return AVERROR(EINVAL);
2152 flags |= AVSEEK_FLAG_ANY;
2153 flags &= ~AVSEEK_FLAG_BACKWARD;
2155 if (s->iformat->read_seek2) {
2157 ff_read_frame_flush(s);
2159 if (stream_index == -1 && s->nb_streams == 1) {
2160 AVRational time_base = s->streams[0]->time_base;
2161 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2162 min_ts = av_rescale_rnd(min_ts, time_base.den,
2163 time_base.num * (int64_t)AV_TIME_BASE,
2164 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2165 max_ts = av_rescale_rnd(max_ts, time_base.den,
2166 time_base.num * (int64_t)AV_TIME_BASE,
2167 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2170 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2174 ret = avformat_queue_attached_pictures(s);
2178 if (s->iformat->read_timestamp) {
2179 // try to seek via read_timestamp()
2182 // Fall back on old API if new is not implemented but old is.
2183 // Note the old API has somewhat different semantics.
2184 if (s->iformat->read_seek || 1) {
2185 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2186 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2187 if (ret<0 && ts != min_ts && max_ts != ts) {
2188 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2190 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2195 // try some generic seek like seek_frame_generic() but with new ts semantics
2196 return -1; //unreachable
2199 /*******************************************************/
2202 * Return TRUE if the stream has accurate duration in any stream.
2204 * @return TRUE if the stream has accurate duration for at least one component.
2206 static int has_duration(AVFormatContext *ic)
2211 for (i = 0; i < ic->nb_streams; i++) {
2212 st = ic->streams[i];
2213 if (st->duration != AV_NOPTS_VALUE)
2216 if (ic->duration != AV_NOPTS_VALUE)
2222 * Estimate the stream timings from the one of each components.
2224 * Also computes the global bitrate if possible.
2226 static void update_stream_timings(AVFormatContext *ic)
2228 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2229 int64_t duration, duration1, filesize;
2234 start_time = INT64_MAX;
2235 start_time_text = INT64_MAX;
2236 end_time = INT64_MIN;
2237 duration = INT64_MIN;
2238 for (i = 0; i < ic->nb_streams; i++) {
2239 st = ic->streams[i];
2240 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2241 start_time1 = av_rescale_q(st->start_time, st->time_base,
2243 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2244 if (start_time1 < start_time_text)
2245 start_time_text = start_time1;
2247 start_time = FFMIN(start_time, start_time1);
2248 end_time1 = AV_NOPTS_VALUE;
2249 if (st->duration != AV_NOPTS_VALUE) {
2250 end_time1 = start_time1 +
2251 av_rescale_q(st->duration, st->time_base,
2253 end_time = FFMAX(end_time, end_time1);
2255 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2256 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2257 p->start_time = start_time1;
2258 if (p->end_time < end_time1)
2259 p->end_time = end_time1;
2262 if (st->duration != AV_NOPTS_VALUE) {
2263 duration1 = av_rescale_q(st->duration, st->time_base,
2265 duration = FFMAX(duration, duration1);
2268 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2269 start_time = start_time_text;
2270 else if (start_time > start_time_text)
2271 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2273 if (start_time != INT64_MAX) {
2274 ic->start_time = start_time;
2275 if (end_time != INT64_MIN) {
2276 if (ic->nb_programs) {
2277 for (i = 0; i < ic->nb_programs; i++) {
2278 p = ic->programs[i];
2279 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2280 duration = FFMAX(duration, p->end_time - p->start_time);
2283 duration = FFMAX(duration, end_time - start_time);
2286 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2287 ic->duration = duration;
2289 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2290 /* compute the bitrate */
2291 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2292 (double) ic->duration;
2293 if (bitrate >= 0 && bitrate <= INT_MAX)
2294 ic->bit_rate = bitrate;
2298 static void fill_all_stream_timings(AVFormatContext *ic)
2303 update_stream_timings(ic);
2304 for (i = 0; i < ic->nb_streams; i++) {
2305 st = ic->streams[i];
2306 if (st->start_time == AV_NOPTS_VALUE) {
2307 if (ic->start_time != AV_NOPTS_VALUE)
2308 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2310 if (ic->duration != AV_NOPTS_VALUE)
2311 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2317 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2319 int64_t filesize, duration;
2320 int i, show_warning = 0;
2323 /* if bit_rate is already set, we believe it */
2324 if (ic->bit_rate <= 0) {
2326 for (i = 0; i < ic->nb_streams; i++) {
2327 st = ic->streams[i];
2328 if (st->codec->bit_rate > 0) {
2329 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2333 bit_rate += st->codec->bit_rate;
2336 ic->bit_rate = bit_rate;
2339 /* if duration is already set, we believe it */
2340 if (ic->duration == AV_NOPTS_VALUE &&
2341 ic->bit_rate != 0) {
2342 filesize = ic->pb ? avio_size(ic->pb) : 0;
2343 if (filesize > ic->data_offset) {
2344 filesize -= ic->data_offset;
2345 for (i = 0; i < ic->nb_streams; i++) {
2346 st = ic->streams[i];
2347 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2348 && st->duration == AV_NOPTS_VALUE) {
2349 duration = av_rescale(8 * filesize, st->time_base.den,
2351 (int64_t) st->time_base.num);
2352 st->duration = duration;
2359 av_log(ic, AV_LOG_WARNING,
2360 "Estimating duration from bitrate, this may be inaccurate\n");
2363 #define DURATION_MAX_READ_SIZE 250000LL
2364 #define DURATION_MAX_RETRY 4
2366 /* only usable for MPEG-PS streams */
2367 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2369 AVPacket pkt1, *pkt = &pkt1;
2371 int num, den, read_size, i, ret;
2372 int found_duration = 0;
2374 int64_t filesize, offset, duration;
2377 /* flush packet queue */
2378 flush_packet_queue(ic);
2380 for (i = 0; i < ic->nb_streams; i++) {
2381 st = ic->streams[i];
2382 if (st->start_time == AV_NOPTS_VALUE &&
2383 st->first_dts == AV_NOPTS_VALUE &&
2384 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2385 av_log(st->codec, AV_LOG_WARNING,
2386 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2389 av_parser_close(st->parser);
2394 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2395 /* estimate the end time (duration) */
2396 /* XXX: may need to support wrapping */
2397 filesize = ic->pb ? avio_size(ic->pb) : 0;
2399 is_end = found_duration;
2400 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2404 avio_seek(ic->pb, offset, SEEK_SET);
2407 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2411 ret = ff_read_packet(ic, pkt);
2412 } while (ret == AVERROR(EAGAIN));
2415 read_size += pkt->size;
2416 st = ic->streams[pkt->stream_index];
2417 if (pkt->pts != AV_NOPTS_VALUE &&
2418 (st->start_time != AV_NOPTS_VALUE ||
2419 st->first_dts != AV_NOPTS_VALUE)) {
2420 if (pkt->duration == 0) {
2421 ff_compute_frame_duration(ic, &num, &den, st, st->parser, pkt);
2423 pkt->duration = av_rescale_rnd(1,
2424 num * (int64_t) st->time_base.den,
2425 den * (int64_t) st->time_base.num,
2429 duration = pkt->pts + pkt->duration;
2431 if (st->start_time != AV_NOPTS_VALUE)
2432 duration -= st->start_time;
2434 duration -= st->first_dts;
2436 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2437 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2438 st->duration = duration;
2439 st->info->last_duration = duration;
2442 av_free_packet(pkt);
2445 /* check if all audio/video streams have valid duration */
2448 for (i = 0; i < ic->nb_streams; i++) {
2449 st = ic->streams[i];
2450 switch (st->codec->codec_type) {
2451 case AVMEDIA_TYPE_VIDEO:
2452 case AVMEDIA_TYPE_AUDIO:
2453 if (st->duration == AV_NOPTS_VALUE)
2460 ++retry <= DURATION_MAX_RETRY);
2462 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2464 /* warn about audio/video streams which duration could not be estimated */
2465 for (i = 0; i < ic->nb_streams; i++) {
2466 st = ic->streams[i];
2467 if (st->duration == AV_NOPTS_VALUE) {
2468 switch (st->codec->codec_type) {
2469 case AVMEDIA_TYPE_VIDEO:
2470 case AVMEDIA_TYPE_AUDIO:
2471 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2472 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2474 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2478 fill_all_stream_timings(ic);
2480 avio_seek(ic->pb, old_offset, SEEK_SET);
2481 for (i = 0; i < ic->nb_streams; i++) {
2484 st = ic->streams[i];
2485 st->cur_dts = st->first_dts;
2486 st->last_IP_pts = AV_NOPTS_VALUE;
2487 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2488 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2489 st->pts_buffer[j] = AV_NOPTS_VALUE;
2493 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2497 /* get the file size, if possible */
2498 if (ic->iformat->flags & AVFMT_NOFILE) {
2501 file_size = avio_size(ic->pb);
2502 file_size = FFMAX(0, file_size);
2505 if ((!strcmp(ic->iformat->name, "mpeg") ||
2506 !strcmp(ic->iformat->name, "mpegts")) &&
2507 file_size && ic->pb->seekable) {
2508 /* get accurate estimate from the PTSes */
2509 estimate_timings_from_pts(ic, old_offset);
2510 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2511 } else if (has_duration(ic)) {
2512 /* at least one component has timings - we use them for all
2514 fill_all_stream_timings(ic);
2515 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2517 /* less precise: use bitrate info */
2518 estimate_timings_from_bit_rate(ic);
2519 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2521 update_stream_timings(ic);
2525 AVStream av_unused *st;
2526 for (i = 0; i < ic->nb_streams; i++) {
2527 st = ic->streams[i];
2528 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2529 (double) st->start_time / AV_TIME_BASE,
2530 (double) st->duration / AV_TIME_BASE);
2533 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2534 (double) ic->start_time / AV_TIME_BASE,
2535 (double) ic->duration / AV_TIME_BASE,
2536 ic->bit_rate / 1000);
2540 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2542 AVCodecContext *avctx = st->codec;
2544 #define FAIL(errmsg) do { \
2546 *errmsg_ptr = errmsg; \
2550 if ( avctx->codec_id == AV_CODEC_ID_NONE
2551 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2552 FAIL("unknown codec");
2553 switch (avctx->codec_type) {
2554 case AVMEDIA_TYPE_AUDIO:
2555 if (!avctx->frame_size && determinable_frame_size(avctx))
2556 FAIL("unspecified frame size");
2557 if (st->info->found_decoder >= 0 &&
2558 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2559 FAIL("unspecified sample format");
2560 if (!avctx->sample_rate)
2561 FAIL("unspecified sample rate");
2562 if (!avctx->channels)
2563 FAIL("unspecified number of channels");
2564 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2565 FAIL("no decodable DTS frames");
2567 case AVMEDIA_TYPE_VIDEO:
2569 FAIL("unspecified size");
2570 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2571 FAIL("unspecified pixel format");
2572 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2573 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2574 FAIL("no frame in rv30/40 and no sar");
2576 case AVMEDIA_TYPE_SUBTITLE:
2577 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2578 FAIL("unspecified size");
2580 case AVMEDIA_TYPE_DATA:
2581 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2587 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2588 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2589 AVDictionary **options)
2591 const AVCodec *codec;
2592 int got_picture = 1, ret = 0;
2593 AVFrame *frame = av_frame_alloc();
2594 AVSubtitle subtitle;
2595 AVPacket pkt = *avpkt;
2598 return AVERROR(ENOMEM);
2600 if (!avcodec_is_open(st->codec) &&
2601 st->info->found_decoder <= 0 &&
2602 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2603 AVDictionary *thread_opt = NULL;
2605 codec = find_decoder(s, st, st->codec->codec_id);
2608 st->info->found_decoder = -st->codec->codec_id;
2613 /* Force thread count to 1 since the H.264 decoder will not extract
2614 * SPS and PPS to extradata during multi-threaded decoding. */
2615 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2616 if (s->codec_whitelist)
2617 av_dict_set(options ? options : &thread_opt, "codec_whitelist", s->codec_whitelist, 0);
2618 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2620 av_dict_free(&thread_opt);
2622 st->info->found_decoder = -st->codec->codec_id;
2625 st->info->found_decoder = 1;
2626 } else if (!st->info->found_decoder)
2627 st->info->found_decoder = 1;
2629 if (st->info->found_decoder < 0) {
2634 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2636 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2637 (!st->codec_info_nb_frames &&
2638 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2640 switch (st->codec->codec_type) {
2641 case AVMEDIA_TYPE_VIDEO:
2642 ret = avcodec_decode_video2(st->codec, frame,
2643 &got_picture, &pkt);
2645 case AVMEDIA_TYPE_AUDIO:
2646 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2648 case AVMEDIA_TYPE_SUBTITLE:
2649 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2650 &got_picture, &pkt);
2658 st->nb_decoded_frames++;
2665 if (!pkt.data && !got_picture)
2669 av_frame_free(&frame);
2673 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2675 while (tags->id != AV_CODEC_ID_NONE) {
2683 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2686 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2687 if (tag == tags[i].tag)
2689 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2690 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2692 return AV_CODEC_ID_NONE;
2695 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2700 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2702 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2704 return AV_CODEC_ID_NONE;
2709 if (sflags & (1 << (bps - 1))) {
2712 return AV_CODEC_ID_PCM_S8;
2714 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2716 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2718 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2720 return AV_CODEC_ID_NONE;
2725 return AV_CODEC_ID_PCM_U8;
2727 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2729 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2731 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2733 return AV_CODEC_ID_NONE;
2739 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2742 if (!av_codec_get_tag2(tags, id, &tag))
2747 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2751 for (i = 0; tags && tags[i]; i++) {
2752 const AVCodecTag *codec_tags = tags[i];
2753 while (codec_tags->id != AV_CODEC_ID_NONE) {
2754 if (codec_tags->id == id) {
2755 *tag = codec_tags->tag;
2764 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2767 for (i = 0; tags && tags[i]; i++) {
2768 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2769 if (id != AV_CODEC_ID_NONE)
2772 return AV_CODEC_ID_NONE;
2775 static void compute_chapters_end(AVFormatContext *s)
2778 int64_t max_time = s->duration +
2779 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2781 for (i = 0; i < s->nb_chapters; i++)
2782 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2783 AVChapter *ch = s->chapters[i];
2784 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2788 for (j = 0; j < s->nb_chapters; j++) {
2789 AVChapter *ch1 = s->chapters[j];
2790 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2792 if (j != i && next_start > ch->start && next_start < end)
2795 ch->end = (end == INT64_MAX) ? ch->start : end;
2799 static int get_std_framerate(int i)
2802 return (i + 1) * 1001;
2806 return ((const int[]) { 40, 48, 50, 60, 80, 120, 240})[i] * 1001 * 12;
2810 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i] * 1000 * 12;
2813 /* Is the time base unreliable?
2814 * This is a heuristic to balance between quick acceptance of the values in
2815 * the headers vs. some extra checks.
2816 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2817 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2818 * And there are "variable" fps files this needs to detect as well. */
2819 static int tb_unreliable(AVCodecContext *c)
2821 if (c->time_base.den >= 101L * c->time_base.num ||
2822 c->time_base.den < 5L * c->time_base.num ||
2823 // c->codec_tag == AV_RL32("DIVX") ||
2824 // c->codec_tag == AV_RL32("XVID") ||
2825 c->codec_tag == AV_RL32("mp4v") ||
2826 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2827 c->codec_id == AV_CODEC_ID_GIF ||
2828 c->codec_id == AV_CODEC_ID_H264)
2833 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2837 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2838 avctx->extradata_size = 0;
2839 return AVERROR(EINVAL);
2841 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2842 if (avctx->extradata) {
2843 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2844 avctx->extradata_size = size;
2847 avctx->extradata_size = 0;
2848 ret = AVERROR(ENOMEM);
2853 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2855 int ret = ff_alloc_extradata(avctx, size);
2858 ret = avio_read(pb, avctx->extradata, size);
2860 av_freep(&avctx->extradata);
2861 avctx->extradata_size = 0;
2862 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2863 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2869 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2872 int64_t last = st->info->last_dts;
2874 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2875 && ts - (uint64_t)last < INT64_MAX) {
2876 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2877 int64_t duration = ts - last;
2879 if (!st->info->duration_error)
2880 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2881 if (!st->info->duration_error)
2882 return AVERROR(ENOMEM);
2884 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2885 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2886 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2887 if (st->info->duration_error[0][1][i] < 1e10) {
2888 int framerate = get_std_framerate(i);
2889 double sdts = dts*framerate/(1001*12);
2890 for (j= 0; j<2; j++) {
2891 int64_t ticks = llrint(sdts+j*0.5);
2892 double error= sdts - ticks + j*0.5;
2893 st->info->duration_error[j][0][i] += error;
2894 st->info->duration_error[j][1][i] += error*error;
2898 st->info->duration_count++;
2899 st->info->rfps_duration_sum += duration;
2901 if (st->info->duration_count % 10 == 0) {
2902 int n = st->info->duration_count;
2903 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2904 if (st->info->duration_error[0][1][i] < 1e10) {
2905 double a0 = st->info->duration_error[0][0][i] / n;
2906 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
2907 double a1 = st->info->duration_error[1][0][i] / n;
2908 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
2909 if (error0 > 0.04 && error1 > 0.04) {
2910 st->info->duration_error[0][1][i] = 2e10;
2911 st->info->duration_error[1][1][i] = 2e10;
2917 // ignore the first 4 values, they might have some random jitter
2918 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2919 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2921 if (ts != AV_NOPTS_VALUE)
2922 st->info->last_dts = ts;
2927 void ff_rfps_calculate(AVFormatContext *ic)
2931 for (i = 0; i < ic->nb_streams; i++) {
2932 AVStream *st = ic->streams[i];
2934 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2936 // the check for tb_unreliable() is not completely correct, since this is not about handling
2937 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2938 // ipmovie.c produces.
2939 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)
2940 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);
2941 if (st->info->duration_count>1 && !st->r_frame_rate.num
2942 && tb_unreliable(st->codec)) {
2944 double best_error= 0.01;
2945 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
2947 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
2950 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2952 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2955 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
2958 for (k= 0; k<2; k++) {
2959 int n = st->info->duration_count;
2960 double a= st->info->duration_error[k][0][j] / n;
2961 double error= st->info->duration_error[k][1][j]/n - a*a;
2963 if (error < best_error && best_error> 0.000000001) {
2965 num = get_std_framerate(j);
2968 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2971 // do not increase frame rate by more than 1 % in order to match a standard rate.
2972 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
2973 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2975 if ( !st->avg_frame_rate.num
2976 && st->r_frame_rate.num && st->info->rfps_duration_sum
2977 && st->info->codec_info_duration <= 0
2978 && st->info->duration_count > 2
2979 && 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
2981 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
2982 st->avg_frame_rate = st->r_frame_rate;
2985 av_freep(&st->info->duration_error);
2986 st->info->last_dts = AV_NOPTS_VALUE;
2987 st->info->duration_count = 0;
2988 st->info->rfps_duration_sum = 0;
2992 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2994 int i, count, ret = 0, j;
2997 AVPacket pkt1, *pkt;
2998 int64_t old_offset = avio_tell(ic->pb);
2999 // new streams might appear, no options for those
3000 int orig_nb_streams = ic->nb_streams;
3002 int64_t max_analyze_duration = ic->max_analyze_duration2;
3003 int64_t max_stream_analyze_duration;
3004 int64_t probesize = ic->probesize2;
3006 if (!max_analyze_duration)
3007 max_analyze_duration = ic->max_analyze_duration;
3009 probesize = ic->probesize;
3010 flush_codecs = probesize > 0;
3012 av_opt_set(ic, "skip_clear", "1", AV_OPT_SEARCH_CHILDREN);
3014 max_stream_analyze_duration = max_analyze_duration;
3015 if (!max_analyze_duration) {
3016 max_stream_analyze_duration =
3017 max_analyze_duration = 5*AV_TIME_BASE;
3018 if (!strcmp(ic->iformat->name, "flv"))
3019 max_stream_analyze_duration = 30*AV_TIME_BASE;
3023 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3024 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3026 for (i = 0; i < ic->nb_streams; i++) {
3027 const AVCodec *codec;
3028 AVDictionary *thread_opt = NULL;
3029 st = ic->streams[i];
3031 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3032 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3033 /* if (!st->time_base.num)
3035 if (!st->codec->time_base.num)
3036 st->codec->time_base = st->time_base;
3038 // only for the split stuff
3039 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3040 st->parser = av_parser_init(st->codec->codec_id);
3042 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3043 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3044 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3045 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3047 } else if (st->need_parsing) {
3048 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3049 "%s, packets or times may be invalid.\n",
3050 avcodec_get_name(st->codec->codec_id));
3053 codec = find_decoder(ic, st, st->codec->codec_id);
3055 /* Force thread count to 1 since the H.264 decoder will not extract
3056 * SPS and PPS to extradata during multi-threaded decoding. */
3057 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3059 if (ic->codec_whitelist)
3060 av_dict_set(options ? &options[i] : &thread_opt, "codec_whitelist", ic->codec_whitelist, 0);
3062 /* Ensure that subtitle_header is properly set. */
3063 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3064 && codec && !st->codec->codec) {
3065 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3066 av_log(ic, AV_LOG_WARNING,
3067 "Failed to open codec in av_find_stream_info\n");
3070 // Try to just open decoders, in case this is enough to get parameters.
3071 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3072 if (codec && !st->codec->codec)
3073 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3074 av_log(ic, AV_LOG_WARNING,
3075 "Failed to open codec in av_find_stream_info\n");
3078 av_dict_free(&thread_opt);
3081 for (i = 0; i < ic->nb_streams; i++) {
3082 #if FF_API_R_FRAME_RATE
3083 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3085 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3086 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3092 int analyzed_all_streams;
3093 if (ff_check_interrupt(&ic->interrupt_callback)) {
3095 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3099 /* check if one codec still needs to be handled */
3100 for (i = 0; i < ic->nb_streams; i++) {
3101 int fps_analyze_framecount = 20;
3103 st = ic->streams[i];
3104 if (!has_codec_parameters(st, NULL))
3106 /* If the timebase is coarse (like the usual millisecond precision
3107 * of mkv), we need to analyze more frames to reliably arrive at
3108 * the correct fps. */
3109 if (av_q2d(st->time_base) > 0.0005)
3110 fps_analyze_framecount *= 2;
3111 if (!tb_unreliable(st->codec))
3112 fps_analyze_framecount = 0;
3113 if (ic->fps_probe_size >= 0)
3114 fps_analyze_framecount = ic->fps_probe_size;
3115 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3116 fps_analyze_framecount = 0;
3117 /* variable fps and no guess at the real fps */
3118 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3119 st->info->duration_count < fps_analyze_framecount &&
3120 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3122 if (st->parser && st->parser->parser->split &&
3123 !st->codec->extradata)
3125 if (st->first_dts == AV_NOPTS_VALUE &&
3126 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3127 st->codec_info_nb_frames < ic->max_ts_probe &&
3128 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3129 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3132 analyzed_all_streams = 0;
3133 if (i == ic->nb_streams) {
3134 analyzed_all_streams = 1;
3135 /* NOTE: If the format has no header, then we need to read some
3136 * packets to get most of the streams, so we cannot stop here. */
3137 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3138 /* If we found the info for all the codecs, we can stop. */
3140 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3145 /* We did not get all the codec info, but we read too much data. */
3146 if (read_size >= probesize) {
3148 av_log(ic, AV_LOG_DEBUG,
3149 "Probe buffer size limit of %"PRId64" bytes reached\n", probesize);
3150 for (i = 0; i < ic->nb_streams; i++)
3151 if (!ic->streams[i]->r_frame_rate.num &&
3152 ic->streams[i]->info->duration_count <= 1 &&
3153 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3154 strcmp(ic->iformat->name, "image2"))
3155 av_log(ic, AV_LOG_WARNING,
3156 "Stream #%d: not enough frames to estimate rate; "
3157 "consider increasing probesize\n", i);
3161 /* NOTE: A new stream can be added there if no header in file
3162 * (AVFMTCTX_NOHEADER). */
3163 ret = read_frame_internal(ic, &pkt1);
3164 if (ret == AVERROR(EAGAIN))
3172 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3173 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3175 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3176 &ic->packet_buffer_end);
3178 ret = AVERROR(ENOMEM);
3179 goto find_stream_info_err;
3181 if ((ret = av_dup_packet(pkt)) < 0)
3182 goto find_stream_info_err;
3185 st = ic->streams[pkt->stream_index];
3186 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3187 read_size += pkt->size;
3189 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3190 /* check for non-increasing dts */
3191 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3192 st->info->fps_last_dts >= pkt->dts) {
3193 av_log(ic, AV_LOG_DEBUG,
3194 "Non-increasing DTS in stream %d: packet %d with DTS "
3195 "%"PRId64", packet %d with DTS %"PRId64"\n",
3196 st->index, st->info->fps_last_dts_idx,
3197 st->info->fps_last_dts, st->codec_info_nb_frames,
3199 st->info->fps_first_dts =
3200 st->info->fps_last_dts = AV_NOPTS_VALUE;
3202 /* Check for a discontinuity in dts. If the difference in dts
3203 * is more than 1000 times the average packet duration in the
3204 * sequence, we treat it as a discontinuity. */
3205 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3206 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3207 (pkt->dts - st->info->fps_last_dts) / 1000 >
3208 (st->info->fps_last_dts - st->info->fps_first_dts) /
3209 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3210 av_log(ic, AV_LOG_WARNING,
3211 "DTS discontinuity in stream %d: packet %d with DTS "
3212 "%"PRId64", packet %d with DTS %"PRId64"\n",
3213 st->index, st->info->fps_last_dts_idx,
3214 st->info->fps_last_dts, st->codec_info_nb_frames,
3216 st->info->fps_first_dts =
3217 st->info->fps_last_dts = AV_NOPTS_VALUE;
3220 /* update stored dts values */
3221 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3222 st->info->fps_first_dts = pkt->dts;
3223 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3225 st->info->fps_last_dts = pkt->dts;
3226 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3228 if (st->codec_info_nb_frames>1) {
3231 if (st->time_base.den > 0)
3232 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3233 if (st->avg_frame_rate.num > 0)
3234 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3237 && st->codec_info_nb_frames>30
3238 && st->info->fps_first_dts != AV_NOPTS_VALUE
3239 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3240 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3242 if (t >= (analyzed_all_streams ? max_analyze_duration : max_stream_analyze_duration)) {
3243 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3244 max_analyze_duration,
3246 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3247 av_packet_unref(pkt);
3250 if (pkt->duration) {
3251 st->info->codec_info_duration += pkt->duration;
3252 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3255 #if FF_API_R_FRAME_RATE
3256 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3257 ff_rfps_add_frame(ic, st, pkt->dts);
3259 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3260 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3261 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3262 if (ff_alloc_extradata(st->codec, i))
3263 return AVERROR(ENOMEM);
3264 memcpy(st->codec->extradata, pkt->data,
3265 st->codec->extradata_size);
3269 /* If still no information, we try to open the codec and to
3270 * decompress the frame. We try to avoid that in most cases as
3271 * it takes longer and uses more memory. For MPEG-4, we need to
3272 * decompress for QuickTime.
3274 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3275 * least one frame of codec data, this makes sure the codec initializes
3276 * the channel configuration and does not only trust the values from
3278 try_decode_frame(ic, st, pkt,
3279 (options && i < orig_nb_streams) ? &options[i] : NULL);
3281 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3282 av_packet_unref(pkt);
3284 st->codec_info_nb_frames++;
3289 AVPacket empty_pkt = { 0 };
3291 av_init_packet(&empty_pkt);
3293 for (i = 0; i < ic->nb_streams; i++) {
3295 st = ic->streams[i];
3297 /* flush the decoders */
3298 if (st->info->found_decoder == 1) {
3300 err = try_decode_frame(ic, st, &empty_pkt,
3301 (options && i < orig_nb_streams)
3302 ? &options[i] : NULL);
3303 } while (err > 0 && !has_codec_parameters(st, NULL));
3306 av_log(ic, AV_LOG_INFO,
3307 "decoding for stream %d failed\n", st->index);
3313 // close codecs which were opened in try_decode_frame()
3314 for (i = 0; i < ic->nb_streams; i++) {
3315 st = ic->streams[i];
3316 avcodec_close(st->codec);
3319 ff_rfps_calculate(ic);
3321 for (i = 0; i < ic->nb_streams; i++) {
3322 st = ic->streams[i];
3323 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3324 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3325 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3326 if (avpriv_find_pix_fmt(avpriv_get_raw_pix_fmt_tags(), tag) == st->codec->pix_fmt)
3327 st->codec->codec_tag= tag;
3330 /* estimate average framerate if not set by demuxer */
3331 if (st->info->codec_info_duration_fields &&
3332 !st->avg_frame_rate.num &&
3333 st->info->codec_info_duration) {
3335 double best_error = 0.01;
3337 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3338 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3339 st->info->codec_info_duration < 0)
3341 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3342 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3343 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3345 /* Round guessed framerate to a "standard" framerate if it's
3346 * within 1% of the original estimate. */
3347 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3348 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3349 double error = fabs(av_q2d(st->avg_frame_rate) /
3350 av_q2d(std_fps) - 1);
3352 if (error < best_error) {
3354 best_fps = std_fps.num;
3358 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3359 best_fps, 12 * 1001, INT_MAX);
3362 if (!st->r_frame_rate.num) {
3363 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3364 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3365 st->r_frame_rate.num = st->codec->time_base.den;
3366 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3368 st->r_frame_rate.num = st->time_base.den;
3369 st->r_frame_rate.den = st->time_base.num;
3372 if (st->display_aspect_ratio.num && st->display_aspect_ratio.den) {
3373 AVRational hw_ratio = { st->codec->height, st->codec->width };
3374 st->sample_aspect_ratio = av_mul_q(st->display_aspect_ratio,
3377 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3378 if (!st->codec->bits_per_coded_sample)
3379 st->codec->bits_per_coded_sample =
3380 av_get_bits_per_sample(st->codec->codec_id);
3381 // set stream disposition based on audio service type
3382 switch (st->codec->audio_service_type) {
3383 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3384 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3386 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3387 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3389 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3390 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3392 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3393 st->disposition = AV_DISPOSITION_COMMENT;
3395 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3396 st->disposition = AV_DISPOSITION_KARAOKE;
3403 estimate_timings(ic, old_offset);
3405 av_opt_set(ic, "skip_clear", "0", AV_OPT_SEARCH_CHILDREN);
3407 if (ret >= 0 && ic->nb_streams)
3408 /* We could not have all the codec parameters before EOF. */
3410 for (i = 0; i < ic->nb_streams; i++) {
3412 st = ic->streams[i];
3413 if (!has_codec_parameters(st, &errmsg)) {
3415 avcodec_string(buf, sizeof(buf), st->codec, 0);
3416 av_log(ic, AV_LOG_WARNING,
3417 "Could not find codec parameters for stream %d (%s): %s\n"
3418 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3425 compute_chapters_end(ic);
3427 find_stream_info_err:
3428 for (i = 0; i < ic->nb_streams; i++) {
3429 st = ic->streams[i];
3430 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3431 ic->streams[i]->codec->thread_count = 0;
3433 av_freep(&st->info->duration_error);
3434 av_freep(&ic->streams[i]->info);
3437 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3438 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3442 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3446 for (i = 0; i < ic->nb_programs; i++) {
3447 if (ic->programs[i] == last) {
3451 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3452 if (ic->programs[i]->stream_index[j] == s)
3453 return ic->programs[i];
3459 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3460 int wanted_stream_nb, int related_stream,
3461 AVCodec **decoder_ret, int flags)
3463 int i, nb_streams = ic->nb_streams;
3464 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3465 unsigned *program = NULL;
3466 const AVCodec *decoder = NULL, *best_decoder = NULL;
3468 if (related_stream >= 0 && wanted_stream_nb < 0) {
3469 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3471 program = p->stream_index;
3472 nb_streams = p->nb_stream_indexes;
3475 for (i = 0; i < nb_streams; i++) {
3476 int real_stream_index = program ? program[i] : i;
3477 AVStream *st = ic->streams[real_stream_index];
3478 AVCodecContext *avctx = st->codec;
3479 if (avctx->codec_type != type)
3481 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3483 if (wanted_stream_nb != real_stream_index &&
3484 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3485 AV_DISPOSITION_VISUAL_IMPAIRED))
3487 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3490 decoder = find_decoder(ic, st, st->codec->codec_id);
3493 ret = AVERROR_DECODER_NOT_FOUND;
3497 count = st->codec_info_nb_frames;
3498 bitrate = avctx->bit_rate;
3500 bitrate = avctx->rc_max_rate;
3501 multiframe = FFMIN(5, count);
3502 if ((best_multiframe > multiframe) ||
3503 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3504 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3507 best_bitrate = bitrate;
3508 best_multiframe = multiframe;
3509 ret = real_stream_index;
3510 best_decoder = decoder;
3511 if (program && i == nb_streams - 1 && ret < 0) {
3513 nb_streams = ic->nb_streams;
3514 /* no related stream found, try again with everything */
3519 *decoder_ret = (AVCodec*)best_decoder;
3523 /*******************************************************/
3525 int av_read_play(AVFormatContext *s)
3527 if (s->iformat->read_play)
3528 return s->iformat->read_play(s);
3530 return avio_pause(s->pb, 0);
3531 return AVERROR(ENOSYS);
3534 int av_read_pause(AVFormatContext *s)
3536 if (s->iformat->read_pause)
3537 return s->iformat->read_pause(s);
3539 return avio_pause(s->pb, 1);
3540 return AVERROR(ENOSYS);
3543 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3545 av_assert0(s->nb_streams>0);
3546 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3548 for (j = 0; j < st->nb_side_data; j++)
3549 av_freep(&st->side_data[j].data);
3550 av_freep(&st->side_data);
3551 st->nb_side_data = 0;
3554 av_parser_close(st->parser);
3556 if (st->attached_pic.data)
3557 av_free_packet(&st->attached_pic);
3558 av_dict_free(&st->metadata);
3559 av_freep(&st->probe_data.buf);
3560 av_freep(&st->index_entries);
3561 av_freep(&st->codec->extradata);
3562 av_freep(&st->codec->subtitle_header);
3563 av_freep(&st->codec);
3564 av_freep(&st->priv_data);
3566 av_freep(&st->info->duration_error);
3567 av_freep(&st->info);
3568 av_freep(&st->recommended_encoder_configuration);
3569 av_freep(&s->streams[ --s->nb_streams ]);
3572 void avformat_free_context(AVFormatContext *s)
3580 if (s->iformat && s->iformat->priv_class && s->priv_data)
3581 av_opt_free(s->priv_data);
3582 if (s->oformat && s->oformat->priv_class && s->priv_data)
3583 av_opt_free(s->priv_data);
3585 for (i = s->nb_streams - 1; i >= 0; i--) {
3586 ff_free_stream(s, s->streams[i]);
3588 for (i = s->nb_programs - 1; i >= 0; i--) {
3589 av_dict_free(&s->programs[i]->metadata);
3590 av_freep(&s->programs[i]->stream_index);
3591 av_freep(&s->programs[i]);
3593 av_freep(&s->programs);
3594 av_freep(&s->priv_data);
3595 while (s->nb_chapters--) {
3596 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3597 av_freep(&s->chapters[s->nb_chapters]);
3599 av_freep(&s->chapters);
3600 av_dict_free(&s->metadata);
3601 av_freep(&s->streams);
3602 av_freep(&s->internal);
3603 flush_packet_queue(s);
3607 void avformat_close_input(AVFormatContext **ps)
3618 if ((s->iformat && strcmp(s->iformat->name, "image2") && s->iformat->flags & AVFMT_NOFILE) ||
3619 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3622 flush_packet_queue(s);
3625 if (s->iformat->read_close)
3626 s->iformat->read_close(s);
3628 avformat_free_context(s);
3635 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3641 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3643 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3646 s->streams = streams;
3648 st = av_mallocz(sizeof(AVStream));
3651 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3655 st->info->last_dts = AV_NOPTS_VALUE;
3657 st->codec = avcodec_alloc_context3(c);
3659 /* no default bitrate if decoding */
3660 st->codec->bit_rate = 0;
3662 /* default pts setting is MPEG-like */
3663 avpriv_set_pts_info(st, 33, 1, 90000);
3666 st->index = s->nb_streams;
3667 st->start_time = AV_NOPTS_VALUE;
3668 st->duration = AV_NOPTS_VALUE;
3669 /* we set the current DTS to 0 so that formats without any timestamps
3670 * but durations get some timestamps, formats with some unknown
3671 * timestamps have their first few packets buffered and the
3672 * timestamps corrected before they are returned to the user */
3673 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3674 st->first_dts = AV_NOPTS_VALUE;
3675 st->probe_packets = MAX_PROBE_PACKETS;
3676 st->pts_wrap_reference = AV_NOPTS_VALUE;
3677 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3679 st->last_IP_pts = AV_NOPTS_VALUE;
3680 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3681 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3682 st->pts_buffer[i] = AV_NOPTS_VALUE;
3684 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3686 #if FF_API_R_FRAME_RATE
3687 st->info->last_dts = AV_NOPTS_VALUE;
3689 st->info->fps_first_dts = AV_NOPTS_VALUE;
3690 st->info->fps_last_dts = AV_NOPTS_VALUE;
3692 st->inject_global_side_data = s->internal->inject_global_side_data;
3694 s->streams[s->nb_streams++] = st;
3698 AVProgram *av_new_program(AVFormatContext *ac, int id)
3700 AVProgram *program = NULL;
3703 av_dlog(ac, "new_program: id=0x%04x\n", id);
3705 for (i = 0; i < ac->nb_programs; i++)
3706 if (ac->programs[i]->id == id)
3707 program = ac->programs[i];
3710 program = av_mallocz(sizeof(AVProgram));
3713 dynarray_add(&ac->programs, &ac->nb_programs, program);
3714 program->discard = AVDISCARD_NONE;
3717 program->pts_wrap_reference = AV_NOPTS_VALUE;
3718 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3720 program->start_time =
3721 program->end_time = AV_NOPTS_VALUE;
3726 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3727 int64_t start, int64_t end, const char *title)
3729 AVChapter *chapter = NULL;
3732 if (end != AV_NOPTS_VALUE && start > end) {
3733 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3737 for (i = 0; i < s->nb_chapters; i++)
3738 if (s->chapters[i]->id == id)
3739 chapter = s->chapters[i];
3742 chapter = av_mallocz(sizeof(AVChapter));
3745 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3747 av_dict_set(&chapter->metadata, "title", title, 0);
3749 chapter->time_base = time_base;
3750 chapter->start = start;
3756 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3759 AVProgram *program = NULL;
3762 if (idx >= ac->nb_streams) {
3763 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3767 for (i = 0; i < ac->nb_programs; i++) {
3768 if (ac->programs[i]->id != progid)
3770 program = ac->programs[i];
3771 for (j = 0; j < program->nb_stream_indexes; j++)
3772 if (program->stream_index[j] == idx)
3775 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3778 program->stream_index = tmp;
3779 program->stream_index[program->nb_stream_indexes++] = idx;
3784 uint64_t ff_ntp_time(void)
3786 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3789 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3792 char *q, buf1[20], c;
3793 int nd, len, percentd_found;
3805 while (av_isdigit(*p))
3806 nd = nd * 10 + *p++ - '0';
3808 } while (av_isdigit(c));
3817 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3819 if ((q - buf + len) > buf_size - 1)
3821 memcpy(q, buf1, len);
3829 if ((q - buf) < buf_size - 1)
3833 if (!percentd_found)
3842 void av_url_split(char *proto, int proto_size,
3843 char *authorization, int authorization_size,
3844 char *hostname, int hostname_size,
3845 int *port_ptr, char *path, int path_size, const char *url)
3847 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3853 if (authorization_size > 0)
3854 authorization[0] = 0;
3855 if (hostname_size > 0)
3860 /* parse protocol */
3861 if ((p = strchr(url, ':'))) {
3862 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3869 /* no protocol means plain filename */
3870 av_strlcpy(path, url, path_size);
3874 /* separate path from hostname */
3875 ls = strchr(p, '/');
3876 ls2 = strchr(p, '?');
3880 ls = FFMIN(ls, ls2);
3882 av_strlcpy(path, ls, path_size);
3884 ls = &p[strlen(p)]; // XXX
3886 /* the rest is hostname, use that to parse auth/port */
3888 /* authorization (user[:pass]@hostname) */
3890 while ((at = strchr(p, '@')) && at < ls) {
3891 av_strlcpy(authorization, at2,
3892 FFMIN(authorization_size, at + 1 - at2));
3893 p = at + 1; /* skip '@' */
3896 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3898 av_strlcpy(hostname, p + 1,
3899 FFMIN(hostname_size, brk - p));
3900 if (brk[1] == ':' && port_ptr)
3901 *port_ptr = atoi(brk + 2);
3902 } else if ((col = strchr(p, ':')) && col < ls) {
3903 av_strlcpy(hostname, p,
3904 FFMIN(col + 1 - p, hostname_size));
3906 *port_ptr = atoi(col + 1);
3908 av_strlcpy(hostname, p,
3909 FFMIN(ls + 1 - p, hostname_size));
3913 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3916 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3919 'C', 'D', 'E', 'F' };
3920 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3923 'c', 'd', 'e', 'f' };
3924 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3926 for (i = 0; i < s; i++) {
3927 buff[i * 2] = hex_table[src[i] >> 4];
3928 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3934 int ff_hex_to_data(uint8_t *data, const char *p)
3941 p += strspn(p, SPACE_CHARS);
3944 c = av_toupper((unsigned char) *p++);
3945 if (c >= '0' && c <= '9')
3947 else if (c >= 'A' && c <= 'F')
3962 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3963 unsigned int pts_num, unsigned int pts_den)
3966 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
3967 if (new_tb.num != pts_num)
3968 av_log(NULL, AV_LOG_DEBUG,
3969 "st:%d removing common factor %d from timebase\n",
3970 s->index, pts_num / new_tb.num);
3972 av_log(NULL, AV_LOG_WARNING,
3973 "st:%d has too large timebase, reducing\n", s->index);
3975 if (new_tb.num <= 0 || new_tb.den <= 0) {
3976 av_log(NULL, AV_LOG_ERROR,
3977 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
3978 new_tb.num, new_tb.den,
3982 s->time_base = new_tb;
3983 av_codec_set_pkt_timebase(s->codec, new_tb);
3984 s->pts_wrap_bits = pts_wrap_bits;
3987 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3990 const char *ptr = str;
3992 /* Parse key=value pairs. */
3995 char *dest = NULL, *dest_end;
3996 int key_len, dest_len = 0;
3998 /* Skip whitespace and potential commas. */
3999 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4006 if (!(ptr = strchr(key, '=')))
4009 key_len = ptr - key;
4011 callback_get_buf(context, key, key_len, &dest, &dest_len);
4012 dest_end = dest + dest_len - 1;
4016 while (*ptr && *ptr != '\"') {
4020 if (dest && dest < dest_end)
4024 if (dest && dest < dest_end)
4032 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4033 if (dest && dest < dest_end)
4041 int ff_find_stream_index(AVFormatContext *s, int id)
4044 for (i = 0; i < s->nb_streams; i++)
4045 if (s->streams[i]->id == id)
4050 int64_t ff_iso8601_to_unix_time(const char *datestr)
4052 struct tm time1 = { 0 }, time2 = { 0 };
4054 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4055 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4057 return av_timegm(&time2);
4059 return av_timegm(&time1);
4062 int avformat_query_codec(const AVOutputFormat *ofmt, enum AVCodecID codec_id,
4066 if (ofmt->query_codec)
4067 return ofmt->query_codec(codec_id, std_compliance);
4068 else if (ofmt->codec_tag)
4069 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4070 else if (codec_id == ofmt->video_codec ||
4071 codec_id == ofmt->audio_codec ||
4072 codec_id == ofmt->subtitle_codec)
4075 return AVERROR_PATCHWELCOME;
4078 int avformat_network_init(void)
4082 ff_network_inited_globally = 1;
4083 if ((ret = ff_network_init()) < 0)
4090 int avformat_network_deinit(void)
4099 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4100 uint64_t channel_layout, int32_t sample_rate,
4101 int32_t width, int32_t height)
4107 return AVERROR(EINVAL);
4110 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4112 if (channel_layout) {
4114 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4118 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4120 if (width || height) {
4122 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4124 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4126 return AVERROR(ENOMEM);
4127 bytestream_put_le32(&data, flags);
4129 bytestream_put_le32(&data, channels);
4131 bytestream_put_le64(&data, channel_layout);
4133 bytestream_put_le32(&data, sample_rate);
4134 if (width || height) {
4135 bytestream_put_le32(&data, width);
4136 bytestream_put_le32(&data, height);
4141 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4143 AVRational undef = {0, 1};
4144 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4145 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4146 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4148 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4149 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4150 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4151 stream_sample_aspect_ratio = undef;
4153 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4154 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4155 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4156 frame_sample_aspect_ratio = undef;
4158 if (stream_sample_aspect_ratio.num)
4159 return stream_sample_aspect_ratio;
4161 return frame_sample_aspect_ratio;
4164 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4166 AVRational fr = st->r_frame_rate;
4167 AVRational codec_fr = st->codec->framerate;
4168 AVRational avg_fr = st->avg_frame_rate;
4170 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4171 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4176 if (st->codec->ticks_per_frame > 1) {
4177 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4178 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4185 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4188 if (*spec <= '9' && *spec >= '0') /* opt:index */
4189 return strtol(spec, NULL, 0) == st->index;
4190 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4191 *spec == 't') { /* opt:[vasdt] */
4192 enum AVMediaType type;
4195 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4196 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4197 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4198 case 'd': type = AVMEDIA_TYPE_DATA; break;
4199 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4200 default: av_assert0(0);
4202 if (type != st->codec->codec_type)
4204 if (*spec++ == ':') { /* possibly followed by :index */
4205 int i, index = strtol(spec, NULL, 0);
4206 for (i = 0; i < s->nb_streams; i++)
4207 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4208 return i == st->index;
4212 } else if (*spec == 'p' && *(spec + 1) == ':') {
4216 prog_id = strtol(spec, &endptr, 0);
4217 for (i = 0; i < s->nb_programs; i++) {
4218 if (s->programs[i]->id != prog_id)
4221 if (*endptr++ == ':') {
4222 int stream_idx = strtol(endptr, NULL, 0);
4223 return stream_idx >= 0 &&
4224 stream_idx < s->programs[i]->nb_stream_indexes &&
4225 st->index == s->programs[i]->stream_index[stream_idx];
4228 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4229 if (st->index == s->programs[i]->stream_index[j])
4233 } else if (*spec == '#' ||
4234 (*spec == 'i' && *(spec + 1) == ':')) {
4237 spec += 1 + (*spec == 'i');
4238 stream_id = strtol(spec, &endptr, 0);
4240 return stream_id == st->id;
4241 } else if (*spec == 'm' && *(spec + 1) == ':') {
4242 AVDictionaryEntry *tag;
4247 val = strchr(spec, ':');
4249 key = val ? av_strndup(spec, val - spec) : av_strdup(spec);
4251 return AVERROR(ENOMEM);
4253 tag = av_dict_get(st->metadata, key, NULL, 0);
4255 if (!val || !strcmp(tag->value, val + 1))
4264 } else if (!*spec) /* empty specifier, matches everything */
4267 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4268 return AVERROR(EINVAL);
4271 int ff_generate_avci_extradata(AVStream *st)
4273 static const uint8_t avci100_1080p_extradata[] = {
4275 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4276 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4277 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4278 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4279 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4280 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4281 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4282 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4283 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4285 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4288 static const uint8_t avci100_1080i_extradata[] = {
4290 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4291 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4292 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4293 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4294 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4295 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4296 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4297 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4298 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4299 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4300 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4302 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4305 static const uint8_t avci50_1080p_extradata[] = {
4307 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4308 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4309 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4310 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4311 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4312 0x6e, 0x6c, 0xd3, 0x3c, 0x05, 0xa0, 0x22, 0x7e,
4313 0x5f, 0xfc, 0x00, 0x0c, 0x00, 0x13, 0x8c, 0x04,
4314 0x04, 0x05, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
4315 0x00, 0x03, 0x00, 0x32, 0x84, 0x00, 0x00, 0x00,
4317 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4320 static const uint8_t avci50_1080i_extradata[] = {
4322 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4323 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4324 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4325 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4326 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4327 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4328 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4329 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4330 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4331 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4332 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4334 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4337 static const uint8_t avci100_720p_extradata[] = {
4339 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4340 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4341 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4342 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4343 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4344 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4345 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4346 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4347 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4348 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4350 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4353 static const uint8_t avci50_720p_extradata[] = {
4355 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x20,
4356 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4357 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4358 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6f, 0x37,
4359 0xcd, 0xf9, 0xbf, 0x81, 0x6b, 0xf3, 0x7c, 0xde,
4360 0x6e, 0x6c, 0xd3, 0x3c, 0x0f, 0x01, 0x6e, 0xff,
4361 0xc0, 0x00, 0xc0, 0x01, 0x38, 0xc0, 0x40, 0x40,
4362 0x50, 0x00, 0x00, 0x03, 0x00, 0x10, 0x00, 0x00,
4363 0x06, 0x48, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
4365 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4369 const uint8_t *data = NULL;
4372 if (st->codec->width == 1920) {
4373 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4374 data = avci100_1080p_extradata;
4375 size = sizeof(avci100_1080p_extradata);
4377 data = avci100_1080i_extradata;
4378 size = sizeof(avci100_1080i_extradata);
4380 } else if (st->codec->width == 1440) {
4381 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4382 data = avci50_1080p_extradata;
4383 size = sizeof(avci50_1080p_extradata);
4385 data = avci50_1080i_extradata;
4386 size = sizeof(avci50_1080i_extradata);
4388 } else if (st->codec->width == 1280) {
4389 data = avci100_720p_extradata;
4390 size = sizeof(avci100_720p_extradata);
4391 } else if (st->codec->width == 960) {
4392 data = avci50_720p_extradata;
4393 size = sizeof(avci50_720p_extradata);
4399 av_freep(&st->codec->extradata);
4400 if (ff_alloc_extradata(st->codec, size))
4401 return AVERROR(ENOMEM);
4402 memcpy(st->codec->extradata, data, size);
4407 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4412 for (i = 0; i < st->nb_side_data; i++) {
4413 if (st->side_data[i].type == type) {
4415 *size = st->side_data[i].size;
4416 return st->side_data[i].data;