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 /* estimate the end time (duration) */
2504 /* XXX: may need to support wrapping */
2505 filesize = ic->pb ? avio_size(ic->pb) : 0;
2507 is_end = found_duration;
2508 offset = filesize - (DURATION_MAX_READ_SIZE << retry);
2512 avio_seek(ic->pb, offset, SEEK_SET);
2515 if (read_size >= DURATION_MAX_READ_SIZE << (FFMAX(retry - 1, 0)))
2519 ret = ff_read_packet(ic, pkt);
2520 } while (ret == AVERROR(EAGAIN));
2523 read_size += pkt->size;
2524 st = ic->streams[pkt->stream_index];
2525 if (pkt->pts != AV_NOPTS_VALUE &&
2526 (st->start_time != AV_NOPTS_VALUE ||
2527 st->first_dts != AV_NOPTS_VALUE)) {
2528 if (pkt->duration == 0) {
2529 ff_compute_frame_duration(&num, &den, st, st->parser, pkt);
2531 pkt->duration = av_rescale_rnd(1,
2532 num * (int64_t) st->time_base.den,
2533 den * (int64_t) st->time_base.num,
2537 duration = pkt->pts + pkt->duration;
2539 if (st->start_time != AV_NOPTS_VALUE)
2540 duration -= st->start_time;
2542 duration -= st->first_dts;
2544 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<= 0 ||
2545 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2546 st->duration = duration;
2547 st->info->last_duration = duration;
2550 av_free_packet(pkt);
2553 /* check if all audio/video streams have valid duration */
2556 for (i = 0; i < ic->nb_streams; i++) {
2557 st = ic->streams[i];
2558 switch (st->codec->codec_type) {
2559 case AVMEDIA_TYPE_VIDEO:
2560 case AVMEDIA_TYPE_AUDIO:
2561 if (st->duration == AV_NOPTS_VALUE)
2568 ++retry <= DURATION_MAX_RETRY);
2570 /* warn about audio/video streams which duration could not be estimated */
2571 for (i = 0; i < ic->nb_streams; i++) {
2572 st = ic->streams[i];
2573 if (st->duration == AV_NOPTS_VALUE) {
2574 switch (st->codec->codec_type) {
2575 case AVMEDIA_TYPE_VIDEO:
2576 case AVMEDIA_TYPE_AUDIO:
2577 if (st->start_time != AV_NOPTS_VALUE || st->first_dts != AV_NOPTS_VALUE) {
2578 av_log(ic, AV_LOG_DEBUG, "stream %d : no PTS found at end of file, duration not set\n", i);
2580 av_log(ic, AV_LOG_DEBUG, "stream %d : no TS found at start of file, duration not set\n", i);
2584 fill_all_stream_timings(ic);
2586 avio_seek(ic->pb, old_offset, SEEK_SET);
2587 for (i = 0; i < ic->nb_streams; i++) {
2590 st = ic->streams[i];
2591 st->cur_dts = st->first_dts;
2592 st->last_IP_pts = AV_NOPTS_VALUE;
2593 st->last_dts_for_order_check = AV_NOPTS_VALUE;
2594 for (j = 0; j < MAX_REORDER_DELAY + 1; j++)
2595 st->pts_buffer[j] = AV_NOPTS_VALUE;
2599 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2603 /* get the file size, if possible */
2604 if (ic->iformat->flags & AVFMT_NOFILE) {
2607 file_size = avio_size(ic->pb);
2608 file_size = FFMAX(0, file_size);
2611 if ((!strcmp(ic->iformat->name, "mpeg") ||
2612 !strcmp(ic->iformat->name, "mpegts")) &&
2613 file_size && ic->pb->seekable) {
2614 /* get accurate estimate from the PTSes */
2615 estimate_timings_from_pts(ic, old_offset);
2616 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2617 } else if (has_duration(ic)) {
2618 /* at least one component has timings - we use them for all
2620 fill_all_stream_timings(ic);
2621 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2623 /* less precise: use bitrate info */
2624 estimate_timings_from_bit_rate(ic);
2625 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2627 update_stream_timings(ic);
2631 AVStream av_unused *st;
2632 for (i = 0; i < ic->nb_streams; i++) {
2633 st = ic->streams[i];
2634 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2635 (double) st->start_time / AV_TIME_BASE,
2636 (double) st->duration / AV_TIME_BASE);
2639 "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2640 (double) ic->start_time / AV_TIME_BASE,
2641 (double) ic->duration / AV_TIME_BASE,
2642 ic->bit_rate / 1000);
2646 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2648 AVCodecContext *avctx = st->codec;
2650 #define FAIL(errmsg) do { \
2652 *errmsg_ptr = errmsg; \
2656 if ( avctx->codec_id == AV_CODEC_ID_NONE
2657 && avctx->codec_type != AVMEDIA_TYPE_DATA)
2658 FAIL("unknown codec");
2659 switch (avctx->codec_type) {
2660 case AVMEDIA_TYPE_AUDIO:
2661 if (!avctx->frame_size && determinable_frame_size(avctx))
2662 FAIL("unspecified frame size");
2663 if (st->info->found_decoder >= 0 &&
2664 avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2665 FAIL("unspecified sample format");
2666 if (!avctx->sample_rate)
2667 FAIL("unspecified sample rate");
2668 if (!avctx->channels)
2669 FAIL("unspecified number of channels");
2670 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2671 FAIL("no decodable DTS frames");
2673 case AVMEDIA_TYPE_VIDEO:
2675 FAIL("unspecified size");
2676 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2677 FAIL("unspecified pixel format");
2678 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2679 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2680 FAIL("no frame in rv30/40 and no sar");
2682 case AVMEDIA_TYPE_SUBTITLE:
2683 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2684 FAIL("unspecified size");
2686 case AVMEDIA_TYPE_DATA:
2687 if (avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2693 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2694 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt,
2695 AVDictionary **options)
2697 const AVCodec *codec;
2698 int got_picture = 1, ret = 0;
2699 AVFrame *frame = av_frame_alloc();
2700 AVSubtitle subtitle;
2701 AVPacket pkt = *avpkt;
2704 return AVERROR(ENOMEM);
2706 if (!avcodec_is_open(st->codec) &&
2707 st->info->found_decoder <= 0 &&
2708 (st->codec->codec_id != -st->info->found_decoder || !st->codec->codec_id)) {
2709 AVDictionary *thread_opt = NULL;
2711 codec = find_decoder(s, st, st->codec->codec_id);
2714 st->info->found_decoder = -st->codec->codec_id;
2719 /* Force thread count to 1 since the H.264 decoder will not extract
2720 * SPS and PPS to extradata during multi-threaded decoding. */
2721 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2722 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2724 av_dict_free(&thread_opt);
2726 st->info->found_decoder = -st->codec->codec_id;
2729 st->info->found_decoder = 1;
2730 } else if (!st->info->found_decoder)
2731 st->info->found_decoder = 1;
2733 if (st->info->found_decoder < 0) {
2738 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2740 (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) ||
2741 (!st->codec_info_nb_frames &&
2742 st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2744 switch (st->codec->codec_type) {
2745 case AVMEDIA_TYPE_VIDEO:
2746 ret = avcodec_decode_video2(st->codec, frame,
2747 &got_picture, &pkt);
2749 case AVMEDIA_TYPE_AUDIO:
2750 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2752 case AVMEDIA_TYPE_SUBTITLE:
2753 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2754 &got_picture, &pkt);
2762 st->nb_decoded_frames++;
2769 if (!pkt.data && !got_picture)
2773 av_frame_free(&frame);
2777 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2779 while (tags->id != AV_CODEC_ID_NONE) {
2787 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2790 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2791 if (tag == tags[i].tag)
2793 for (i = 0; tags[i].id != AV_CODEC_ID_NONE; i++)
2794 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2796 return AV_CODEC_ID_NONE;
2799 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2804 return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2806 return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2808 return AV_CODEC_ID_NONE;
2813 if (sflags & (1 << (bps - 1))) {
2816 return AV_CODEC_ID_PCM_S8;
2818 return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2820 return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2822 return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2824 return AV_CODEC_ID_NONE;
2829 return AV_CODEC_ID_PCM_U8;
2831 return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2833 return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2835 return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2837 return AV_CODEC_ID_NONE;
2843 unsigned int av_codec_get_tag(const AVCodecTag *const *tags, enum AVCodecID id)
2846 if (!av_codec_get_tag2(tags, id, &tag))
2851 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2855 for (i = 0; tags && tags[i]; i++) {
2856 const AVCodecTag *codec_tags = tags[i];
2857 while (codec_tags->id != AV_CODEC_ID_NONE) {
2858 if (codec_tags->id == id) {
2859 *tag = codec_tags->tag;
2868 enum AVCodecID av_codec_get_id(const AVCodecTag *const *tags, unsigned int tag)
2871 for (i = 0; tags && tags[i]; i++) {
2872 enum AVCodecID id = ff_codec_get_id(tags[i], tag);
2873 if (id != AV_CODEC_ID_NONE)
2876 return AV_CODEC_ID_NONE;
2879 static void compute_chapters_end(AVFormatContext *s)
2882 int64_t max_time = s->duration +
2883 ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2885 for (i = 0; i < s->nb_chapters; i++)
2886 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2887 AVChapter *ch = s->chapters[i];
2888 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q,
2892 for (j = 0; j < s->nb_chapters; j++) {
2893 AVChapter *ch1 = s->chapters[j];
2894 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base,
2896 if (j != i && next_start > ch->start && next_start < end)
2899 ch->end = (end == INT64_MAX) ? ch->start : end;
2903 static int get_std_framerate(int i)
2906 return (i + 1) * 1001;
2908 return ((const int[]) { 24, 30, 60, 12, 15, 48 })[i - 60 * 12] * 1000 * 12;
2911 /* Is the time base unreliable?
2912 * This is a heuristic to balance between quick acceptance of the values in
2913 * the headers vs. some extra checks.
2914 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2915 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2916 * And there are "variable" fps files this needs to detect as well. */
2917 static int tb_unreliable(AVCodecContext *c)
2919 if (c->time_base.den >= 101L * c->time_base.num ||
2920 c->time_base.den < 5L * c->time_base.num ||
2921 // c->codec_tag == AV_RL32("DIVX") ||
2922 // c->codec_tag == AV_RL32("XVID") ||
2923 c->codec_tag == AV_RL32("mp4v") ||
2924 c->codec_id == AV_CODEC_ID_MPEG2VIDEO ||
2925 c->codec_id == AV_CODEC_ID_GIF ||
2926 c->codec_id == AV_CODEC_ID_H264)
2931 #if FF_API_FORMAT_PARAMETERS
2932 int av_find_stream_info(AVFormatContext *ic)
2934 return avformat_find_stream_info(ic, NULL);
2938 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2942 if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2943 avctx->extradata_size = 0;
2944 return AVERROR(EINVAL);
2946 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2947 if (avctx->extradata) {
2948 memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2949 avctx->extradata_size = size;
2952 avctx->extradata_size = 0;
2953 ret = AVERROR(ENOMEM);
2958 int ff_get_extradata(AVCodecContext *avctx, AVIOContext *pb, int size)
2960 int ret = ff_alloc_extradata(avctx, size);
2963 ret = avio_read(pb, avctx->extradata, size);
2965 av_freep(&avctx->extradata);
2966 avctx->extradata_size = 0;
2967 av_log(avctx, AV_LOG_ERROR, "Failed to read extradata of size %d\n", size);
2968 return ret < 0 ? ret : AVERROR_INVALIDDATA;
2974 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2977 int64_t last = st->info->last_dts;
2979 if ( ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2980 && ts - (uint64_t)last < INT64_MAX) {
2981 double dts = (is_relative(ts) ? ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2982 int64_t duration = ts - last;
2984 if (!st->info->duration_error)
2985 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2986 if (!st->info->duration_error)
2987 return AVERROR(ENOMEM);
2989 // if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2990 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2991 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
2992 if (st->info->duration_error[0][1][i] < 1e10) {
2993 int framerate = get_std_framerate(i);
2994 double sdts = dts*framerate/(1001*12);
2995 for (j= 0; j<2; j++) {
2996 int64_t ticks = llrint(sdts+j*0.5);
2997 double error= sdts - ticks + j*0.5;
2998 st->info->duration_error[j][0][i] += error;
2999 st->info->duration_error[j][1][i] += error*error;
3003 st->info->duration_count++;
3004 st->info->rfps_duration_sum += duration;
3006 if (st->info->duration_count % 10 == 0) {
3007 int n = st->info->duration_count;
3008 for (i = 0; i<MAX_STD_TIMEBASES; i++) {
3009 if (st->info->duration_error[0][1][i] < 1e10) {
3010 double a0 = st->info->duration_error[0][0][i] / n;
3011 double error0 = st->info->duration_error[0][1][i] / n - a0*a0;
3012 double a1 = st->info->duration_error[1][0][i] / n;
3013 double error1 = st->info->duration_error[1][1][i] / n - a1*a1;
3014 if (error0 > 0.04 && error1 > 0.04) {
3015 st->info->duration_error[0][1][i] = 2e10;
3016 st->info->duration_error[1][1][i] = 2e10;
3022 // ignore the first 4 values, they might have some random jitter
3023 if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
3024 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
3026 if (ts != AV_NOPTS_VALUE)
3027 st->info->last_dts = ts;
3032 void ff_rfps_calculate(AVFormatContext *ic)
3036 for (i = 0; i < ic->nb_streams; i++) {
3037 AVStream *st = ic->streams[i];
3039 if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
3041 // the check for tb_unreliable() is not completely correct, since this is not about handling
3042 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3043 // ipmovie.c produces.
3044 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)
3045 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);
3046 if (st->info->duration_count>1 && !st->r_frame_rate.num
3047 && tb_unreliable(st->codec)) {
3049 double best_error= 0.01;
3050 AVRational ref_rate = st->r_frame_rate.num ? st->r_frame_rate : av_inv_q(st->time_base);
3052 for (j= 0; j<MAX_STD_TIMEBASES; j++) {
3055 if (st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3057 if (!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3060 if (av_q2d(st->time_base) * st->info->rfps_duration_sum / st->info->duration_count < (1001*12.0 * 0.8)/get_std_framerate(j))
3063 for (k= 0; k<2; k++) {
3064 int n = st->info->duration_count;
3065 double a= st->info->duration_error[k][0][j] / n;
3066 double error= st->info->duration_error[k][1][j]/n - a*a;
3068 if (error < best_error && best_error> 0.000000001) {
3070 num = get_std_framerate(j);
3073 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3076 // do not increase frame rate by more than 1 % in order to match a standard rate.
3077 if (num && (!ref_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(ref_rate)))
3078 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3080 if ( !st->avg_frame_rate.num
3081 && st->r_frame_rate.num && st->info->rfps_duration_sum
3082 && st->info->codec_info_duration <= 0
3083 && st->info->duration_count > 2
3084 && 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
3086 av_log(ic, AV_LOG_DEBUG, "Setting avg frame rate based on r frame rate\n");
3087 st->avg_frame_rate = st->r_frame_rate;
3090 av_freep(&st->info->duration_error);
3091 st->info->last_dts = AV_NOPTS_VALUE;
3092 st->info->duration_count = 0;
3093 st->info->rfps_duration_sum = 0;
3097 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
3099 int i, count, ret = 0, j;
3102 AVPacket pkt1, *pkt;
3103 int64_t old_offset = avio_tell(ic->pb);
3104 // new streams might appear, no options for those
3105 int orig_nb_streams = ic->nb_streams;
3106 int flush_codecs = ic->probesize > 0;
3107 int64_t max_analyze_duration = ic->max_analyze_duration2;
3108 if (!max_analyze_duration)
3109 max_analyze_duration = ic->max_analyze_duration;
3111 if (!max_analyze_duration) {
3112 if (!strcmp(ic->iformat->name, "flv") && !(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3113 max_analyze_duration = 10*AV_TIME_BASE;
3115 max_analyze_duration = 5*AV_TIME_BASE;
3119 av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
3120 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
3122 for (i = 0; i < ic->nb_streams; i++) {
3123 const AVCodec *codec;
3124 AVDictionary *thread_opt = NULL;
3125 st = ic->streams[i];
3127 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3128 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3129 /* if (!st->time_base.num)
3131 if (!st->codec->time_base.num)
3132 st->codec->time_base = st->time_base;
3134 // only for the split stuff
3135 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
3136 st->parser = av_parser_init(st->codec->codec_id);
3138 if (st->need_parsing == AVSTREAM_PARSE_HEADERS) {
3139 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
3140 } else if (st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
3141 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
3143 } else if (st->need_parsing) {
3144 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
3145 "%s, packets or times may be invalid.\n",
3146 avcodec_get_name(st->codec->codec_id));
3149 codec = find_decoder(ic, st, st->codec->codec_id);
3151 /* Force thread count to 1 since the H.264 decoder will not extract
3152 * SPS and PPS to extradata during multi-threaded decoding. */
3153 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
3155 /* Ensure that subtitle_header is properly set. */
3156 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
3157 && codec && !st->codec->codec) {
3158 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3159 av_log(ic, AV_LOG_WARNING,
3160 "Failed to open codec in av_find_stream_info\n");
3163 // Try to just open decoders, in case this is enough to get parameters.
3164 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
3165 if (codec && !st->codec->codec)
3166 if (avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt) < 0)
3167 av_log(ic, AV_LOG_WARNING,
3168 "Failed to open codec in av_find_stream_info\n");
3171 av_dict_free(&thread_opt);
3174 for (i = 0; i < ic->nb_streams; i++) {
3175 #if FF_API_R_FRAME_RATE
3176 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
3178 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
3179 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
3185 if (ff_check_interrupt(&ic->interrupt_callback)) {
3187 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
3191 /* check if one codec still needs to be handled */
3192 for (i = 0; i < ic->nb_streams; i++) {
3193 int fps_analyze_framecount = 20;
3195 st = ic->streams[i];
3196 if (!has_codec_parameters(st, NULL))
3198 /* If the timebase is coarse (like the usual millisecond precision
3199 * of mkv), we need to analyze more frames to reliably arrive at
3200 * the correct fps. */
3201 if (av_q2d(st->time_base) > 0.0005)
3202 fps_analyze_framecount *= 2;
3203 if (!tb_unreliable(st->codec))
3204 fps_analyze_framecount = 0;
3205 if (ic->fps_probe_size >= 0)
3206 fps_analyze_framecount = ic->fps_probe_size;
3207 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
3208 fps_analyze_framecount = 0;
3209 /* variable fps and no guess at the real fps */
3210 if (!(st->r_frame_rate.num && st->avg_frame_rate.num) &&
3211 st->info->duration_count < fps_analyze_framecount &&
3212 st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3214 if (st->parser && st->parser->parser->split &&
3215 !st->codec->extradata)
3217 if (st->first_dts == AV_NOPTS_VALUE &&
3218 !(ic->iformat->flags & AVFMT_NOTIMESTAMPS) &&
3219 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3220 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
3223 if (i == ic->nb_streams) {
3224 /* NOTE: If the format has no header, then we need to read some
3225 * packets to get most of the streams, so we cannot stop here. */
3226 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
3227 /* If we found the info for all the codecs, we can stop. */
3229 av_log(ic, AV_LOG_DEBUG, "All info found\n");
3234 /* We did not get all the codec info, but we read too much data. */
3235 if (read_size >= ic->probesize) {
3237 av_log(ic, AV_LOG_DEBUG,
3238 "Probe buffer size limit of %d bytes reached\n", ic->probesize);
3239 for (i = 0; i < ic->nb_streams; i++)
3240 if (!ic->streams[i]->r_frame_rate.num &&
3241 ic->streams[i]->info->duration_count <= 1 &&
3242 ic->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3243 strcmp(ic->iformat->name, "image2"))
3244 av_log(ic, AV_LOG_WARNING,
3245 "Stream #%d: not enough frames to estimate rate; "
3246 "consider increasing probesize\n", i);
3250 /* NOTE: A new stream can be added there if no header in file
3251 * (AVFMTCTX_NOHEADER). */
3252 ret = read_frame_internal(ic, &pkt1);
3253 if (ret == AVERROR(EAGAIN))
3261 if (ic->flags & AVFMT_FLAG_NOBUFFER)
3262 free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
3264 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
3265 &ic->packet_buffer_end);
3267 ret = AVERROR(ENOMEM);
3268 goto find_stream_info_err;
3270 if ((ret = av_dup_packet(pkt)) < 0)
3271 goto find_stream_info_err;
3274 st = ic->streams[pkt->stream_index];
3275 if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
3276 read_size += pkt->size;
3278 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
3279 /* check for non-increasing dts */
3280 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3281 st->info->fps_last_dts >= pkt->dts) {
3282 av_log(ic, AV_LOG_DEBUG,
3283 "Non-increasing DTS in stream %d: packet %d with DTS "
3284 "%"PRId64", packet %d with DTS %"PRId64"\n",
3285 st->index, st->info->fps_last_dts_idx,
3286 st->info->fps_last_dts, st->codec_info_nb_frames,
3288 st->info->fps_first_dts =
3289 st->info->fps_last_dts = AV_NOPTS_VALUE;
3291 /* Check for a discontinuity in dts. If the difference in dts
3292 * is more than 1000 times the average packet duration in the
3293 * sequence, we treat it as a discontinuity. */
3294 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
3295 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
3296 (pkt->dts - st->info->fps_last_dts) / 1000 >
3297 (st->info->fps_last_dts - st->info->fps_first_dts) /
3298 (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
3299 av_log(ic, AV_LOG_WARNING,
3300 "DTS discontinuity in stream %d: packet %d with DTS "
3301 "%"PRId64", packet %d with DTS %"PRId64"\n",
3302 st->index, st->info->fps_last_dts_idx,
3303 st->info->fps_last_dts, st->codec_info_nb_frames,
3305 st->info->fps_first_dts =
3306 st->info->fps_last_dts = AV_NOPTS_VALUE;
3309 /* update stored dts values */
3310 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
3311 st->info->fps_first_dts = pkt->dts;
3312 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
3314 st->info->fps_last_dts = pkt->dts;
3315 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
3317 if (st->codec_info_nb_frames>1) {
3320 if (st->time_base.den > 0)
3321 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
3322 if (st->avg_frame_rate.num > 0)
3323 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
3326 && st->codec_info_nb_frames>30
3327 && st->info->fps_first_dts != AV_NOPTS_VALUE
3328 && st->info->fps_last_dts != AV_NOPTS_VALUE)
3329 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
3331 if (t >= max_analyze_duration) {
3332 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %"PRId64" reached at %"PRId64" microseconds\n",
3333 max_analyze_duration,
3337 if (pkt->duration) {
3338 st->info->codec_info_duration += pkt->duration;
3339 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame ==2 ? st->parser->repeat_pict + 1 : 2;
3342 #if FF_API_R_FRAME_RATE
3343 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3344 ff_rfps_add_frame(ic, st, pkt->dts);
3346 if (st->parser && st->parser->parser->split && !st->codec->extradata) {
3347 int i = st->parser->parser->split(st->codec, pkt->data, pkt->size);
3348 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3349 if (ff_alloc_extradata(st->codec, i))
3350 return AVERROR(ENOMEM);
3351 memcpy(st->codec->extradata, pkt->data,
3352 st->codec->extradata_size);
3356 /* If still no information, we try to open the codec and to
3357 * decompress the frame. We try to avoid that in most cases as
3358 * it takes longer and uses more memory. For MPEG-4, we need to
3359 * decompress for QuickTime.
3361 * If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3362 * least one frame of codec data, this makes sure the codec initializes
3363 * the channel configuration and does not only trust the values from
3365 try_decode_frame(ic, st, pkt,
3366 (options && i < orig_nb_streams) ? &options[i] : NULL);
3368 st->codec_info_nb_frames++;
3373 AVPacket empty_pkt = { 0 };
3375 av_init_packet(&empty_pkt);
3377 for (i = 0; i < ic->nb_streams; i++) {
3379 st = ic->streams[i];
3381 /* flush the decoders */
3382 if (st->info->found_decoder == 1) {
3384 err = try_decode_frame(ic, st, &empty_pkt,
3385 (options && i < orig_nb_streams)
3386 ? &options[i] : NULL);
3387 } while (err > 0 && !has_codec_parameters(st, NULL));
3390 av_log(ic, AV_LOG_INFO,
3391 "decoding for stream %d failed\n", st->index);
3397 // close codecs which were opened in try_decode_frame()
3398 for (i = 0; i < ic->nb_streams; i++) {
3399 st = ic->streams[i];
3400 avcodec_close(st->codec);
3403 ff_rfps_calculate(ic);
3405 for (i = 0; i < ic->nb_streams; i++) {
3406 st = ic->streams[i];
3407 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3408 if (st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample) {
3409 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3410 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3411 st->codec->codec_tag= tag;
3414 /* estimate average framerate if not set by demuxer */
3415 if (st->info->codec_info_duration_fields &&
3416 !st->avg_frame_rate.num &&
3417 st->info->codec_info_duration) {
3419 double best_error = 0.01;
3421 if (st->info->codec_info_duration >= INT64_MAX / st->time_base.num / 2||
3422 st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3423 st->info->codec_info_duration < 0)
3425 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3426 st->info->codec_info_duration_fields * (int64_t) st->time_base.den,
3427 st->info->codec_info_duration * 2 * (int64_t) st->time_base.num, 60000);
3429 /* Round guessed framerate to a "standard" framerate if it's
3430 * within 1% of the original estimate. */
3431 for (j = 0; j < MAX_STD_TIMEBASES; j++) {
3432 AVRational std_fps = { get_std_framerate(j), 12 * 1001 };
3433 double error = fabs(av_q2d(st->avg_frame_rate) /
3434 av_q2d(std_fps) - 1);
3436 if (error < best_error) {
3438 best_fps = std_fps.num;
3442 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3443 best_fps, 12 * 1001, INT_MAX);
3446 if (!st->r_frame_rate.num) {
3447 if ( st->codec->time_base.den * (int64_t) st->time_base.num
3448 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t) st->time_base.den) {
3449 st->r_frame_rate.num = st->codec->time_base.den;
3450 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3452 st->r_frame_rate.num = st->time_base.den;
3453 st->r_frame_rate.den = st->time_base.num;
3456 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3457 if (!st->codec->bits_per_coded_sample)
3458 st->codec->bits_per_coded_sample =
3459 av_get_bits_per_sample(st->codec->codec_id);
3460 // set stream disposition based on audio service type
3461 switch (st->codec->audio_service_type) {
3462 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3463 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;
3465 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3466 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;
3468 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3469 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED;
3471 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3472 st->disposition = AV_DISPOSITION_COMMENT;
3474 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3475 st->disposition = AV_DISPOSITION_KARAOKE;
3482 estimate_timings(ic, old_offset);
3484 if (ret >= 0 && ic->nb_streams)
3485 /* We could not have all the codec parameters before EOF. */
3487 for (i = 0; i < ic->nb_streams; i++) {
3489 st = ic->streams[i];
3490 if (!has_codec_parameters(st, &errmsg)) {
3492 avcodec_string(buf, sizeof(buf), st->codec, 0);
3493 av_log(ic, AV_LOG_WARNING,
3494 "Could not find codec parameters for stream %d (%s): %s\n"
3495 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3502 compute_chapters_end(ic);
3504 find_stream_info_err:
3505 for (i = 0; i < ic->nb_streams; i++) {
3506 st = ic->streams[i];
3507 if (ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3508 ic->streams[i]->codec->thread_count = 0;
3510 av_freep(&st->info->duration_error);
3511 av_freep(&ic->streams[i]->info);
3514 av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3515 avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3519 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3523 for (i = 0; i < ic->nb_programs; i++) {
3524 if (ic->programs[i] == last) {
3528 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3529 if (ic->programs[i]->stream_index[j] == s)
3530 return ic->programs[i];
3536 int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type,
3537 int wanted_stream_nb, int related_stream,
3538 AVCodec **decoder_ret, int flags)
3540 int i, nb_streams = ic->nb_streams;
3541 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3542 unsigned *program = NULL;
3543 const AVCodec *decoder = NULL, *best_decoder = NULL;
3545 if (related_stream >= 0 && wanted_stream_nb < 0) {
3546 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3548 program = p->stream_index;
3549 nb_streams = p->nb_stream_indexes;
3552 for (i = 0; i < nb_streams; i++) {
3553 int real_stream_index = program ? program[i] : i;
3554 AVStream *st = ic->streams[real_stream_index];
3555 AVCodecContext *avctx = st->codec;
3556 if (avctx->codec_type != type)
3558 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3560 if (wanted_stream_nb != real_stream_index &&
3561 st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED |
3562 AV_DISPOSITION_VISUAL_IMPAIRED))
3564 if (type == AVMEDIA_TYPE_AUDIO && !avctx->channels)
3567 decoder = find_decoder(ic, st, st->codec->codec_id);
3570 ret = AVERROR_DECODER_NOT_FOUND;
3574 count = st->codec_info_nb_frames;
3575 bitrate = avctx->bit_rate;
3577 bitrate = avctx->rc_max_rate;
3578 multiframe = FFMIN(5, count);
3579 if ((best_multiframe > multiframe) ||
3580 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3581 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3584 best_bitrate = bitrate;
3585 best_multiframe = multiframe;
3586 ret = real_stream_index;
3587 best_decoder = decoder;
3588 if (program && i == nb_streams - 1 && ret < 0) {
3590 nb_streams = ic->nb_streams;
3591 /* no related stream found, try again with everything */
3596 *decoder_ret = (AVCodec*)best_decoder;
3600 /*******************************************************/
3602 int av_read_play(AVFormatContext *s)
3604 if (s->iformat->read_play)
3605 return s->iformat->read_play(s);
3607 return avio_pause(s->pb, 0);
3608 return AVERROR(ENOSYS);
3611 int av_read_pause(AVFormatContext *s)
3613 if (s->iformat->read_pause)
3614 return s->iformat->read_pause(s);
3616 return avio_pause(s->pb, 1);
3617 return AVERROR(ENOSYS);
3620 void ff_free_stream(AVFormatContext *s, AVStream *st) {
3622 av_assert0(s->nb_streams>0);
3623 av_assert0(s->streams[ s->nb_streams - 1 ] == st);
3625 for (j = 0; j < st->nb_side_data; j++)
3626 av_freep(&st->side_data[j].data);
3627 av_freep(&st->side_data);
3628 st->nb_side_data = 0;
3631 av_parser_close(st->parser);
3633 if (st->attached_pic.data)
3634 av_free_packet(&st->attached_pic);
3635 av_dict_free(&st->metadata);
3636 av_freep(&st->probe_data.buf);
3637 av_freep(&st->index_entries);
3638 av_freep(&st->codec->extradata);
3639 av_freep(&st->codec->subtitle_header);
3640 av_freep(&st->codec);
3641 av_freep(&st->priv_data);
3643 av_freep(&st->info->duration_error);
3644 av_freep(&st->info);
3645 av_freep(&s->streams[ --s->nb_streams ]);
3648 void avformat_free_context(AVFormatContext *s)
3656 if (s->iformat && s->iformat->priv_class && s->priv_data)
3657 av_opt_free(s->priv_data);
3658 if (s->oformat && s->oformat->priv_class && s->priv_data)
3659 av_opt_free(s->priv_data);
3661 for (i = s->nb_streams - 1; i >= 0; i--) {
3662 ff_free_stream(s, s->streams[i]);
3664 for (i = s->nb_programs - 1; i >= 0; i--) {
3665 av_dict_free(&s->programs[i]->metadata);
3666 av_freep(&s->programs[i]->stream_index);
3667 av_freep(&s->programs[i]);
3669 av_freep(&s->programs);
3670 av_freep(&s->priv_data);
3671 while (s->nb_chapters--) {
3672 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3673 av_freep(&s->chapters[s->nb_chapters]);
3675 av_freep(&s->chapters);
3676 av_dict_free(&s->metadata);
3677 av_freep(&s->streams);
3678 av_freep(&s->internal);
3682 #if FF_API_CLOSE_INPUT_FILE
3683 void av_close_input_file(AVFormatContext *s)
3685 avformat_close_input(&s);
3689 void avformat_close_input(AVFormatContext **ps)
3700 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3701 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3704 flush_packet_queue(s);
3707 if (s->iformat->read_close)
3708 s->iformat->read_close(s);
3710 avformat_free_context(s);
3717 #if FF_API_NEW_STREAM
3718 AVStream *av_new_stream(AVFormatContext *s, int id)
3720 AVStream *st = avformat_new_stream(s, NULL);
3727 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3733 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3735 streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3738 s->streams = streams;
3740 st = av_mallocz(sizeof(AVStream));
3743 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3747 st->info->last_dts = AV_NOPTS_VALUE;
3749 st->codec = avcodec_alloc_context3(c);
3751 /* no default bitrate if decoding */
3752 st->codec->bit_rate = 0;
3754 /* default pts setting is MPEG-like */
3755 avpriv_set_pts_info(st, 33, 1, 90000);
3758 st->index = s->nb_streams;
3759 st->start_time = AV_NOPTS_VALUE;
3760 st->duration = AV_NOPTS_VALUE;
3761 /* we set the current DTS to 0 so that formats without any timestamps
3762 * but durations get some timestamps, formats with some unknown
3763 * timestamps have their first few packets buffered and the
3764 * timestamps corrected before they are returned to the user */
3765 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3766 st->first_dts = AV_NOPTS_VALUE;
3767 st->probe_packets = MAX_PROBE_PACKETS;
3768 st->pts_wrap_reference = AV_NOPTS_VALUE;
3769 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3771 st->last_IP_pts = AV_NOPTS_VALUE;
3772 st->last_dts_for_order_check = AV_NOPTS_VALUE;
3773 for (i = 0; i < MAX_REORDER_DELAY + 1; i++)
3774 st->pts_buffer[i] = AV_NOPTS_VALUE;
3776 st->sample_aspect_ratio = (AVRational) { 0, 1 };
3778 #if FF_API_R_FRAME_RATE
3779 st->info->last_dts = AV_NOPTS_VALUE;
3781 st->info->fps_first_dts = AV_NOPTS_VALUE;
3782 st->info->fps_last_dts = AV_NOPTS_VALUE;
3784 st->inject_global_side_data = s->internal->inject_global_side_data;
3786 s->streams[s->nb_streams++] = st;
3790 AVProgram *av_new_program(AVFormatContext *ac, int id)
3792 AVProgram *program = NULL;
3795 av_dlog(ac, "new_program: id=0x%04x\n", id);
3797 for (i = 0; i < ac->nb_programs; i++)
3798 if (ac->programs[i]->id == id)
3799 program = ac->programs[i];
3802 program = av_mallocz(sizeof(AVProgram));
3805 dynarray_add(&ac->programs, &ac->nb_programs, program);
3806 program->discard = AVDISCARD_NONE;
3809 program->pts_wrap_reference = AV_NOPTS_VALUE;
3810 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3812 program->start_time =
3813 program->end_time = AV_NOPTS_VALUE;
3818 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base,
3819 int64_t start, int64_t end, const char *title)
3821 AVChapter *chapter = NULL;
3824 if (end != AV_NOPTS_VALUE && start > end) {
3825 av_log(s, AV_LOG_ERROR, "Chapter end time %"PRId64" before start %"PRId64"\n", end, start);
3829 for (i = 0; i < s->nb_chapters; i++)
3830 if (s->chapters[i]->id == id)
3831 chapter = s->chapters[i];
3834 chapter = av_mallocz(sizeof(AVChapter));
3837 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3839 av_dict_set(&chapter->metadata, "title", title, 0);
3841 chapter->time_base = time_base;
3842 chapter->start = start;
3848 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned idx)
3851 AVProgram *program = NULL;
3854 if (idx >= ac->nb_streams) {
3855 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3859 for (i = 0; i < ac->nb_programs; i++) {
3860 if (ac->programs[i]->id != progid)
3862 program = ac->programs[i];
3863 for (j = 0; j < program->nb_stream_indexes; j++)
3864 if (program->stream_index[j] == idx)
3867 tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3870 program->stream_index = tmp;
3871 program->stream_index[program->nb_stream_indexes++] = idx;
3876 uint64_t ff_ntp_time(void)
3878 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3881 int av_get_frame_filename(char *buf, int buf_size, const char *path, int number)
3884 char *q, buf1[20], c;
3885 int nd, len, percentd_found;
3897 while (av_isdigit(*p))
3898 nd = nd * 10 + *p++ - '0';
3900 } while (av_isdigit(c));
3909 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3911 if ((q - buf + len) > buf_size - 1)
3913 memcpy(q, buf1, len);
3921 if ((q - buf) < buf_size - 1)
3925 if (!percentd_found)
3934 void av_url_split(char *proto, int proto_size,
3935 char *authorization, int authorization_size,
3936 char *hostname, int hostname_size,
3937 int *port_ptr, char *path, int path_size, const char *url)
3939 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3945 if (authorization_size > 0)
3946 authorization[0] = 0;
3947 if (hostname_size > 0)
3952 /* parse protocol */
3953 if ((p = strchr(url, ':'))) {
3954 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3961 /* no protocol means plain filename */
3962 av_strlcpy(path, url, path_size);
3966 /* separate path from hostname */
3967 ls = strchr(p, '/');
3968 ls2 = strchr(p, '?');
3972 ls = FFMIN(ls, ls2);
3974 av_strlcpy(path, ls, path_size);
3976 ls = &p[strlen(p)]; // XXX
3978 /* the rest is hostname, use that to parse auth/port */
3980 /* authorization (user[:pass]@hostname) */
3982 while ((at = strchr(p, '@')) && at < ls) {
3983 av_strlcpy(authorization, at2,
3984 FFMIN(authorization_size, at + 1 - at2));
3985 p = at + 1; /* skip '@' */
3988 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3990 av_strlcpy(hostname, p + 1,
3991 FFMIN(hostname_size, brk - p));
3992 if (brk[1] == ':' && port_ptr)
3993 *port_ptr = atoi(brk + 2);
3994 } else if ((col = strchr(p, ':')) && col < ls) {
3995 av_strlcpy(hostname, p,
3996 FFMIN(col + 1 - p, hostname_size));
3998 *port_ptr = atoi(col + 1);
4000 av_strlcpy(hostname, p,
4001 FFMIN(ls + 1 - p, hostname_size));
4005 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
4008 static const char hex_table_uc[16] = { '0', '1', '2', '3',
4011 'C', 'D', 'E', 'F' };
4012 static const char hex_table_lc[16] = { '0', '1', '2', '3',
4015 'c', 'd', 'e', 'f' };
4016 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
4018 for (i = 0; i < s; i++) {
4019 buff[i * 2] = hex_table[src[i] >> 4];
4020 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
4026 int ff_hex_to_data(uint8_t *data, const char *p)
4033 p += strspn(p, SPACE_CHARS);
4036 c = av_toupper((unsigned char) *p++);
4037 if (c >= '0' && c <= '9')
4039 else if (c >= 'A' && c <= 'F')
4054 #if FF_API_SET_PTS_INFO
4055 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
4056 unsigned int pts_num, unsigned int pts_den)
4058 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
4062 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
4063 unsigned int pts_num, unsigned int pts_den)
4066 if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
4067 if (new_tb.num != pts_num)
4068 av_log(NULL, AV_LOG_DEBUG,
4069 "st:%d removing common factor %d from timebase\n",
4070 s->index, pts_num / new_tb.num);
4072 av_log(NULL, AV_LOG_WARNING,
4073 "st:%d has too large timebase, reducing\n", s->index);
4075 if (new_tb.num <= 0 || new_tb.den <= 0) {
4076 av_log(NULL, AV_LOG_ERROR,
4077 "Ignoring attempt to set invalid timebase %d/%d for st:%d\n",
4078 new_tb.num, new_tb.den,
4082 s->time_base = new_tb;
4083 av_codec_set_pkt_timebase(s->codec, new_tb);
4084 s->pts_wrap_bits = pts_wrap_bits;
4087 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4090 const char *ptr = str;
4092 /* Parse key=value pairs. */
4095 char *dest = NULL, *dest_end;
4096 int key_len, dest_len = 0;
4098 /* Skip whitespace and potential commas. */
4099 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4106 if (!(ptr = strchr(key, '=')))
4109 key_len = ptr - key;
4111 callback_get_buf(context, key, key_len, &dest, &dest_len);
4112 dest_end = dest + dest_len - 1;
4116 while (*ptr && *ptr != '\"') {
4120 if (dest && dest < dest_end)
4124 if (dest && dest < dest_end)
4132 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4133 if (dest && dest < dest_end)
4141 int ff_find_stream_index(AVFormatContext *s, int id)
4144 for (i = 0; i < s->nb_streams; i++)
4145 if (s->streams[i]->id == id)
4150 int64_t ff_iso8601_to_unix_time(const char *datestr)
4152 struct tm time1 = { 0 }, time2 = { 0 };
4154 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4155 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4157 return av_timegm(&time2);
4159 return av_timegm(&time1);
4162 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id,
4166 if (ofmt->query_codec)
4167 return ofmt->query_codec(codec_id, std_compliance);
4168 else if (ofmt->codec_tag)
4169 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4170 else if (codec_id == ofmt->video_codec ||
4171 codec_id == ofmt->audio_codec ||
4172 codec_id == ofmt->subtitle_codec)
4175 return AVERROR_PATCHWELCOME;
4178 int avformat_network_init(void)
4182 ff_network_inited_globally = 1;
4183 if ((ret = ff_network_init()) < 0)
4190 int avformat_network_deinit(void)
4199 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4200 uint64_t channel_layout, int32_t sample_rate,
4201 int32_t width, int32_t height)
4207 return AVERROR(EINVAL);
4210 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4212 if (channel_layout) {
4214 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4218 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4220 if (width || height) {
4222 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4224 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4226 return AVERROR(ENOMEM);
4227 bytestream_put_le32(&data, flags);
4229 bytestream_put_le32(&data, channels);
4231 bytestream_put_le64(&data, channel_layout);
4233 bytestream_put_le32(&data, sample_rate);
4234 if (width || height) {
4235 bytestream_put_le32(&data, width);
4236 bytestream_put_le32(&data, height);
4241 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4243 AVRational undef = {0, 1};
4244 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4245 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4246 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4248 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4249 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4250 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4251 stream_sample_aspect_ratio = undef;
4253 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4254 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4255 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4256 frame_sample_aspect_ratio = undef;
4258 if (stream_sample_aspect_ratio.num)
4259 return stream_sample_aspect_ratio;
4261 return frame_sample_aspect_ratio;
4264 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4266 AVRational fr = st->r_frame_rate;
4267 AVRational codec_fr = av_inv_q(st->codec->time_base);
4268 AVRational avg_fr = st->avg_frame_rate;
4270 if (avg_fr.num > 0 && avg_fr.den > 0 && fr.num > 0 && fr.den > 0 &&
4271 av_q2d(avg_fr) < 70 && av_q2d(fr) > 210) {
4276 if (st->codec->ticks_per_frame > 1) {
4277 codec_fr.den *= st->codec->ticks_per_frame;
4278 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4279 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4286 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4289 if (*spec <= '9' && *spec >= '0') /* opt:index */
4290 return strtol(spec, NULL, 0) == st->index;
4291 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4292 *spec == 't') { /* opt:[vasdt] */
4293 enum AVMediaType type;
4296 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4297 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4298 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4299 case 'd': type = AVMEDIA_TYPE_DATA; break;
4300 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4301 default: av_assert0(0);
4303 if (type != st->codec->codec_type)
4305 if (*spec++ == ':') { /* possibly followed by :index */
4306 int i, index = strtol(spec, NULL, 0);
4307 for (i = 0; i < s->nb_streams; i++)
4308 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4309 return i == st->index;
4313 } else if (*spec == 'p' && *(spec + 1) == ':') {
4317 prog_id = strtol(spec, &endptr, 0);
4318 for (i = 0; i < s->nb_programs; i++) {
4319 if (s->programs[i]->id != prog_id)
4322 if (*endptr++ == ':') {
4323 int stream_idx = strtol(endptr, NULL, 0);
4324 return stream_idx >= 0 &&
4325 stream_idx < s->programs[i]->nb_stream_indexes &&
4326 st->index == s->programs[i]->stream_index[stream_idx];
4329 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4330 if (st->index == s->programs[i]->stream_index[j])
4334 } else if (*spec == '#' ||
4335 (*spec == 'i' && *(spec + 1) == ':')) {
4338 spec += 1 + (*spec == 'i');
4339 stream_id = strtol(spec, &endptr, 0);
4341 return stream_id == st->id;
4342 } else if (!*spec) /* empty specifier, matches everything */
4345 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4346 return AVERROR(EINVAL);
4349 int ff_generate_avci_extradata(AVStream *st)
4351 static const uint8_t avci100_1080p_extradata[] = {
4353 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4354 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4355 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4356 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4357 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4358 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4359 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4360 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4361 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4363 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4366 static const uint8_t avci100_1080i_extradata[] = {
4368 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4369 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4370 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4371 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4372 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4373 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4374 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4375 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4376 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4377 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4378 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4380 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4383 static const uint8_t avci50_1080i_extradata[] = {
4385 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4386 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4387 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4388 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4389 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4390 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4391 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4392 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4393 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4394 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4395 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4397 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4400 static const uint8_t avci100_720p_extradata[] = {
4402 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4403 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4404 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4405 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4406 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4407 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4408 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4409 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4410 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4411 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4413 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4417 const uint8_t *data = NULL;
4420 if (st->codec->width == 1920) {
4421 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4422 data = avci100_1080p_extradata;
4423 size = sizeof(avci100_1080p_extradata);
4425 data = avci100_1080i_extradata;
4426 size = sizeof(avci100_1080i_extradata);
4428 } else if (st->codec->width == 1440) {
4429 data = avci50_1080i_extradata;
4430 size = sizeof(avci50_1080i_extradata);
4431 } else if (st->codec->width == 1280) {
4432 data = avci100_720p_extradata;
4433 size = sizeof(avci100_720p_extradata);
4439 av_freep(&st->codec->extradata);
4440 if (ff_alloc_extradata(st->codec, size))
4441 return AVERROR(ENOMEM);
4442 memcpy(st->codec->extradata, data, size);
4447 uint8_t *av_stream_get_side_data(AVStream *st, enum AVPacketSideDataType type,
4452 for (i = 0; i < st->nb_side_data; i++) {
4453 if (st->side_data[i].type == type) {
4455 *size = st->side_data[i].size;
4456 return st->side_data[i].data;