2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29 #include "libavutil/avassert.h"
30 #include "libavutil/avstring.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mathematics.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/parseutils.h"
36 #include "libavutil/pixdesc.h"
37 #include "libavutil/time.h"
38 #include "libavutil/timestamp.h"
40 #include "libavcodec/bytestream.h"
41 #include "libavcodec/internal.h"
42 #include "libavcodec/raw.h"
44 #include "audiointerleave.h"
46 #include "avio_internal.h"
58 * various utility functions for use within FFmpeg
61 unsigned avformat_version(void)
63 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
64 return LIBAVFORMAT_VERSION_INT;
67 const char *avformat_configuration(void)
69 return FFMPEG_CONFIGURATION;
72 const char *avformat_license(void)
74 #define LICENSE_PREFIX "libavformat license: "
75 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
78 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
80 static int is_relative(int64_t ts) {
81 return ts > (RELATIVE_TS_BASE - (1LL<<48));
85 * Wrap a given time stamp, if there is an indication for an overflow
88 * @param timestamp the time stamp to wrap
89 * @return resulting time stamp
91 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
93 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
94 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
95 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
96 timestamp < st->pts_wrap_reference)
97 return timestamp + (1ULL << st->pts_wrap_bits);
98 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
99 timestamp >= st->pts_wrap_reference)
100 return timestamp - (1ULL << st->pts_wrap_bits);
105 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
106 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
107 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
108 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
109 MAKE_ACCESSORS(AVFormatContext, format, int, metadata_header_padding)
110 MAKE_ACCESSORS(AVFormatContext, format, void *, opaque)
111 MAKE_ACCESSORS(AVFormatContext, format, av_format_control_message, control_message_cb)
113 int64_t av_stream_get_end_pts(const AVStream *st)
118 void av_format_inject_global_side_data(AVFormatContext *s)
121 s->internal->inject_global_side_data = 1;
122 for (i = 0; i < s->nb_streams; i++) {
123 AVStream *st = s->streams[i];
124 st->inject_global_side_data = 1;
128 static const AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
130 if (st->codec->codec)
131 return st->codec->codec;
133 switch (st->codec->codec_type) {
134 case AVMEDIA_TYPE_VIDEO:
135 if (s->video_codec) return s->video_codec;
137 case AVMEDIA_TYPE_AUDIO:
138 if (s->audio_codec) return s->audio_codec;
140 case AVMEDIA_TYPE_SUBTITLE:
141 if (s->subtitle_codec) return s->subtitle_codec;
145 return avcodec_find_decoder(codec_id);
148 int av_format_get_probe_score(const AVFormatContext *s)
150 return s->probe_score;
153 /* an arbitrarily chosen "sane" max packet size -- 50M */
154 #define SANE_CHUNK_SIZE (50000000)
156 int ffio_limit(AVIOContext *s, int size)
158 if (s->maxsize>= 0) {
159 int64_t remaining= s->maxsize - avio_tell(s);
160 if (remaining < size) {
161 int64_t newsize = avio_size(s);
162 if (!s->maxsize || s->maxsize<newsize)
163 s->maxsize = newsize - !newsize;
164 remaining= s->maxsize - avio_tell(s);
165 remaining= FFMAX(remaining, 0);
168 if (s->maxsize>= 0 && remaining+1 < size) {
169 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
176 /* Read the data in sane-sized chunks and append to pkt.
177 * Return the number of bytes read or an error. */
178 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
180 int64_t orig_pos = pkt->pos; // av_grow_packet might reset pos
181 int orig_size = pkt->size;
185 int prev_size = pkt->size;
188 /* When the caller requests a lot of data, limit it to the amount
189 * left in file or SANE_CHUNK_SIZE when it is not known. */
191 if (read_size > SANE_CHUNK_SIZE/10) {
192 read_size = ffio_limit(s, read_size);
193 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
195 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
198 ret = av_grow_packet(pkt, read_size);
202 ret = avio_read(s, pkt->data + prev_size, read_size);
203 if (ret != read_size) {
204 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
211 pkt->flags |= AV_PKT_FLAG_CORRUPT;
216 return pkt->size > orig_size ? pkt->size - orig_size : ret;
219 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
224 pkt->pos = avio_tell(s);
226 return append_packet_chunked(s, pkt, size);
229 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
232 return av_get_packet(s, pkt, size);
233 return append_packet_chunked(s, pkt, size);
236 int av_filename_number_test(const char *filename)
240 (av_get_frame_filename(buf, sizeof(buf), filename, 1) >= 0);
243 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
246 AVProbeData lpd = *pd;
247 AVInputFormat *fmt1 = NULL, *fmt;
248 int score, nodat = 0, score_max = 0;
249 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
252 lpd.buf = zerobuffer;
254 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
255 int id3len = ff_id3v2_tag_len(lpd.buf);
256 if (lpd.buf_size > id3len + 16) {
258 lpd.buf_size -= id3len;
259 } else if (id3len >= PROBE_BUF_MAX) {
266 while ((fmt1 = av_iformat_next(fmt1))) {
267 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
270 if (fmt1->read_probe) {
271 score = fmt1->read_probe(&lpd);
272 if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
273 if (nodat == 0) score = FFMAX(score, 1);
274 else if (nodat == 1) score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
275 else score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
277 } else if (fmt1->extensions) {
278 if (av_match_ext(lpd.filename, fmt1->extensions))
279 score = AVPROBE_SCORE_EXTENSION;
281 if (score > score_max) {
284 } else if (score == score_max)
288 score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
289 *score_ret = score_max;
294 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
297 AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
298 if (score_ret > *score_max) {
299 *score_max = score_ret;
305 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
308 return av_probe_input_format2(pd, is_opened, &score);
311 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st,
314 static const struct {
317 enum AVMediaType type;
319 { "aac", AV_CODEC_ID_AAC, AVMEDIA_TYPE_AUDIO },
320 { "ac3", AV_CODEC_ID_AC3, AVMEDIA_TYPE_AUDIO },
321 { "dts", AV_CODEC_ID_DTS, AVMEDIA_TYPE_AUDIO },
322 { "eac3", AV_CODEC_ID_EAC3, AVMEDIA_TYPE_AUDIO },
323 { "h264", AV_CODEC_ID_H264, AVMEDIA_TYPE_VIDEO },
324 { "hevc", AV_CODEC_ID_HEVC, AVMEDIA_TYPE_VIDEO },
325 { "loas", AV_CODEC_ID_AAC_LATM, AVMEDIA_TYPE_AUDIO },
326 { "m4v", AV_CODEC_ID_MPEG4, AVMEDIA_TYPE_VIDEO },
327 { "mp3", AV_CODEC_ID_MP3, AVMEDIA_TYPE_AUDIO },
328 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
332 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
334 if (fmt && st->request_probe <= score) {
336 av_log(s, AV_LOG_DEBUG,
337 "Probe with size=%d, packets=%d detected %s with score=%d\n",
338 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets,
340 for (i = 0; fmt_id_type[i].name; i++) {
341 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
342 st->codec->codec_id = fmt_id_type[i].id;
343 st->codec->codec_type = fmt_id_type[i].type;
351 /************************************************************/
352 /* input media file */
354 int av_demuxer_open(AVFormatContext *ic) {
357 if (ic->iformat->read_header) {
358 err = ic->iformat->read_header(ic);
363 if (ic->pb && !ic->data_offset)
364 ic->data_offset = avio_tell(ic->pb);
370 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
371 const char *filename, void *logctx,
372 unsigned int offset, unsigned int max_probe_size)
374 AVProbeData pd = { filename ? filename : "" };
377 int ret = 0, probe_size, buf_offset = 0;
381 max_probe_size = PROBE_BUF_MAX;
382 else if (max_probe_size < PROBE_BUF_MIN) {
383 av_log(logctx, AV_LOG_ERROR,
384 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
385 return AVERROR(EINVAL);
388 if (offset >= max_probe_size)
389 return AVERROR(EINVAL);
391 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
392 if (!av_strcasecmp(mime_type, "audio/aacp")) {
393 *fmt = av_find_input_format("aac");
395 av_freep(&mime_type);
398 for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
399 probe_size = FFMIN(probe_size << 1,
400 FFMAX(max_probe_size, probe_size + 1))) {
401 score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
403 /* Read probe data. */
404 if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
406 if ((ret = avio_read(pb, buf + buf_offset,
407 probe_size - buf_offset)) < 0) {
408 /* Fail if error was not end of file, otherwise, lower score. */
409 if (ret != AVERROR_EOF) {
414 ret = 0; /* error was end of file, nothing read */
417 if (buf_offset < offset)
419 pd.buf_size = buf_offset - offset;
420 pd.buf = &buf[offset];
422 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
424 /* Guess file format. */
425 *fmt = av_probe_input_format2(&pd, 1, &score);
427 /* This can only be true in the last iteration. */
428 if (score <= AVPROBE_SCORE_RETRY) {
429 av_log(logctx, AV_LOG_WARNING,
430 "Format %s detected only with low score of %d, "
431 "misdetection possible!\n", (*fmt)->name, score);
433 av_log(logctx, AV_LOG_DEBUG,
434 "Format %s probed with size=%d and score=%d\n",
435 (*fmt)->name, probe_size, score);
437 FILE *f = fopen("probestat.tmp", "ab");
438 fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
446 return AVERROR_INVALIDDATA;
449 /* Rewind. Reuse probe buffer to avoid seeking. */
450 ret = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
452 return ret < 0 ? ret : score;
455 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
456 const char *filename, void *logctx,
457 unsigned int offset, unsigned int max_probe_size)
459 int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
460 return ret < 0 ? ret : 0;
463 /* Open input file and probe the format if necessary. */
464 static int init_input(AVFormatContext *s, const char *filename,
465 AVDictionary **options)
468 AVProbeData pd = { filename, NULL, 0 };
469 int score = AVPROBE_SCORE_RETRY;
472 s->flags |= AVFMT_FLAG_CUSTOM_IO;
474 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
475 s, 0, s->format_probesize);
476 else if (s->iformat->flags & AVFMT_NOFILE)
477 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
478 "will be ignored with AVFMT_NOFILE format.\n");
482 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
483 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
486 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
487 &s->interrupt_callback, options)) < 0)
491 return av_probe_input_buffer2(s->pb, &s->iformat, filename,
492 s, 0, s->format_probesize);
495 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
496 AVPacketList **plast_pktl)
498 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
503 (*plast_pktl)->next = pktl;
505 *packet_buffer = pktl;
507 /* Add the packet in the buffered packet list. */
513 int avformat_queue_attached_pictures(AVFormatContext *s)
516 for (i = 0; i < s->nb_streams; i++)
517 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
518 s->streams[i]->discard < AVDISCARD_ALL) {
519 AVPacket copy = s->streams[i]->attached_pic;
520 if (copy.size <= 0) {
521 av_log(s, AV_LOG_WARNING,
522 "Attached picture on stream %d has invalid size, "
526 copy.buf = av_buffer_ref(copy.buf);
528 return AVERROR(ENOMEM);
530 add_to_pktbuf(&s->raw_packet_buffer, ©,
531 &s->raw_packet_buffer_end);
536 int avformat_open_input(AVFormatContext **ps, const char *filename,
537 AVInputFormat *fmt, AVDictionary **options)
539 AVFormatContext *s = *ps;
541 AVDictionary *tmp = NULL;
542 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
544 if (!s && !(s = avformat_alloc_context()))
545 return AVERROR(ENOMEM);
547 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
548 return AVERROR(EINVAL);
554 av_dict_copy(&tmp, *options, 0);
556 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
559 if ((ret = init_input(s, filename, &tmp)) < 0)
561 s->probe_score = ret;
562 avio_skip(s->pb, s->skip_initial_bytes);
564 /* Check filename in case an image number is expected. */
565 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
566 if (!av_filename_number_test(filename)) {
567 ret = AVERROR(EINVAL);
572 s->duration = s->start_time = AV_NOPTS_VALUE;
573 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
575 /* Allocate private data. */
576 if (s->iformat->priv_data_size > 0) {
577 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
578 ret = AVERROR(ENOMEM);
581 if (s->iformat->priv_class) {
582 *(const AVClass **) s->priv_data = s->iformat->priv_class;
583 av_opt_set_defaults(s->priv_data);
584 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
589 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
591 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta, 0);
593 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
594 if ((ret = s->iformat->read_header(s)) < 0)
597 if (id3v2_extra_meta) {
598 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
599 !strcmp(s->iformat->name, "tta")) {
600 if ((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
603 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
605 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
607 if ((ret = avformat_queue_attached_pictures(s)) < 0)
610 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
611 s->data_offset = avio_tell(s->pb);
613 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
616 av_dict_free(options);
623 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
625 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
627 avformat_free_context(s);
632 /*******************************************************/
634 static void force_codec_ids(AVFormatContext *s, AVStream *st)
636 switch (st->codec->codec_type) {
637 case AVMEDIA_TYPE_VIDEO:
638 if (s->video_codec_id)
639 st->codec->codec_id = s->video_codec_id;
641 case AVMEDIA_TYPE_AUDIO:
642 if (s->audio_codec_id)
643 st->codec->codec_id = s->audio_codec_id;
645 case AVMEDIA_TYPE_SUBTITLE:
646 if (s->subtitle_codec_id)
647 st->codec->codec_id = s->subtitle_codec_id;
652 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
654 if (st->request_probe>0) {
655 AVProbeData *pd = &st->probe_data;
657 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
661 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
663 av_log(s, AV_LOG_WARNING,
664 "Failed to reallocate probe buffer for stream %d\n",
669 memcpy(pd->buf + pd->buf_size, pkt->data, pkt->size);
670 pd->buf_size += pkt->size;
671 memset(pd->buf + pd->buf_size, 0, AVPROBE_PADDING_SIZE);
674 st->probe_packets = 0;
676 av_log(s, AV_LOG_WARNING,
677 "nothing to probe for stream %d\n", st->index);
681 end= s->raw_packet_buffer_remaining_size <= 0
682 || st->probe_packets<= 0;
684 if (end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
685 int score = set_codec_from_probe_data(s, st, pd);
686 if ( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_STREAM_RETRY)
690 st->request_probe = -1;
691 if (st->codec->codec_id != AV_CODEC_ID_NONE) {
692 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
694 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
696 force_codec_ids(s, st);
702 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
704 int64_t ref = pkt->dts;
705 int i, pts_wrap_behavior;
706 int64_t pts_wrap_reference;
707 AVProgram *first_program;
709 if (ref == AV_NOPTS_VALUE)
711 if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
713 ref &= (1LL << st->pts_wrap_bits)-1;
715 // reference time stamp should be 60 s before first time stamp
716 pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
717 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
718 pts_wrap_behavior = (ref < (1LL << st->pts_wrap_bits) - (1LL << st->pts_wrap_bits-3)) ||
719 (ref < (1LL << st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
720 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
722 first_program = av_find_program_from_stream(s, NULL, stream_index);
724 if (!first_program) {
725 int default_stream_index = av_find_default_stream_index(s);
726 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
727 for (i = 0; i < s->nb_streams; i++) {
728 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
729 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
733 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
734 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
738 AVProgram *program = first_program;
740 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
741 pts_wrap_reference = program->pts_wrap_reference;
742 pts_wrap_behavior = program->pts_wrap_behavior;
745 program = av_find_program_from_stream(s, program, stream_index);
748 // update every program with differing pts_wrap_reference
749 program = first_program;
751 if (program->pts_wrap_reference != pts_wrap_reference) {
752 for (i = 0; i<program->nb_stream_indexes; i++) {
753 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
754 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
757 program->pts_wrap_reference = pts_wrap_reference;
758 program->pts_wrap_behavior = pts_wrap_behavior;
760 program = av_find_program_from_stream(s, program, stream_index);
766 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
772 AVPacketList *pktl = s->raw_packet_buffer;
776 st = s->streams[pkt->stream_index];
777 if (s->raw_packet_buffer_remaining_size <= 0)
778 if ((err = probe_codec(s, st, NULL)) < 0)
780 if (st->request_probe <= 0) {
781 s->raw_packet_buffer = pktl->next;
782 s->raw_packet_buffer_remaining_size += pkt->size;
791 ret = s->iformat->read_packet(s, pkt);
793 if (!pktl || ret == AVERROR(EAGAIN))
795 for (i = 0; i < s->nb_streams; i++) {
797 if (st->probe_packets)
798 if ((err = probe_codec(s, st, NULL)) < 0)
800 av_assert0(st->request_probe <= 0);
805 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
806 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
807 av_log(s, AV_LOG_WARNING,
808 "Dropped corrupted packet (stream = %d)\n",
814 if (pkt->stream_index >= (unsigned)s->nb_streams) {
815 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
819 st = s->streams[pkt->stream_index];
821 if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
822 // correct first time stamps to negative values
823 if (!is_relative(st->first_dts))
824 st->first_dts = wrap_timestamp(st, st->first_dts);
825 if (!is_relative(st->start_time))
826 st->start_time = wrap_timestamp(st, st->start_time);
827 if (!is_relative(st->cur_dts))
828 st->cur_dts = wrap_timestamp(st, st->cur_dts);
831 pkt->dts = wrap_timestamp(st, pkt->dts);
832 pkt->pts = wrap_timestamp(st, pkt->pts);
834 force_codec_ids(s, st);
836 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
837 if (s->use_wallclock_as_timestamps)
838 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
840 if (!pktl && st->request_probe <= 0)
843 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
844 s->raw_packet_buffer_remaining_size -= pkt->size;
846 if ((err = probe_codec(s, st, pkt)) < 0)
851 #if FF_API_READ_PACKET
852 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
854 return ff_read_packet(s, pkt);
859 /**********************************************************/
861 static int determinable_frame_size(AVCodecContext *avctx)
863 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
864 avctx->codec_id == AV_CODEC_ID_MP1 ||
865 avctx->codec_id == AV_CODEC_ID_MP2 ||
866 avctx->codec_id == AV_CODEC_ID_MP3/* ||
867 avctx->codec_id == AV_CODEC_ID_CELT*/)
873 * Get the number of samples of an audio frame. Return -1 on error.
875 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
879 /* give frame_size priority if demuxing */
880 if (!mux && enc->frame_size > 1)
881 return enc->frame_size;
883 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
886 /* Fall back on using frame_size if muxing. */
887 if (enc->frame_size > 1)
888 return enc->frame_size;
890 //For WMA we currently have no other means to calculate duration thus we
891 //do it here by assuming CBR, which is true for all known cases.
892 if (!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
893 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
894 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
901 * Return the frame duration in seconds. Return 0 if not available.
903 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
904 AVCodecParserContext *pc, AVPacket *pkt)
910 switch (st->codec->codec_type) {
911 case AVMEDIA_TYPE_VIDEO:
912 if (st->r_frame_rate.num && !pc) {
913 *pnum = st->r_frame_rate.den;
914 *pden = st->r_frame_rate.num;
915 } else if (st->time_base.num * 1000LL > st->time_base.den) {
916 *pnum = st->time_base.num;
917 *pden = st->time_base.den;
918 } else if (st->codec->time_base.num * 1000LL > st->codec->time_base.den) {
919 *pnum = st->codec->time_base.num;
920 *pden = st->codec->time_base.den;
921 if (pc && pc->repeat_pict) {
922 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
923 *pden /= 1 + pc->repeat_pict;
925 *pnum *= 1 + pc->repeat_pict;
927 /* If this codec can be interlaced or progressive then we need
928 * a parser to compute duration of a packet. Thus if we have
929 * no parser in such case leave duration undefined. */
930 if (st->codec->ticks_per_frame > 1 && !pc)
934 case AVMEDIA_TYPE_AUDIO:
935 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
936 if (frame_size <= 0 || st->codec->sample_rate <= 0)
939 *pden = st->codec->sample_rate;
946 static int is_intra_only(AVCodecContext *enc) {
947 const AVCodecDescriptor *desc;
949 if (enc->codec_type != AVMEDIA_TYPE_VIDEO)
952 desc = av_codec_get_codec_descriptor(enc);
954 desc = avcodec_descriptor_get(enc->codec_id);
955 av_codec_set_codec_descriptor(enc, desc);
958 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
962 static int has_decode_delay_been_guessed(AVStream *st)
964 if (st->codec->codec_id != AV_CODEC_ID_H264) return 1;
965 if (!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
967 #if CONFIG_H264_DECODER
968 if (st->codec->has_b_frames &&
969 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
972 if (st->codec->has_b_frames<3)
973 return st->nb_decoded_frames >= 7;
974 else if (st->codec->has_b_frames<4)
975 return st->nb_decoded_frames >= 18;
977 return st->nb_decoded_frames >= 20;
980 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
984 if (pktl == s->packet_buffer_end)
985 return s->parse_queue;
989 static int64_t select_from_pts_buffer(AVStream *st, int64_t *pts_buffer, int64_t dts) {
990 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
991 st->codec->codec_id != AV_CODEC_ID_HEVC;
994 int delay = st->codec->has_b_frames;
997 if (dts == AV_NOPTS_VALUE) {
998 int64_t best_score = INT64_MAX;
999 for (i = 0; i<delay; i++) {
1000 if (st->pts_reorder_error_count[i]) {
1001 int64_t score = st->pts_reorder_error[i] / st->pts_reorder_error_count[i];
1002 if (score < best_score) {
1004 dts = pts_buffer[i];
1009 for (i = 0; i<delay; i++) {
1010 if (pts_buffer[i] != AV_NOPTS_VALUE) {
1011 int64_t diff = FFABS(pts_buffer[i] - dts)
1012 + (uint64_t)st->pts_reorder_error[i];
1013 diff = FFMAX(diff, st->pts_reorder_error[i]);
1014 st->pts_reorder_error[i] = diff;
1015 st->pts_reorder_error_count[i]++;
1016 if (st->pts_reorder_error_count[i] > 250) {
1017 st->pts_reorder_error[i] >>= 1;
1018 st->pts_reorder_error_count[i] >>= 1;
1025 if (dts == AV_NOPTS_VALUE)
1026 dts = pts_buffer[0];
1031 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1032 int64_t dts, int64_t pts, AVPacket *pkt)
1034 AVStream *st = s->streams[stream_index];
1035 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1036 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1040 if (st->first_dts != AV_NOPTS_VALUE ||
1041 dts == AV_NOPTS_VALUE ||
1042 st->cur_dts == AV_NOPTS_VALUE ||
1046 delay = st->codec->has_b_frames;
1047 st->first_dts = dts - (st->cur_dts - RELATIVE_TS_BASE);
1049 shift = st->first_dts - RELATIVE_TS_BASE;
1051 for (i = 0; i<MAX_REORDER_DELAY+1; i++)
1052 pts_buffer[i] = AV_NOPTS_VALUE;
1054 if (is_relative(pts))
1057 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1058 if (pktl->pkt.stream_index != stream_index)
1060 if (is_relative(pktl->pkt.pts))
1061 pktl->pkt.pts += shift;
1063 if (is_relative(pktl->pkt.dts))
1064 pktl->pkt.dts += shift;
1066 if (st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1067 st->start_time = pktl->pkt.pts;
1069 if (pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1070 pts_buffer[0] = pktl->pkt.pts;
1071 for (i = 0; i<delay && pts_buffer[i] > pts_buffer[i + 1]; i++)
1072 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i + 1]);
1074 pktl->pkt.dts = select_from_pts_buffer(st, pts_buffer, pktl->pkt.dts);
1078 if (st->start_time == AV_NOPTS_VALUE)
1079 st->start_time = pts;
1082 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1083 int stream_index, int duration)
1085 AVPacketList *pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1086 int64_t cur_dts = RELATIVE_TS_BASE;
1088 if (st->first_dts != AV_NOPTS_VALUE) {
1089 if (st->update_initial_durations_done)
1091 st->update_initial_durations_done = 1;
1092 cur_dts = st->first_dts;
1093 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1094 if (pktl->pkt.stream_index == stream_index) {
1095 if (pktl->pkt.pts != pktl->pkt.dts ||
1096 pktl->pkt.dts != AV_NOPTS_VALUE ||
1099 cur_dts -= duration;
1102 if (pktl && pktl->pkt.dts != st->first_dts) {
1103 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1104 av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1108 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1111 pktl = s->packet_buffer ? s->packet_buffer : s->parse_queue;
1112 st->first_dts = cur_dts;
1113 } else if (st->cur_dts != RELATIVE_TS_BASE)
1116 for (; pktl; pktl = get_next_pkt(s, st, pktl)) {
1117 if (pktl->pkt.stream_index != stream_index)
1119 if (pktl->pkt.pts == pktl->pkt.dts &&
1120 (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts) &&
1121 !pktl->pkt.duration) {
1122 pktl->pkt.dts = cur_dts;
1123 if (!st->codec->has_b_frames)
1124 pktl->pkt.pts = cur_dts;
1125 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1126 pktl->pkt.duration = duration;
1129 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1132 st->cur_dts = cur_dts;
1135 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1136 AVCodecParserContext *pc, AVPacket *pkt)
1138 int num, den, presentation_delayed, delay, i;
1140 AVRational duration;
1141 int onein_oneout = st->codec->codec_id != AV_CODEC_ID_H264 &&
1142 st->codec->codec_id != AV_CODEC_ID_HEVC;
1144 if (s->flags & AVFMT_FLAG_NOFILLIN)
1147 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && pkt->dts != AV_NOPTS_VALUE) {
1148 if (pkt->dts == pkt->pts && st->last_dts_for_order_check != AV_NOPTS_VALUE) {
1149 if (st->last_dts_for_order_check <= pkt->dts) {
1152 av_log(s, st->dts_misordered ? AV_LOG_DEBUG : AV_LOG_WARNING,
1153 "DTS %"PRIi64" < %"PRIi64" out of order\n",
1155 st->last_dts_for_order_check);
1156 st->dts_misordered++;
1158 if (st->dts_ordered + st->dts_misordered > 250) {
1159 st->dts_ordered >>= 1;
1160 st->dts_misordered >>= 1;
1164 st->last_dts_for_order_check = pkt->dts;
1165 if (st->dts_ordered < 8*st->dts_misordered && pkt->dts == pkt->pts)
1166 pkt->dts = AV_NOPTS_VALUE;
1169 if ((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1170 pkt->dts = AV_NOPTS_VALUE;
1172 if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1173 && !st->codec->has_b_frames)
1174 //FIXME Set low_delay = 0 when has_b_frames = 1
1175 st->codec->has_b_frames = 1;
1177 /* do we have a video B-frame ? */
1178 delay = st->codec->has_b_frames;
1179 presentation_delayed = 0;
1181 /* XXX: need has_b_frame, but cannot get it if the codec is
1182 * not initialized */
1184 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1185 presentation_delayed = 1;
1187 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1188 st->pts_wrap_bits < 63 &&
1189 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1190 if (is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits - 1)) > st->cur_dts) {
1191 pkt->dts -= 1LL << st->pts_wrap_bits;
1193 pkt->pts += 1LL << st->pts_wrap_bits;
1196 /* Some MPEG-2 in MPEG-PS lack dts (issue #171 / input_file.mpg).
1197 * We take the conservative approach and discard both.
1198 * Note: If this is misbehaving for an H.264 file, then possibly
1199 * presentation_delayed is not set correctly. */
1200 if (delay == 1 && pkt->dts == pkt->pts &&
1201 pkt->dts != AV_NOPTS_VALUE && presentation_delayed) {
1202 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1203 if ( strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")
1204 && strcmp(s->iformat->name, "flv")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1205 pkt->dts = AV_NOPTS_VALUE;
1208 duration = av_mul_q((AVRational) {pkt->duration, 1}, st->time_base);
1209 if (pkt->duration == 0) {
1210 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1212 duration = (AVRational) {num, den};
1213 pkt->duration = av_rescale_rnd(1,
1214 num * (int64_t) st->time_base.den,
1215 den * (int64_t) st->time_base.num,
1220 if (pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1221 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1223 /* Correct timestamps with byte offset if demuxers only have timestamps
1224 * on packet boundaries */
1225 if (pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size) {
1226 /* this will estimate bitrate based on this frame's duration and size */
1227 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1228 if (pkt->pts != AV_NOPTS_VALUE)
1230 if (pkt->dts != AV_NOPTS_VALUE)
1234 /* This may be redundant, but it should not hurt. */
1235 if (pkt->dts != AV_NOPTS_VALUE &&
1236 pkt->pts != AV_NOPTS_VALUE &&
1237 pkt->pts > pkt->dts)
1238 presentation_delayed = 1;
1241 "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1242 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts),
1243 pkt->stream_index, pc, pkt->duration);
1244 /* Interpolate PTS and DTS if they are not present. We skip H264
1245 * currently because delay and has_b_frames are not reliably set. */
1246 if ((delay == 0 || (delay == 1 && pc)) &&
1248 if (presentation_delayed) {
1249 /* DTS = decompression timestamp */
1250 /* PTS = presentation timestamp */
1251 if (pkt->dts == AV_NOPTS_VALUE)
1252 pkt->dts = st->last_IP_pts;
1253 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1254 if (pkt->dts == AV_NOPTS_VALUE)
1255 pkt->dts = st->cur_dts;
1257 /* This is tricky: the dts must be incremented by the duration
1258 * of the frame we are displaying, i.e. the last I- or P-frame. */
1259 if (st->last_IP_duration == 0)
1260 st->last_IP_duration = pkt->duration;
1261 if (pkt->dts != AV_NOPTS_VALUE)
1262 st->cur_dts = pkt->dts + st->last_IP_duration;
1263 st->last_IP_duration = pkt->duration;
1264 st->last_IP_pts = pkt->pts;
1265 /* Cannot compute PTS if not present (we can compute it only
1266 * by knowing the future. */
1267 } else if (pkt->pts != AV_NOPTS_VALUE ||
1268 pkt->dts != AV_NOPTS_VALUE ||
1271 /* presentation is not delayed : PTS and DTS are the same */
1272 if (pkt->pts == AV_NOPTS_VALUE)
1273 pkt->pts = pkt->dts;
1274 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1276 if (pkt->pts == AV_NOPTS_VALUE)
1277 pkt->pts = st->cur_dts;
1278 pkt->dts = pkt->pts;
1279 if (pkt->pts != AV_NOPTS_VALUE)
1280 st->cur_dts = av_add_stable(st->time_base, pkt->pts, duration, 1);
1284 if (pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)) {
1285 st->pts_buffer[0] = pkt->pts;
1286 for (i = 0; i<delay && st->pts_buffer[i] > st->pts_buffer[i + 1]; i++)
1287 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i + 1]);
1289 pkt->dts = select_from_pts_buffer(st, st->pts_buffer, pkt->dts);
1291 // We skipped it above so we try here.
1293 // This should happen on the first packet
1294 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1295 if (pkt->dts > st->cur_dts)
1296 st->cur_dts = pkt->dts;
1298 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1299 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1302 if (is_intra_only(st->codec))
1303 pkt->flags |= AV_PKT_FLAG_KEY;
1305 pkt->convergence_duration = pc->convergence_duration;
1308 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1311 AVPacketList *pktl = *pkt_buf;
1312 *pkt_buf = pktl->next;
1313 av_free_packet(&pktl->pkt);
1316 *pkt_buf_end = NULL;
1320 * Parse a packet, add all split parts to parse_queue.
1322 * @param pkt Packet to parse, NULL when flushing the parser at end of stream.
1324 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1326 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1327 AVStream *st = s->streams[stream_index];
1328 uint8_t *data = pkt ? pkt->data : NULL;
1329 int size = pkt ? pkt->size : 0;
1330 int ret = 0, got_output = 0;
1333 av_init_packet(&flush_pkt);
1336 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1337 // preserve 0-size sync packets
1338 compute_pkt_fields(s, st, st->parser, pkt);
1341 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1344 av_init_packet(&out_pkt);
1345 len = av_parser_parse2(st->parser, st->codec,
1346 &out_pkt.data, &out_pkt.size, data, size,
1347 pkt->pts, pkt->dts, pkt->pos);
1349 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1351 /* increment read pointer */
1355 got_output = !!out_pkt.size;
1360 if (pkt->side_data) {
1361 out_pkt.side_data = pkt->side_data;
1362 out_pkt.side_data_elems = pkt->side_data_elems;
1363 pkt->side_data = NULL;
1364 pkt->side_data_elems = 0;
1367 /* set the duration */
1368 out_pkt.duration = 0;
1369 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1370 if (st->codec->sample_rate > 0) {
1372 av_rescale_q_rnd(st->parser->duration,
1373 (AVRational) { 1, st->codec->sample_rate },
1379 out_pkt.stream_index = st->index;
1380 out_pkt.pts = st->parser->pts;
1381 out_pkt.dts = st->parser->dts;
1382 out_pkt.pos = st->parser->pos;
1384 if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1385 out_pkt.pos = st->parser->frame_offset;
1387 if (st->parser->key_frame == 1 ||
1388 (st->parser->key_frame == -1 &&
1389 st->parser->pict_type == AV_PICTURE_TYPE_I))
1390 out_pkt.flags |= AV_PKT_FLAG_KEY;
1392 if (st->parser->key_frame == -1 && st->parser->pict_type ==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1393 out_pkt.flags |= AV_PKT_FLAG_KEY;
1395 compute_pkt_fields(s, st, st->parser, &out_pkt);
1397 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1398 out_pkt.buf = pkt->buf;
1400 #if FF_API_DESTRUCT_PACKET
1401 FF_DISABLE_DEPRECATION_WARNINGS
1402 out_pkt.destruct = pkt->destruct;
1403 pkt->destruct = NULL;
1404 FF_ENABLE_DEPRECATION_WARNINGS
1407 if ((ret = av_dup_packet(&out_pkt)) < 0)
1410 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1411 av_free_packet(&out_pkt);
1412 ret = AVERROR(ENOMEM);
1417 /* end of the stream => close and free the parser */
1418 if (pkt == &flush_pkt) {
1419 av_parser_close(st->parser);
1424 av_free_packet(pkt);
1428 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1429 AVPacketList **pkt_buffer_end,
1433 av_assert0(*pkt_buffer);
1436 *pkt_buffer = pktl->next;
1438 *pkt_buffer_end = NULL;
1443 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1445 int ret = 0, i, got_packet = 0;
1447 av_init_packet(pkt);
1449 while (!got_packet && !s->parse_queue) {
1453 /* read next packet */
1454 ret = ff_read_packet(s, &cur_pkt);
1456 if (ret == AVERROR(EAGAIN))
1458 /* flush the parsers */
1459 for (i = 0; i < s->nb_streams; i++) {
1461 if (st->parser && st->need_parsing)
1462 parse_packet(s, NULL, st->index);
1464 /* all remaining packets are now in parse_queue =>
1465 * really terminate parsing */
1469 st = s->streams[cur_pkt.stream_index];
1471 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1472 cur_pkt.dts != AV_NOPTS_VALUE &&
1473 cur_pkt.pts < cur_pkt.dts) {
1474 av_log(s, AV_LOG_WARNING,
1475 "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1476 cur_pkt.stream_index,
1477 av_ts2str(cur_pkt.pts),
1478 av_ts2str(cur_pkt.dts),
1481 if (s->debug & FF_FDEBUG_TS)
1482 av_log(s, AV_LOG_DEBUG,
1483 "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1484 cur_pkt.stream_index,
1485 av_ts2str(cur_pkt.pts),
1486 av_ts2str(cur_pkt.dts),
1487 cur_pkt.size, cur_pkt.duration, cur_pkt.flags);
1489 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1490 st->parser = av_parser_init(st->codec->codec_id);
1492 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1493 "%s, packets or times may be invalid.\n",
1494 avcodec_get_name(st->codec->codec_id));
1495 /* no parser available: just output the raw packets */
1496 st->need_parsing = AVSTREAM_PARSE_NONE;
1497 } else if (st->need_parsing == AVSTREAM_PARSE_HEADERS)
1498 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1499 else if (st->need_parsing == AVSTREAM_PARSE_FULL_ONCE)
1500 st->parser->flags |= PARSER_FLAG_ONCE;
1501 else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1502 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1505 if (!st->need_parsing || !st->parser) {
1506 /* no parsing needed: we just output the packet as is */
1508 compute_pkt_fields(s, st, NULL, pkt);
1509 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1510 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1511 ff_reduce_index(s, st->index);
1512 av_add_index_entry(st, pkt->pos, pkt->dts,
1513 0, 0, AVINDEX_KEYFRAME);
1516 } else if (st->discard < AVDISCARD_ALL) {
1517 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1521 av_free_packet(&cur_pkt);
1523 if (pkt->flags & AV_PKT_FLAG_KEY)
1524 st->skip_to_keyframe = 0;
1525 if (st->skip_to_keyframe) {
1526 av_free_packet(&cur_pkt);
1534 if (!got_packet && s->parse_queue)
1535 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1538 AVStream *st = s->streams[pkt->stream_index];
1539 if (st->skip_samples) {
1540 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1542 AV_WL32(p, st->skip_samples);
1543 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1545 st->skip_samples = 0;
1548 if (st->inject_global_side_data) {
1549 for (i = 0; i < st->nb_side_data; i++) {
1550 AVPacketSideData *src_sd = &st->side_data[i];
1553 if (av_packet_get_side_data(pkt, src_sd->type, NULL))
1556 dst_data = av_packet_new_side_data(pkt, src_sd->type, src_sd->size);
1558 av_log(s, AV_LOG_WARNING, "Could not inject global side data\n");
1562 memcpy(dst_data, src_sd->data, src_sd->size);
1564 st->inject_global_side_data = 0;
1567 if (!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1568 av_packet_merge_side_data(pkt);
1571 if (s->debug & FF_FDEBUG_TS)
1572 av_log(s, AV_LOG_DEBUG,
1573 "read_frame_internal stream=%d, pts=%s, dts=%s, "
1574 "size=%d, duration=%d, flags=%d\n",
1576 av_ts2str(pkt->pts),
1577 av_ts2str(pkt->dts),
1578 pkt->size, pkt->duration, pkt->flags);
1583 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1585 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1591 ret = s->packet_buffer
1592 ? read_from_packet_buffer(&s->packet_buffer,
1593 &s->packet_buffer_end, pkt)
1594 : read_frame_internal(s, pkt);
1601 AVPacketList *pktl = s->packet_buffer;
1604 AVPacket *next_pkt = &pktl->pkt;
1606 if (next_pkt->dts != AV_NOPTS_VALUE) {
1607 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1608 // last dts seen for this stream. if any of packets following
1609 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1610 int64_t last_dts = next_pkt->dts;
1611 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1612 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1613 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1614 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) {
1616 next_pkt->pts = pktl->pkt.dts;
1618 if (last_dts != AV_NOPTS_VALUE) {
1619 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1620 last_dts = pktl->pkt.dts;
1625 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1626 // Fixing the last reference frame had none pts issue (For MXF etc).
1627 // We only do this when
1629 // 2. we are not able to resolve a pts value for current packet.
1630 // 3. the packets for this stream at the end of the files had valid dts.
1631 next_pkt->pts = last_dts + next_pkt->duration;
1633 pktl = s->packet_buffer;
1636 /* read packet from packet buffer, if there is data */
1637 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1638 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1639 ret = read_from_packet_buffer(&s->packet_buffer,
1640 &s->packet_buffer_end, pkt);
1645 ret = read_frame_internal(s, pkt);
1647 if (pktl && ret != AVERROR(EAGAIN)) {
1654 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1655 &s->packet_buffer_end)) < 0)
1656 return AVERROR(ENOMEM);
1661 st = s->streams[pkt->stream_index];
1662 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1663 ff_reduce_index(s, st->index);
1664 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1667 if (is_relative(pkt->dts))
1668 pkt->dts -= RELATIVE_TS_BASE;
1669 if (is_relative(pkt->pts))
1670 pkt->pts -= RELATIVE_TS_BASE;
1675 /* XXX: suppress the packet queue */
1676 static void flush_packet_queue(AVFormatContext *s)
1678 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1679 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1680 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1682 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1685 /*******************************************************/
1688 int av_find_default_stream_index(AVFormatContext *s)
1690 int first_audio_index = -1;
1694 if (s->nb_streams <= 0)
1696 for (i = 0; i < s->nb_streams; i++) {
1698 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1699 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1702 if (first_audio_index < 0 &&
1703 st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1704 first_audio_index = i;
1706 return first_audio_index >= 0 ? first_audio_index : 0;
1709 /** Flush the frame reader. */
1710 void ff_read_frame_flush(AVFormatContext *s)
1715 flush_packet_queue(s);
1717 /* Reset read state for each stream. */
1718 for (i = 0; i < s->nb_streams; i++) {
1722 av_parser_close(st->parser);
1725 st->last_IP_pts = AV_NOPTS_VALUE;
1726 st->last_dts_for_order_check = AV_NOPTS_VALUE;
1727 if (st->first_dts == AV_NOPTS_VALUE)
1728 st->cur_dts = RELATIVE_TS_BASE;
1730 /* We set the current DTS to an unspecified origin. */
1731 st->cur_dts = AV_NOPTS_VALUE;
1733 st->probe_packets = MAX_PROBE_PACKETS;
1735 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
1736 st->pts_buffer[j] = AV_NOPTS_VALUE;
1738 if (s->internal->inject_global_side_data)
1739 st->inject_global_side_data = 1;
1743 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1747 for (i = 0; i < s->nb_streams; i++) {
1748 AVStream *st = s->streams[i];
1751 av_rescale(timestamp,
1752 st->time_base.den * (int64_t) ref_st->time_base.num,
1753 st->time_base.num * (int64_t) ref_st->time_base.den);
1757 void ff_reduce_index(AVFormatContext *s, int stream_index)
1759 AVStream *st = s->streams[stream_index];
1760 unsigned int max_entries = s->max_index_size / sizeof(AVIndexEntry);
1762 if ((unsigned) st->nb_index_entries >= max_entries) {
1764 for (i = 0; 2 * i < st->nb_index_entries; i++)
1765 st->index_entries[i] = st->index_entries[2 * i];
1766 st->nb_index_entries = i;
1770 int ff_add_index_entry(AVIndexEntry **index_entries,
1771 int *nb_index_entries,
1772 unsigned int *index_entries_allocated_size,
1773 int64_t pos, int64_t timestamp,
1774 int size, int distance, int flags)
1776 AVIndexEntry *entries, *ie;
1779 if ((unsigned) *nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1782 if (timestamp == AV_NOPTS_VALUE)
1783 return AVERROR(EINVAL);
1785 if (size < 0 || size > 0x3FFFFFFF)
1786 return AVERROR(EINVAL);
1788 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1789 timestamp -= RELATIVE_TS_BASE;
1791 entries = av_fast_realloc(*index_entries,
1792 index_entries_allocated_size,
1793 (*nb_index_entries + 1) *
1794 sizeof(AVIndexEntry));
1798 *index_entries = entries;
1800 index = ff_index_search_timestamp(*index_entries, *nb_index_entries,
1801 timestamp, AVSEEK_FLAG_ANY);
1804 index = (*nb_index_entries)++;
1805 ie = &entries[index];
1806 av_assert0(index == 0 || ie[-1].timestamp < timestamp);
1808 ie = &entries[index];
1809 if (ie->timestamp != timestamp) {
1810 if (ie->timestamp <= timestamp)
1812 memmove(entries + index + 1, entries + index,
1813 sizeof(AVIndexEntry) * (*nb_index_entries - index));
1814 (*nb_index_entries)++;
1815 } else if (ie->pos == pos && distance < ie->min_distance)
1816 // do not reduce the distance
1817 distance = ie->min_distance;
1821 ie->timestamp = timestamp;
1822 ie->min_distance = distance;
1829 int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
1830 int size, int distance, int flags)
1832 timestamp = wrap_timestamp(st, timestamp);
1833 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1834 &st->index_entries_allocated_size, pos,
1835 timestamp, size, distance, flags);
1838 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1839 int64_t wanted_timestamp, int flags)
1847 // Optimize appending index entries at the end.
1848 if (b && entries[b - 1].timestamp < wanted_timestamp)
1853 timestamp = entries[m].timestamp;
1854 if (timestamp >= wanted_timestamp)
1856 if (timestamp <= wanted_timestamp)
1859 m = (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1861 if (!(flags & AVSEEK_FLAG_ANY))
1862 while (m >= 0 && m < nb_entries &&
1863 !(entries[m].flags & AVINDEX_KEYFRAME))
1864 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1866 if (m == nb_entries)
1871 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp, int flags)
1873 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1874 wanted_timestamp, flags);
1877 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1878 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1880 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1881 if (stream_index >= 0)
1882 ts = wrap_timestamp(s->streams[stream_index], ts);
1886 int ff_seek_frame_binary(AVFormatContext *s, int stream_index,
1887 int64_t target_ts, int flags)
1889 AVInputFormat *avif = s->iformat;
1890 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1891 int64_t ts_min, ts_max, ts;
1896 if (stream_index < 0)
1899 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1902 ts_min = AV_NOPTS_VALUE;
1903 pos_limit = -1; // GCC falsely says it may be uninitialized.
1905 st = s->streams[stream_index];
1906 if (st->index_entries) {
1909 /* FIXME: Whole function must be checked for non-keyframe entries in
1910 * index case, especially read_timestamp(). */
1911 index = av_index_search_timestamp(st, target_ts,
1912 flags | AVSEEK_FLAG_BACKWARD);
1913 index = FFMAX(index, 0);
1914 e = &st->index_entries[index];
1916 if (e->timestamp <= target_ts || e->pos == e->min_distance) {
1918 ts_min = e->timestamp;
1919 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1920 pos_min, av_ts2str(ts_min));
1922 av_assert1(index == 0);
1925 index = av_index_search_timestamp(st, target_ts,
1926 flags & ~AVSEEK_FLAG_BACKWARD);
1927 av_assert0(index < st->nb_index_entries);
1929 e = &st->index_entries[index];
1930 av_assert1(e->timestamp >= target_ts);
1932 ts_max = e->timestamp;
1933 pos_limit = pos_max - e->min_distance;
1934 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64
1935 " dts_max=%s\n", pos_max, pos_limit, av_ts2str(ts_max));
1939 pos = ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit,
1940 ts_min, ts_max, flags, &ts, avif->read_timestamp);
1945 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1948 ff_read_frame_flush(s);
1949 ff_update_cur_dts(s, st, ts);
1954 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1955 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1957 int64_t step = 1024;
1958 int64_t limit, ts_max;
1959 int64_t filesize = avio_size(s->pb);
1960 int64_t pos_max = filesize - 1;
1963 pos_max = FFMAX(0, (pos_max) - step);
1964 ts_max = ff_read_timestamp(s, stream_index,
1965 &pos_max, limit, read_timestamp);
1967 } while (ts_max == AV_NOPTS_VALUE && 2*limit > step);
1968 if (ts_max == AV_NOPTS_VALUE)
1972 int64_t tmp_pos = pos_max + 1;
1973 int64_t tmp_ts = ff_read_timestamp(s, stream_index,
1974 &tmp_pos, INT64_MAX, read_timestamp);
1975 if (tmp_ts == AV_NOPTS_VALUE)
1977 av_assert0(tmp_pos > pos_max);
1980 if (tmp_pos >= filesize)
1992 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1993 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1994 int64_t ts_min, int64_t ts_max,
1995 int flags, int64_t *ts_ret,
1996 int64_t (*read_timestamp)(struct AVFormatContext *, int,
1997 int64_t *, int64_t))
2004 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
2006 if (ts_min == AV_NOPTS_VALUE) {
2007 pos_min = s->data_offset;
2008 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2009 if (ts_min == AV_NOPTS_VALUE)
2013 if (ts_min >= target_ts) {
2018 if (ts_max == AV_NOPTS_VALUE) {
2019 if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
2021 pos_limit = pos_max;
2024 if (ts_max <= target_ts) {
2029 if (ts_min > ts_max)
2031 else if (ts_min == ts_max)
2032 pos_limit = pos_min;
2035 while (pos_min < pos_limit) {
2037 "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
2038 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
2039 assert(pos_limit <= pos_max);
2041 if (no_change == 0) {
2042 int64_t approximate_keyframe_distance = pos_max - pos_limit;
2043 // interpolate position (better than dichotomy)
2044 pos = av_rescale(target_ts - ts_min, pos_max - pos_min,
2046 pos_min - approximate_keyframe_distance;
2047 } else if (no_change == 1) {
2048 // bisection if interpolation did not change min / max pos last time
2049 pos = (pos_min + pos_limit) >> 1;
2051 /* linear search if bisection failed, can only happen if there
2052 * are very few or no keyframes between min/max */
2057 else if (pos > pos_limit)
2061 // May pass pos_limit instead of -1.
2062 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp);
2067 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s"
2068 " target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
2069 pos_min, pos, pos_max,
2070 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
2071 pos_limit, start_pos, no_change);
2072 if (ts == AV_NOPTS_VALUE) {
2073 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
2076 assert(ts != AV_NOPTS_VALUE);
2077 if (target_ts <= ts) {
2078 pos_limit = start_pos - 1;
2082 if (target_ts >= ts) {
2088 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
2089 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2092 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2094 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2095 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2096 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2102 static int seek_frame_byte(AVFormatContext *s, int stream_index,
2103 int64_t pos, int flags)
2105 int64_t pos_min, pos_max;
2107 pos_min = s->data_offset;
2108 pos_max = avio_size(s->pb) - 1;
2112 else if (pos > pos_max)
2115 avio_seek(s->pb, pos, SEEK_SET);
2117 s->io_repositioned = 1;
2122 static int seek_frame_generic(AVFormatContext *s, int stream_index,
2123 int64_t timestamp, int flags)
2130 st = s->streams[stream_index];
2132 index = av_index_search_timestamp(st, timestamp, flags);
2134 if (index < 0 && st->nb_index_entries &&
2135 timestamp < st->index_entries[0].timestamp)
2138 if (index < 0 || index == st->nb_index_entries - 1) {
2142 if (st->nb_index_entries) {
2143 av_assert0(st->index_entries);
2144 ie = &st->index_entries[st->nb_index_entries - 1];
2145 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2147 ff_update_cur_dts(s, st, ie->timestamp);
2149 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2155 read_status = av_read_frame(s, &pkt);
2156 } while (read_status == AVERROR(EAGAIN));
2157 if (read_status < 0)
2159 av_free_packet(&pkt);
2160 if (stream_index == pkt.stream_index && pkt.dts > timestamp) {
2161 if (pkt.flags & AV_PKT_FLAG_KEY)
2163 if (nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS) {
2164 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);
2169 index = av_index_search_timestamp(st, timestamp, flags);
2174 ff_read_frame_flush(s);
2175 if (s->iformat->read_seek)
2176 if (s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2178 ie = &st->index_entries[index];
2179 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2181 ff_update_cur_dts(s, st, ie->timestamp);
2186 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2187 int64_t timestamp, int flags)
2192 if (flags & AVSEEK_FLAG_BYTE) {
2193 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2195 ff_read_frame_flush(s);
2196 return seek_frame_byte(s, stream_index, timestamp, flags);
2199 if (stream_index < 0) {
2200 stream_index = av_find_default_stream_index(s);
2201 if (stream_index < 0)
2204 st = s->streams[stream_index];
2205 /* timestamp for default must be expressed in AV_TIME_BASE units */
2206 timestamp = av_rescale(timestamp, st->time_base.den,
2207 AV_TIME_BASE * (int64_t) st->time_base.num);
2210 /* first, we try the format specific seek */
2211 if (s->iformat->read_seek) {
2212 ff_read_frame_flush(s);
2213 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2219 if (s->iformat->read_timestamp &&
2220 !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2221 ff_read_frame_flush(s);
2222 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2223 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2224 ff_read_frame_flush(s);
2225 return seek_frame_generic(s, stream_index, timestamp, flags);
2230 int av_seek_frame(AVFormatContext *s, int stream_index,
2231 int64_t timestamp, int flags)
2235 if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2236 int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2237 if ((flags & AVSEEK_FLAG_BACKWARD))
2241 return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2242 flags & ~AVSEEK_FLAG_BACKWARD);
2245 ret = seek_frame_internal(s, stream_index, timestamp, flags);
2248 ret = avformat_queue_attached_pictures(s);
2253 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts,
2254 int64_t ts, int64_t max_ts, int flags)
2256 if (min_ts > ts || max_ts < ts)
2258 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2259 return AVERROR(EINVAL);
2262 flags |= AVSEEK_FLAG_ANY;
2263 flags &= ~AVSEEK_FLAG_BACKWARD;
2265 if (s->iformat->read_seek2) {
2267 ff_read_frame_flush(s);
2269 if (stream_index == -1 && s->nb_streams == 1) {
2270 AVRational time_base = s->streams[0]->time_base;
2271 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2272 min_ts = av_rescale_rnd(min_ts, time_base.den,
2273 time_base.num * (int64_t)AV_TIME_BASE,
2274 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2275 max_ts = av_rescale_rnd(max_ts, time_base.den,
2276 time_base.num * (int64_t)AV_TIME_BASE,
2277 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2280 ret = s->iformat->read_seek2(s, stream_index, min_ts,
2284 ret = avformat_queue_attached_pictures(s);
2288 if (s->iformat->read_timestamp) {
2289 // try to seek via read_timestamp()
2292 // Fall back on old API if new is not implemented but old is.
2293 // Note the old API has somewhat different semantics.
2294 if (s->iformat->read_seek || 1) {
2295 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2296 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2297 if (ret<0 && ts != min_ts && max_ts != ts) {
2298 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2300 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2305 // try some generic seek like seek_frame_generic() but with new ts semantics
2306 return -1; //unreachable
2309 /*******************************************************/
2312 * Return TRUE if the stream has accurate duration in any stream.
2314 * @return TRUE if the stream has accurate duration for at least one component.
2316 static int has_duration(AVFormatContext *ic)
2321 for (i = 0; i < ic->nb_streams; i++) {
2322 st = ic->streams[i];
2323 if (st->duration != AV_NOPTS_VALUE)
2326 if (ic->duration != AV_NOPTS_VALUE)
2332 * Estimate the stream timings from the one of each components.
2334 * Also computes the global bitrate if possible.
2336 static void update_stream_timings(AVFormatContext *ic)
2338 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2339 int64_t duration, duration1, filesize;
2344 start_time = INT64_MAX;
2345 start_time_text = INT64_MAX;
2346 end_time = INT64_MIN;
2347 duration = INT64_MIN;
2348 for (i = 0; i < ic->nb_streams; i++) {
2349 st = ic->streams[i];
2350 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2351 start_time1 = av_rescale_q(st->start_time, st->time_base,
2353 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2354 if (start_time1 < start_time_text)
2355 start_time_text = start_time1;
2357 start_time = FFMIN(start_time, start_time1);
2358 end_time1 = AV_NOPTS_VALUE;
2359 if (st->duration != AV_NOPTS_VALUE) {
2360 end_time1 = start_time1 +
2361 av_rescale_q(st->duration, st->time_base,
2363 end_time = FFMAX(end_time, end_time1);
2365 for (p = NULL; (p = av_find_program_from_stream(ic, p, i)); ) {
2366 if (p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2367 p->start_time = start_time1;
2368 if (p->end_time < end_time1)
2369 p->end_time = end_time1;
2372 if (st->duration != AV_NOPTS_VALUE) {
2373 duration1 = av_rescale_q(st->duration, st->time_base,
2375 duration = FFMAX(duration, duration1);
2378 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2379 start_time = start_time_text;
2380 else if (start_time > start_time_text)
2381 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2383 if (start_time != INT64_MAX) {
2384 ic->start_time = start_time;
2385 if (end_time != INT64_MIN) {
2386 if (ic->nb_programs) {
2387 for (i = 0; i < ic->nb_programs; i++) {
2388 p = ic->programs[i];
2389 if (p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2390 duration = FFMAX(duration, p->end_time - p->start_time);
2393 duration = FFMAX(duration, end_time - start_time);
2396 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2397 ic->duration = duration;
2399 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2400 /* compute the bitrate */
2401 double bitrate = (double) filesize * 8.0 * AV_TIME_BASE /
2402 (double) ic->duration;
2403 if (bitrate >= 0 && bitrate <= INT_MAX)
2404 ic->bit_rate = bitrate;
2408 static void fill_all_stream_timings(AVFormatContext *ic)
2413 update_stream_timings(ic);
2414 for (i = 0; i < ic->nb_streams; i++) {
2415 st = ic->streams[i];
2416 if (st->start_time == AV_NOPTS_VALUE) {
2417 if (ic->start_time != AV_NOPTS_VALUE)
2418 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q,
2420 if (ic->duration != AV_NOPTS_VALUE)
2421 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q,
2427 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2429 int64_t filesize, duration;
2430 int i, show_warning = 0;
2433 /* if bit_rate is already set, we believe it */
2434 if (ic->bit_rate <= 0) {
2436 for (i = 0; i < ic->nb_streams; i++) {
2437 st = ic->streams[i];
2438 if (st->codec->bit_rate > 0) {
2439 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2443 bit_rate += st->codec->bit_rate;
2446 ic->bit_rate = bit_rate;
2449 /* if duration is already set, we believe it */
2450 if (ic->duration == AV_NOPTS_VALUE &&
2451 ic->bit_rate != 0) {
2452 filesize = ic->pb ? avio_size(ic->pb) : 0;
2454 for (i = 0; i < ic->nb_streams; i++) {
2455 st = ic->streams[i];
2456 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2457 && st->duration == AV_NOPTS_VALUE) {
2458 duration = av_rescale(8 * filesize, st->time_base.den,
2460 (int64_t) st->time_base.num);
2461 st->duration = duration;
2468 av_log(ic, AV_LOG_WARNING,
2469 "Estimating duration from bitrate, this may be inaccurate\n");
2472 #define DURATION_MAX_READ_SIZE 250000LL
2473 #define DURATION_MAX_RETRY 4
2475 /* only usable for MPEG-PS streams */
2476 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2478 AVPacket pkt1, *pkt = &pkt1;
2480 int num, den, read_size, i, ret;
2481 int found_duration = 0;
2483 int64_t filesize, offset, duration;
2486 /* flush packet queue */
2487 flush_packet_queue(ic);
2489 for (i = 0; i < ic->nb_streams; i++) {
2490 st = ic->streams[i];
2491 if (st->start_time == AV_NOPTS_VALUE &&
2492 st->first_dts == AV_NOPTS_VALUE &&
2493 st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN)
2494 av_log(st->codec, AV_LOG_WARNING,
2495 "start time for stream %d is not set in estimate_timings_from_pts\n", i);
2498 av_parser_close(st->parser);
2503 av_opt_set(ic, "skip_changes", "1", AV_OPT_SEARCH_CHILDREN);
2504 /* estimate the end time (duration) */
2505 /* XXX: may need to support wrapping */
2506 filesize = ic->pb ? avio_size(ic->pb) : 0;
2508 is_end = found_duration;
2509 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2513 avio_seek(ic->pb, offset, SEEK_SET);
2516 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2520 ret = ff_read_packet(ic, pkt);
2521 } while (ret == AVERROR(EAGAIN));
2524 read_size += pkt->size;
2525 st = ic->streams[pkt->stream_index];
2526 if (pkt->pts != AV_NOPTS_VALUE &&
2527 (st->start_time != AV_NOPTS_VALUE ||
2528 st->first_dts != AV_NOPTS_VALUE)) {
2529 if (pkt->duration == 0) {
2530 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2532 pkt->duration = av_rescale_rnd(1,
2533 num * (int64_t) st->time_base.den,
2534 den * (int64_t) st->time_base.num,
2538 duration = pkt->pts + pkt->duration;
2540 if (st->start_time != AV_NOPTS_VALUE)
2541 duration -= st->start_time;
2543 duration -= st->first_dts;
2545 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2546 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2547 st->duration = duration;
2548 st->info->last_duration = duration;
2551 av_free_packet(pkt);
2554 /* check if all audio/video streams have valid duration */
2557 for (i = 0; i < ic->nb_streams; i++) {
2558 st = ic->streams[i];
2559 switch (st->codec->codec_type) {
2560 case AVMEDIA_TYPE_VIDEO:
2561 case AVMEDIA_TYPE_AUDIO:
2562 if (st->duration == AV_NOPTS_VALUE)
2569 ++retry <= DURATION_MAX_RETRY);
2571 av_opt_set(ic, "skip_changes", "0", AV_OPT_SEARCH_CHILDREN);
2573 /* warn about audio/video streams which duration could not be estimated */
2574 for (i = 0; i < ic->nb_streams; i++) {
2575 st = ic->streams[i];
2576 if (st->duration == AV_NOPTS_VALUE) {
2577 switch (st->codec->codec_type) {
2578 case AVMEDIA_TYPE_VIDEO:
2579 case AVMEDIA_TYPE_AUDIO:
2580 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2581 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2583 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2587 fill_all_stream_timings(ic);
2589 avio_seek(ic->pb, old_offset, SEEK_SET);
2590 for (i = 0; i < ic->nb_streams; i++) {
2593 st = ic->streams[i];
2594 st->cur_dts = st->first_dts;
2595 st->last_IP_pts = AV_NOPTS_VALUE;
2596 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2597 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2598 st->pts_buffer[j] = AV_NOPTS_VALUE;
2602 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2606 /* get the file size, if possible */
2607 if (ic->iformat->flags & AVFMT_NOFILE) {
2610 file_size = avio_size(ic->pb);
2611 file_size = FFMAX(0, file_size);
2614 if ((!strcmp(ic->iformat->name, "mpeg") ||
2615 !strcmp(ic->iformat->name, "mpegts")) &&
2616 file_size && ic->pb->seekable) {
2617 /* get accurate estimate from the PTSes */
2618 estimate_timings_from_pts(ic, old_offset);
2619 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2620 } else if (has_duration(ic)) {
2621 /* at least one component has timings - we use them for all
2623 fill_all_stream_timings(ic);
2624 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2626 /* less precise: use bitrate info */
2627 estimate_timings_from_bit_rate(ic);
2628 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2630 update_stream_timings(ic);
2634 AVStream av_unused *st;
2635 for (i = 0; i < ic->nb_streams; i++) {
2636 st = ic->streams[i];
2637 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2638 (double) st->start_time / AV_TIME_BASE,
2639 (double) st->duration / AV_TIME_BASE);
2642 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2643 (double) ic->start_time / AV_TIME_BASE,
2644 (double) ic->duration / AV_TIME_BASE,
2645 ic->bit_rate / 1000);
2649 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2651 AVCodecContext *avctx = st->codec;
2653 #define FAIL(errmsg) do { \
2655 *errmsg_ptr = errmsg; \
2659 if ( avctx->codec_id == AV_CODEC_ID_NONE
2660 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2661 FAIL("unknown codec");
2662 switch (avctx->codec_type) {
2663 case AVMEDIA_TYPE_AUDIO:
2664 if (!avctx->frame_size && determinable_frame_size(avctx))
2665 FAIL("unspecified frame size");
2666 if (st->info->found_decoder >= 0 &&
2667 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2668 FAIL("unspecified sample format");
2669 if (!avctx->sample_rate)
2670 FAIL("unspecified sample rate");
2671 if (!avctx->channels)
2672 FAIL("unspecified number of channels");
2673 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2674 FAIL("no decodable DTS frames");
2676 case AVMEDIA_TYPE_VIDEO:
2678 FAIL("unspecified size");
2679 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2680 FAIL("unspecified pixel format");
2681 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2682 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2683 FAIL("no frame in rv30/40 and no sar");
2685 case AVMEDIA_TYPE_SUBTITLE:
2686 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2687 FAIL("unspecified size");
2689 case AVMEDIA_TYPE_DATA:
2690 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2696 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2697 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2698 AVDictionary **options)
2700 const AVCodec *codec;
2701 int got_picture = 1, ret = 0;
2702 AVFrame *frame = av_frame_alloc();
2703 AVSubtitle subtitle;
2704 AVPacket pkt = *avpkt;
2707 return AVERROR(ENOMEM);
2709 if (!avcodec_is_open(st->codec) &&
2710 st->info->found_decoder <= 0 &&
2711 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2712 AVDictionary *thread_opt = NULL;
2714 codec = find_decoder(s, st, st->codec->codec_id);
2717 st->info->found_decoder = -st->codec->codec_id;
2722 /* Force thread count to 1 since the H.264 decoder will not extract
2723 * SPS and PPS to extradata during multi-threaded decoding. */
2724 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2725 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2727 av_dict_free(&thread_opt);
2729 st->info->found_decoder = -st->codec->codec_id;
2732 st->info->found_decoder = 1;
2733 } else if (!st->info->found_decoder)
2734 st->info->found_decoder = 1;
2736 if (st->info->found_decoder < 0) {
2741 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2743 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2744 (!st->codec_info_nb_frames &&
2745 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2747 switch (st->codec->codec_type) {
2748 case AVMEDIA_TYPE_VIDEO:
2749 ret = avcodec_decode_video2(st->codec, frame,
2750 &got_picture, &pkt);
2752 case AVMEDIA_TYPE_AUDIO:
2753 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2755 case AVMEDIA_TYPE_SUBTITLE:
2756 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2757 &got_picture, &pkt);
2765 st->nb_decoded_frames++;
2772 if (!pkt.data && !got_picture)
2776 av_frame_free(&frame);
2780 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2782 while (tags->id != AV_CODEC_ID_NONE) {
2790 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2793 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2794 if (tag == tags[i].tag)
2796 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2797 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2799 return AV_CODEC_ID_NONE;
2802 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2807 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2809 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2811 return AV_CODEC_ID_NONE;
2816 if (sflags & (1 << (bps - 1))) {
2819 return AV_CODEC_ID_PCM_S8;
2821 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2823 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2825 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2827 return AV_CODEC_ID_NONE;
2832 return AV_CODEC_ID_PCM_U8;
2834 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2836 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2838 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2840 return AV_CODEC_ID_NONE;
2846 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2849 if (!av_codec_get_tag2(tags, id, &tag))
2854 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2858 for (i = 0; tags && tags[i]; i++) {
2859 const AVCodecTag *codec_tags = tags[i];
2860 while (codec_tags->id != AV_CODEC_ID_NONE) {
2861 if (codec_tags->id == id) {
2862 *tag = codec_tags->tag;
2871 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2874 for (i = 0; tags && tags[i]; i++) {
2875 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2876 if (id != AV_CODEC_ID_NONE)
2879 return AV_CODEC_ID_NONE;
2882 static void compute_chapters_end(AVFormatContext *s)
2885 int64_t max_time = s->duration +
2886 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2888 for (i = 0; i < s->nb_chapters; i++)
2889 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2890 AVChapter *ch = s->chapters[i];
2891 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2895 for (j = 0; j < s->nb_chapters; j++) {
2896 AVChapter *ch1 = s->chapters[j];
2897 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2899 if (j != i && next_start > ch->start && next_start < end)
2902 ch->end = (end == INT64_MAX) ? ch->start : end;
2906 static int get_std_framerate(int i)
2909 return (i + 1) * 1001;
2911 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2914 /* Is the time base unreliable?
2915 * This is a heuristic to balance between quick acceptance of the values in
2916 * the headers vs. some extra checks.
2917 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2918 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2919 * And there are "variable" fps files this needs to detect as well. */
2920 static int tb_unreliable(AVCodecContext *c)
2922 if (c->time_base.den >= 101L * c->time_base.num ||
2923 c->time_base.den < 5L * c->time_base.num ||
2924 // c->codec_tag == AV_RL32("DIVX") ||
2925 // c->codec_tag == AV_RL32("XVID") ||
2926 c->codec_tag == AV_RL32("mp4v") ||
2927 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2928 c->codec_id == AV_CODEC_ID_GIF ||
2929 c->codec_id == AV_CODEC_ID_H264)
2934 #if FF_API_FORMAT_PARAMETERS
2935 int av_find_stream_info(AVFormatContext *ic)
2937 return avformat_find_stream_info(ic, NULL);
2941 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2945 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2946 avctx->extradata_size = 0;
2947 return AVERROR(EINVAL);
2949 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2950 if (avctx->extradata) {
2951 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2952 avctx->extradata_size = size;
2955 avctx->extradata_size = 0;
2956 ret = AVERROR(ENOMEM);
2961 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2963 int ret = ff_alloc_extradata(avctx, size);
2966 ret = avio_read(pb, avctx->extradata, size);
2968 av_freep(&avctx->extradata);
2969 avctx->extradata_size = 0;
2970 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2971 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2977 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2980 int64_t last = st->info->last_dts;
2982 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2983 && ts - (uint64_t)last < INT64_MAX) {
2984 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2985 int64_t duration = ts - last;
2987 if (!st->info->duration_error)
2988 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2989 if (!st->info->duration_error)
2990 return AVERROR(ENOMEM);
2992 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2993 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2994 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2995 if (st->info->duration_error[0][1][i] < 1e10) {
2996 int framerate = get_std_framerate(i);
2997 double sdts = dts*framerate/(1001*12);
2998 for (j= 0; j<2; j++) {
2999 int64_t ticks = llrint(sdts+j*0.5);
3000 double error= sdts - ticks + j*0.5;
3001 st->info->duration_error[j][0][i] += error;
3002 st->info->duration_error[j][1][i] += error*error;
3006 st->info->duration_count++;
3007 st->info->rfps_duration_sum += duration;
3009 if (st->info->duration_count % 10 == 0) {
3010 int n = st->info->duration_count;
3011 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3012 if (st->info->duration_error[0][1][i] < 1e10) {
3013 double a0 = st->info->duration_error[0][0][i] / n;
3014 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3015 double a1 = st->info->duration_error[1][0][i] / n;
3016 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3017 if (error0 > 0.04 && error1 > 0.04) {
3018 st->info->duration_error[0][1][i] = 2e10;
3019 st->info->duration_error[1][1][i] = 2e10;
3025 // ignore the first 4 values, they might have some random jitter
3026 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3027 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3029 if (ts != AV_NOPTS_VALUE)
3030 st->info->last_dts = ts;
3035 void ff_rfps_calculate(AVFormatContext *ic)
3039 for (i = 0; i < ic->nb_streams; i++) {
3040 AVStream *st = ic->streams[i];
3042 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3044 // the check for tb_unreliable() is not completely correct, since this is not about handling
3045 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3046 // ipmovie.c produces.
3047 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)
3048 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);
3049 if (st->info->duration_count>1 && !st->r_frame_rate.num
3050 && tb_unreliable(st->codec)) {
3052 double best_error= 0.01;
3053 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3055 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3058 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3060 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3063 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3066 for (k= 0; k<2; k++) {
3067 int n = st->info->duration_count;
3068 double a= st->info->duration_error[k][0][j] / n;
3069 double error= st->info->duration_error[k][1][j]/n - a*a;
3071 if (error < best_error && best_error> 0.000000001) {
3073 num = get_std_framerate(j);
3076 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3079 // do not increase frame rate by more than 1 % in order to match a standard rate.
3080 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3081 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3083 if ( !st->avg_frame_rate.num
3084 && st->r_frame_rate.num && st->info->rfps_duration_sum
3085 && st->info->codec_info_duration <= 0
3086 && st->info->duration_count > 2
3087 && 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
3089 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3090 st->avg_frame_rate = st->r_frame_rate;
3093 av_freep(&st->info->duration_error);
3094 st->info->last_dts = AV_NOPTS_VALUE;
3095 st->info->duration_count = 0;
3096 st->info->rfps_duration_sum = 0;
3100 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3102 int i, count, ret = 0, j;
3105 AVPacket pkt1, *pkt;
3106 int64_t old_offset = avio_tell(ic->pb);
3107 // new streams might appear, no options for those
3108 int orig_nb_streams = ic->nb_streams;
3109 int flush_codecs = ic->probesize > 0;
3110 int64_t max_analyze_duration = ic->max_analyze_duration2;
3111 if (!max_analyze_duration)
3112 max_analyze_duration = ic->max_analyze_duration;
3114 if (!max_analyze_duration) {
3115 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3116 max_analyze_duration = 10*AV_TIME_BASE;
3118 max_analyze_duration = 5*AV_TIME_BASE;
3122 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3123 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3125 for (i = 0; i < ic->nb_streams; i++) {
3126 const AVCodec *codec;
3127 AVDictionary *thread_opt = NULL;
3128 st = ic->streams[i];
3130 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3131 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3132 /* if (!st->time_base.num)
3134 if (!st->codec->time_base.num)
3135 st->codec->time_base = st->time_base;
3137 // only for the split stuff
3138 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3139 st->parser = av_parser_init(st->codec->codec_id);
3141 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3142 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3143 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3144 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3146 } else if (st->need_parsing) {
3147 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3148 "%s, packets or times may be invalid.\n",
3149 avcodec_get_name(st->codec->codec_id));
3152 codec = find_decoder(ic, st, st->codec->codec_id);
3154 /* Force thread count to 1 since the H.264 decoder will not extract
3155 * SPS and PPS to extradata during multi-threaded decoding. */
3156 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3158 /* Ensure that subtitle_header is properly set. */
3159 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3160 && codec && !st->codec->codec) {
3161 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3162 av_log(ic, AV_LOG_WARNING,
3163 "Failed to open codec in av_find_stream_info\n");
3166 // Try to just open decoders, in case this is enough to get parameters.
3167 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3168 if (codec && !st->codec->codec)
3169 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3170 av_log(ic, AV_LOG_WARNING,
3171 "Failed to open codec in av_find_stream_info\n");
3174 av_dict_free(&thread_opt);
3177 for (i = 0; i < ic->nb_streams; i++) {
3178 #if FF_API_R_FRAME_RATE
3179 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3181 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3182 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3188 if (ff_check_interrupt(&ic->interrupt_callback)) {
3190 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3194 /* check if one codec still needs to be handled */
3195 for (i = 0; i < ic->nb_streams; i++) {
3196 int fps_analyze_framecount = 20;
3198 st = ic->streams[i];
3199 if (!has_codec_parameters(st, NULL))
3201 /* If the timebase is coarse (like the usual millisecond precision
3202 * of mkv), we need to analyze more frames to reliably arrive at
3203 * the correct fps. */
3204 if (av_q2d(st->time_base) > 0.0005)
3205 fps_analyze_framecount *= 2;
3206 if (!tb_unreliable(st->codec))
3207 fps_analyze_framecount = 0;
3208 if (ic->fps_probe_size >= 0)
3209 fps_analyze_framecount = ic->fps_probe_size;
3210 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3211 fps_analyze_framecount = 0;
3212 /* variable fps and no guess at the real fps */
3213 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3214 st->info->duration_count < fps_analyze_framecount &&
3215 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3217 if (st->parser && st->parser->parser->split &&
3218 !st->codec->extradata)
3220 if (st->first_dts == AV_NOPTS_VALUE &&
3221 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3222 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3223 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3226 if (i == ic->nb_streams) {
3227 /* NOTE: If the format has no header, then we need to read some
3228 * packets to get most of the streams, so we cannot stop here. */
3229 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3230 /* If we found the info for all the codecs, we can stop. */
3232 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3237 /* We did not get all the codec info, but we read too much data. */
3238 if (read_size >= ic->probesize) {
3240 av_log(ic, AV_LOG_DEBUG,
3241 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3242 for (i = 0; i < ic->nb_streams; i++)
3243 if (!ic->streams[i]->r_frame_rate.num &&
3244 ic->streams[i]->info->duration_count <= 1 &&
3245 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3246 strcmp(ic->iformat->name, "image2"))
3247 av_log(ic, AV_LOG_WARNING,
3248 "Stream #%d: not enough frames to estimate rate; "
3249 "consider increasing probesize\n", i);
3253 /* NOTE: A new stream can be added there if no header in file
3254 * (AVFMTCTX_NOHEADER). */
3255 ret = read_frame_internal(ic, &pkt1);
3256 if (ret == AVERROR(EAGAIN))
3264 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3265 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3267 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3268 &ic->packet_buffer_end);
3270 ret = AVERROR(ENOMEM);
3271 goto find_stream_info_err;
3273 if ((ret = av_dup_packet(pkt)) < 0)
3274 goto find_stream_info_err;
3277 st = ic->streams[pkt->stream_index];
3278 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3279 read_size += pkt->size;
3281 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3282 /* check for non-increasing dts */
3283 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3284 st->info->fps_last_dts >= pkt->dts) {
3285 av_log(ic, AV_LOG_DEBUG,
3286 "Non-increasing DTS in stream %d: packet %d with DTS "
3287 "%"PRId64", packet %d with DTS %"PRId64"\n",
3288 st->index, st->info->fps_last_dts_idx,
3289 st->info->fps_last_dts, st->codec_info_nb_frames,
3291 st->info->fps_first_dts =
3292 st->info->fps_last_dts = AV_NOPTS_VALUE;
3294 /* Check for a discontinuity in dts. If the difference in dts
3295 * is more than 1000 times the average packet duration in the
3296 * sequence, we treat it as a discontinuity. */
3297 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3298 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3299 (pkt->dts - st->info->fps_last_dts) / 1000 >
3300 (st->info->fps_last_dts - st->info->fps_first_dts) /
3301 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3302 av_log(ic, AV_LOG_WARNING,
3303 "DTS discontinuity in stream %d: packet %d with DTS "
3304 "%"PRId64", packet %d with DTS %"PRId64"\n",
3305 st->index, st->info->fps_last_dts_idx,
3306 st->info->fps_last_dts, st->codec_info_nb_frames,
3308 st->info->fps_first_dts =
3309 st->info->fps_last_dts = AV_NOPTS_VALUE;
3312 /* update stored dts values */
3313 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3314 st->info->fps_first_dts = pkt->dts;
3315 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3317 st->info->fps_last_dts = pkt->dts;
3318 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3320 if (st->codec_info_nb_frames>1) {
3323 if (st->time_base.den > 0)
3324 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3325 if (st->avg_frame_rate.num > 0)
3326 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3329 && st->codec_info_nb_frames>30
3330 && st->info->fps_first_dts != AV_NOPTS_VALUE
3331 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3332 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3334 if (t >= max_analyze_duration) {
3335 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3336 max_analyze_duration,
3340 if (pkt->duration) {
3341 st->info->codec_info_duration += pkt->duration;
3342 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3345 #if FF_API_R_FRAME_RATE
3346 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3347 ff_rfps_add_frame(ic, st, pkt->dts);
3349 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3350 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3351 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3352 if (ff_alloc_extradata(st->codec, i))
3353 return AVERROR(ENOMEM);
3354 memcpy(st->codec->extradata, pkt->data,
3355 st->codec->extradata_size);
3359 /* If still no information, we try to open the codec and to
3360 * decompress the frame. We try to avoid that in most cases as
3361 * it takes longer and uses more memory. For MPEG-4, we need to
3362 * decompress for QuickTime.
3364 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3365 * least one frame of codec data, this makes sure the codec initializes
3366 * the channel configuration and does not only trust the values from
3368 try_decode_frame(ic, st, pkt,
3369 (options && i < orig_nb_streams) ? &options[i] : NULL);
3371 st->codec_info_nb_frames++;
3376 AVPacket empty_pkt = { 0 };
3378 av_init_packet(&empty_pkt);
3380 for (i = 0; i < ic->nb_streams; i++) {
3382 st = ic->streams[i];
3384 /* flush the decoders */
3385 if (st->info->found_decoder == 1) {
3387 err = try_decode_frame(ic, st, &empty_pkt,
3388 (options && i < orig_nb_streams)
3389 ? &options[i] : NULL);
3390 } while (err > 0 && !has_codec_parameters(st, NULL));
3393 av_log(ic, AV_LOG_INFO,
3394 "decoding for stream %d failed\n", st->index);
3400 // close codecs which were opened in try_decode_frame()
3401 for (i = 0; i < ic->nb_streams; i++) {
3402 st = ic->streams[i];
3403 avcodec_close(st->codec);
3406 ff_rfps_calculate(ic);
3408 for (i = 0; i < ic->nb_streams; i++) {
3409 st = ic->streams[i];
3410 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3411 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3412 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3413 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3414 st->codec->codec_tag= tag;
3417 /* estimate average framerate if not set by demuxer */
3418 if (st->info->codec_info_duration_fields &&
3419 !st->avg_frame_rate.num &&
3420 st->info->codec_info_duration) {
3422 double best_error = 0.01;
3424 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3425 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3426 st->info->codec_info_duration < 0)
3428 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3429 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3430 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3432 /* Round guessed framerate to a "standard" framerate if it's
3433 * within 1% of the original estimate. */
3434 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3435 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3436 double error = fabs(av_q2d(st->avg_frame_rate) /
3437 av_q2d(std_fps) - 1);
3439 if (error < best_error) {
3441 best_fps = std_fps.num;
3445 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3446 best_fps, 12 * 1001, INT_MAX);
3449 if (!st->r_frame_rate.num) {
3450 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3451 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3452 st->r_frame_rate.num = st->codec->time_base.den;
3453 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3455 st->r_frame_rate.num = st->time_base.den;
3456 st->r_frame_rate.den = st->time_base.num;
3459 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3460 if (!st->codec->bits_per_coded_sample)
3461 st->codec->bits_per_coded_sample =
3462 av_get_bits_per_sample(st->codec->codec_id);
3463 // set stream disposition based on audio service type
3464 switch (st->codec->audio_service_type) {
3465 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3466 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3468 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3469 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3471 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3472 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3474 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3475 st->disposition = AV_DISPOSITION_COMMENT;
3477 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3478 st->disposition = AV_DISPOSITION_KARAOKE;
3485 estimate_timings(ic, old_offset);
3487 if (ret >= 0 && ic->nb_streams)
3488 /* We could not have all the codec parameters before EOF. */
3490 for (i = 0; i < ic->nb_streams; i++) {
3492 st = ic->streams[i];
3493 if (!has_codec_parameters(st, &errmsg)) {
3495 avcodec_string(buf, sizeof(buf), st->codec, 0);
3496 av_log(ic, AV_LOG_WARNING,
3497 "Could not find codec parameters for stream %d (%s): %s\n"
3498 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3505 compute_chapters_end(ic);
3507 find_stream_info_err:
3508 for (i = 0; i < ic->nb_streams; i++) {
3509 st = ic->streams[i];
3510 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3511 ic->streams[i]->codec->thread_count = 0;
3513 av_freep(&st->info->duration_error);
3514 av_freep(&ic->streams[i]->info);
3517 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3518 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3522 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3526 for (i = 0; i < ic->nb_programs; i++) {
3527 if (ic->programs[i] == last) {
3531 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3532 if (ic->programs[i]->stream_index[j] == s)
3533 return ic->programs[i];
3539 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3540 int wanted_stream_nb, int related_stream,
3541 AVCodec **decoder_ret, int flags)
3543 int i, nb_streams = ic->nb_streams;
3544 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3545 unsigned *program = NULL;
3546 const AVCodec *decoder = NULL, *best_decoder = NULL;
3548 if (related_stream >= 0 && wanted_stream_nb < 0) {
3549 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3551 program = p->stream_index;
3552 nb_streams = p->nb_stream_indexes;
3555 for (i = 0; i < nb_streams; i++) {
3556 int real_stream_index = program ? program[i] : i;
3557 AVStream *st = ic->streams[real_stream_index];
3558 AVCodecContext *avctx = st->codec;
3559 if (avctx->codec_type != type)
3561 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3563 if (wanted_stream_nb != real_stream_index &&
3564 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3565 AV_DISPOSITION_VISUAL_IMPAIRED))
3567 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3570 decoder = find_decoder(ic, st, st->codec->codec_id);
3573 ret = AVERROR_DECODER_NOT_FOUND;
3577 count = st->codec_info_nb_frames;
3578 bitrate = avctx->bit_rate;
3580 bitrate = avctx->rc_max_rate;
3581 multiframe = FFMIN(5, count);
3582 if ((best_multiframe > multiframe) ||
3583 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3584 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3587 best_bitrate = bitrate;
3588 best_multiframe = multiframe;
3589 ret = real_stream_index;
3590 best_decoder = decoder;
3591 if (program && i == nb_streams - 1 && ret < 0) {
3593 nb_streams = ic->nb_streams;
3594 /* no related stream found, try again with everything */
3599 *decoder_ret = (AVCodec*)best_decoder;
3603 /*******************************************************/
3605 int av_read_play(AVFormatContext *s)
3607 if (s->iformat->read_play)
3608 return s->iformat->read_play(s);
3610 return avio_pause(s->pb, 0);
3611 return AVERROR(ENOSYS);
3614 int av_read_pause(AVFormatContext *s)
3616 if (s->iformat->read_pause)
3617 return s->iformat->read_pause(s);
3619 return avio_pause(s->pb, 1);
3620 return AVERROR(ENOSYS);
3623 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3625 av_assert0(s->nb_streams>0);
3626 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3628 for (j = 0; j < st->nb_side_data; j++)
3629 av_freep(&st->side_data[j].data);
3630 av_freep(&st->side_data);
3631 st->nb_side_data = 0;
3634 av_parser_close(st->parser);
3636 if (st->attached_pic.data)
3637 av_free_packet(&st->attached_pic);
3638 av_dict_free(&st->metadata);
3639 av_freep(&st->probe_data.buf);
3640 av_freep(&st->index_entries);
3641 av_freep(&st->codec->extradata);
3642 av_freep(&st->codec->subtitle_header);
3643 av_freep(&st->codec);
3644 av_freep(&st->priv_data);
3646 av_freep(&st->info->duration_error);
3647 av_freep(&st->info);
3648 av_freep(&s->streams[ --s->nb_streams ]);
3651 void avformat_free_context(AVFormatContext *s)
3659 if (s->iformat && s->iformat->priv_class && s->priv_data)
3660 av_opt_free(s->priv_data);
3661 if (s->oformat && s->oformat->priv_class && s->priv_data)
3662 av_opt_free(s->priv_data);
3664 for (i = s->nb_streams - 1; i >= 0; i--) {
3665 ff_free_stream(s, s->streams[i]);
3667 for (i = s->nb_programs - 1; i >= 0; i--) {
3668 av_dict_free(&s->programs[i]->metadata);
3669 av_freep(&s->programs[i]->stream_index);
3670 av_freep(&s->programs[i]);
3672 av_freep(&s->programs);
3673 av_freep(&s->priv_data);
3674 while (s->nb_chapters--) {
3675 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3676 av_freep(&s->chapters[s->nb_chapters]);
3678 av_freep(&s->chapters);
3679 av_dict_free(&s->metadata);
3680 av_freep(&s->streams);
3681 av_freep(&s->internal);
3685 #if FF_API_CLOSE_INPUT_FILE
3686 void av_close_input_file(AVFormatContext *s)
3688 avformat_close_input(&s);
3692 void avformat_close_input(AVFormatContext **ps)
3703 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3704 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3707 flush_packet_queue(s);
3710 if (s->iformat->read_close)
3711 s->iformat->read_close(s);
3713 avformat_free_context(s);
3720 #if FF_API_NEW_STREAM
3721 AVStream *av_new_stream(AVFormatContext *s, int id)
3723 AVStream *st = avformat_new_stream(s, NULL);
3730 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3736 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3738 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3741 s->streams = streams;
3743 st = av_mallocz(sizeof(AVStream));
3746 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3750 st->info->last_dts = AV_NOPTS_VALUE;
3752 st->codec = avcodec_alloc_context3(c);
3754 /* no default bitrate if decoding */
3755 st->codec->bit_rate = 0;
3757 /* default pts setting is MPEG-like */
3758 avpriv_set_pts_info(st, 33, 1, 90000);
3761 st->index = s->nb_streams;
3762 st->start_time = AV_NOPTS_VALUE;
3763 st->duration = AV_NOPTS_VALUE;
3764 /* we set the current DTS to 0 so that formats without any timestamps
3765 * but durations get some timestamps, formats with some unknown
3766 * timestamps have their first few packets buffered and the
3767 * timestamps corrected before they are returned to the user */
3768 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3769 st->first_dts = AV_NOPTS_VALUE;
3770 st->probe_packets = MAX_PROBE_PACKETS;
3771 st->pts_wrap_reference = AV_NOPTS_VALUE;
3772 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3774 st->last_IP_pts = AV_NOPTS_VALUE;
3775 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3776 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3777 st->pts_buffer[i] = AV_NOPTS_VALUE;
3779 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3781 #if FF_API_R_FRAME_RATE
3782 st->info->last_dts = AV_NOPTS_VALUE;
3784 st->info->fps_first_dts = AV_NOPTS_VALUE;
3785 st->info->fps_last_dts = AV_NOPTS_VALUE;
3787 st->inject_global_side_data = s->internal->inject_global_side_data;
3789 s->streams[s->nb_streams++] = st;
3793 AVProgram *av_new_program(AVFormatContext *ac, int id)
3795 AVProgram *program = NULL;
3798 av_dlog(ac, "new_program: id=0x%04x\n", id);
3800 for (i = 0; i < ac->nb_programs; i++)
3801 if (ac->programs[i]->id == id)
3802 program = ac->programs[i];
3805 program = av_mallocz(sizeof(AVProgram));
3808 dynarray_add(&ac->programs, &ac->nb_programs, program);
3809 program->discard = AVDISCARD_NONE;
3812 program->pts_wrap_reference = AV_NOPTS_VALUE;
3813 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3815 program->start_time =
3816 program->end_time = AV_NOPTS_VALUE;
3821 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3822 int64_t start, int64_t end, const char *title)
3824 AVChapter *chapter = NULL;
3827 if (end != AV_NOPTS_VALUE && start > end) {
3828 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3832 for (i = 0; i < s->nb_chapters; i++)
3833 if (s->chapters[i]->id == id)
3834 chapter = s->chapters[i];
3837 chapter = av_mallocz(sizeof(AVChapter));
3840 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3842 av_dict_set(&chapter->metadata, "title", title, 0);
3844 chapter->time_base = time_base;
3845 chapter->start = start;
3851 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3854 AVProgram *program = NULL;
3857 if (idx >= ac->nb_streams) {
3858 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3862 for (i = 0; i < ac->nb_programs; i++) {
3863 if (ac->programs[i]->id != progid)
3865 program = ac->programs[i];
3866 for (j = 0; j < program->nb_stream_indexes; j++)
3867 if (program->stream_index[j] == idx)
3870 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3873 program->stream_index = tmp;
3874 program->stream_index[program->nb_stream_indexes++] = idx;
3879 uint64_t ff_ntp_time(void)
3881 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3884 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3887 char *q, buf1[20], c;
3888 int nd, len, percentd_found;
3900 while (av_isdigit(*p))
3901 nd = nd * 10 + *p++ - '0';
3903 } while (av_isdigit(c));
3912 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3914 if ((q - buf + len) > buf_size - 1)
3916 memcpy(q, buf1, len);
3924 if ((q - buf) < buf_size - 1)
3928 if (!percentd_found)
3937 void av_url_split(char *proto, int proto_size,
3938 char *authorization, int authorization_size,
3939 char *hostname, int hostname_size,
3940 int *port_ptr, char *path, int path_size, const char *url)
3942 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3948 if (authorization_size > 0)
3949 authorization[0] = 0;
3950 if (hostname_size > 0)
3955 /* parse protocol */
3956 if ((p = strchr(url, ':'))) {
3957 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3964 /* no protocol means plain filename */
3965 av_strlcpy(path, url, path_size);
3969 /* separate path from hostname */
3970 ls = strchr(p, '/');
3971 ls2 = strchr(p, '?');
3975 ls = FFMIN(ls, ls2);
3977 av_strlcpy(path, ls, path_size);
3979 ls = &p[strlen(p)]; // XXX
3981 /* the rest is hostname, use that to parse auth/port */
3983 /* authorization (user[:pass]@hostname) */
3985 while ((at = strchr(p, '@')) && at < ls) {
3986 av_strlcpy(authorization, at2,
3987 FFMIN(authorization_size, at + 1 - at2));
3988 p = at + 1; /* skip '@' */
3991 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3993 av_strlcpy(hostname, p + 1,
3994 FFMIN(hostname_size, brk - p));
3995 if (brk[1] == ':' && port_ptr)
3996 *port_ptr = atoi(brk + 2);
3997 } else if ((col = strchr(p, ':')) && col < ls) {
3998 av_strlcpy(hostname, p,
3999 FFMIN(col + 1 - p, hostname_size));
4001 *port_ptr = atoi(col + 1);
4003 av_strlcpy(hostname, p,
4004 FFMIN(ls + 1 - p, hostname_size));
4008 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4011 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4014 'C', 'D', 'E', 'F' };
4015 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4018 'c', 'd', 'e', 'f' };
4019 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4021 for (i = 0; i < s; i++) {
4022 buff[i * 2] = hex_table[src[i] >> 4];
4023 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4029 int ff_hex_to_data(uint8_t *data, const char *p)
4036 p += strspn(p, SPACE_CHARS);
4039 c = av_toupper((unsigned char) *p++);
4040 if (c >= '0' && c <= '9')
4042 else if (c >= 'A' && c <= 'F')
4057 #if FF_API_SET_PTS_INFO
4058 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4059 unsigned int pts_num, unsigned int pts_den)
4061 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4065 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4066 unsigned int pts_num, unsigned int pts_den)
4069 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4070 if (new_tb.num != pts_num)
4071 av_log(NULL, AV_LOG_DEBUG,
4072 "st:%d removing common factor %d from timebase\n",
4073 s->index, pts_num / new_tb.num);
4075 av_log(NULL, AV_LOG_WARNING,
4076 "st:%d has too large timebase, reducing\n", s->index);
4078 if (new_tb.num <= 0 || new_tb.den <= 0) {
4079 av_log(NULL, AV_LOG_ERROR,
4080 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4081 new_tb.num, new_tb.den,
4085 s->time_base = new_tb;
4086 av_codec_set_pkt_timebase(s->codec, new_tb);
4087 s->pts_wrap_bits = pts_wrap_bits;
4090 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4093 const char *ptr = str;
4095 /* Parse key=value pairs. */
4098 char *dest = NULL, *dest_end;
4099 int key_len, dest_len = 0;
4101 /* Skip whitespace and potential commas. */
4102 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4109 if (!(ptr = strchr(key, '=')))
4112 key_len = ptr - key;
4114 callback_get_buf(context, key, key_len, &dest, &dest_len);
4115 dest_end = dest + dest_len - 1;
4119 while (*ptr && *ptr != '\"') {
4123 if (dest && dest < dest_end)
4127 if (dest && dest < dest_end)
4135 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4136 if (dest && dest < dest_end)
4144 int ff_find_stream_index(AVFormatContext *s, int id)
4147 for (i = 0; i < s->nb_streams; i++)
4148 if (s->streams[i]->id == id)
4153 int64_t ff_iso8601_to_unix_time(const char *datestr)
4155 struct tm time1 = { 0 }, time2 = { 0 };
4157 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4158 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4160 return av_timegm(&time2);
4162 return av_timegm(&time1);
4165 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4169 if (ofmt->query_codec)
4170 return ofmt->query_codec(codec_id, std_compliance);
4171 else if (ofmt->codec_tag)
4172 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4173 else if (codec_id == ofmt->video_codec ||
4174 codec_id == ofmt->audio_codec ||
4175 codec_id == ofmt->subtitle_codec)
4178 return AVERROR_PATCHWELCOME;
4181 int avformat_network_init(void)
4185 ff_network_inited_globally = 1;
4186 if ((ret = ff_network_init()) < 0)
4193 int avformat_network_deinit(void)
4202 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4203 uint64_t channel_layout, int32_t sample_rate,
4204 int32_t width, int32_t height)
4210 return AVERROR(EINVAL);
4213 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4215 if (channel_layout) {
4217 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4221 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4223 if (width || height) {
4225 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4227 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4229 return AVERROR(ENOMEM);
4230 bytestream_put_le32(&data, flags);
4232 bytestream_put_le32(&data, channels);
4234 bytestream_put_le64(&data, channel_layout);
4236 bytestream_put_le32(&data, sample_rate);
4237 if (width || height) {
4238 bytestream_put_le32(&data, width);
4239 bytestream_put_le32(&data, height);
4244 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4246 AVRational undef = {0, 1};
4247 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4248 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4249 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4251 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4252 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4253 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4254 stream_sample_aspect_ratio = undef;
4256 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4257 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4258 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4259 frame_sample_aspect_ratio = undef;
4261 if (stream_sample_aspect_ratio.num)
4262 return stream_sample_aspect_ratio;
4264 return frame_sample_aspect_ratio;
4267 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4269 AVRational fr = st->r_frame_rate;
4270 AVRational codec_fr = av_inv_q(st->codec->time_base);
4271 AVRational avg_fr = st->avg_frame_rate;
4273 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4274 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4279 if (st->codec->ticks_per_frame > 1) {
4280 codec_fr.den *= st->codec->ticks_per_frame;
4281 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4282 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4289 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4292 if (*spec <= '9' && *spec >= '0') /* opt:index */
4293 return strtol(spec, NULL, 0) == st->index;
4294 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4295 *spec == 't') { /* opt:[vasdt] */
4296 enum AVMediaType type;
4299 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4300 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4301 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4302 case 'd': type = AVMEDIA_TYPE_DATA; break;
4303 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4304 default: av_assert0(0);
4306 if (type != st->codec->codec_type)
4308 if (*spec++ == ':') { /* possibly followed by :index */
4309 int i, index = strtol(spec, NULL, 0);
4310 for (i = 0; i < s->nb_streams; i++)
4311 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4312 return i == st->index;
4316 } else if (*spec == 'p' && *(spec + 1) == ':') {
4320 prog_id = strtol(spec, &endptr, 0);
4321 for (i = 0; i < s->nb_programs; i++) {
4322 if (s->programs[i]->id != prog_id)
4325 if (*endptr++ == ':') {
4326 int stream_idx = strtol(endptr, NULL, 0);
4327 return stream_idx >= 0 &&
4328 stream_idx < s->programs[i]->nb_stream_indexes &&
4329 st->index == s->programs[i]->stream_index[stream_idx];
4332 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4333 if (st->index == s->programs[i]->stream_index[j])
4337 } else if (*spec == '#' ||
4338 (*spec == 'i' && *(spec + 1) == ':')) {
4341 spec += 1 + (*spec == 'i');
4342 stream_id = strtol(spec, &endptr, 0);
4344 return stream_id == st->id;
4345 } else if (!*spec) /* empty specifier, matches everything */
4348 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4349 return AVERROR(EINVAL);
4352 int ff_generate_avci_extradata(AVStream *st)
4354 static const uint8_t avci100_1080p_extradata[] = {
4356 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4357 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4358 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4359 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4360 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4361 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4362 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4363 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4364 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4366 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4369 static const uint8_t avci100_1080i_extradata[] = {
4371 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4372 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4373 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4374 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4375 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4376 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4377 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4378 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4379 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4380 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4381 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4383 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4386 static const uint8_t avci50_1080i_extradata[] = {
4388 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4389 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4390 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4391 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4392 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4393 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4394 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4395 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4396 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4397 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4398 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4400 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4403 static const uint8_t avci100_720p_extradata[] = {
4405 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4406 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4407 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4408 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4409 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4410 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4411 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4412 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4413 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4414 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4416 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4420 const uint8_t *data = NULL;
4423 if (st->codec->width == 1920) {
4424 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4425 data = avci100_1080p_extradata;
4426 size = sizeof(avci100_1080p_extradata);
4428 data = avci100_1080i_extradata;
4429 size = sizeof(avci100_1080i_extradata);
4431 } else if (st->codec->width == 1440) {
4432 data = avci50_1080i_extradata;
4433 size = sizeof(avci50_1080i_extradata);
4434 } else if (st->codec->width == 1280) {
4435 data = avci100_720p_extradata;
4436 size = sizeof(avci100_720p_extradata);
4442 av_freep(&st->codec->extradata);
4443 if (ff_alloc_extradata(st->codec, size))
4444 return AVERROR(ENOMEM);
4445 memcpy(st->codec->extradata, data, size);
4450 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4455 for (i = 0; i < st->nb_side_data; i++) {
4456 if (st->side_data[i].type == type) {
4458 *size = st->side_data[i].size;
4459 return st->side_data[i].data;