2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "avio_internal.h"
27 #include "libavcodec/internal.h"
28 #include "libavcodec/raw.h"
29 #include "libavcodec/bytestream.h"
30 #include "libavutil/avassert.h"
31 #include "libavutil/opt.h"
32 #include "libavutil/dict.h"
33 #include "libavutil/pixdesc.h"
36 #include "libavutil/avassert.h"
37 #include "libavutil/avstring.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/parseutils.h"
40 #include "libavutil/time.h"
41 #include "libavutil/timestamp.h"
43 #include "audiointerleave.h"
55 * various utility functions for use within FFmpeg
58 unsigned avformat_version(void)
60 av_assert0(LIBAVFORMAT_VERSION_MICRO >= 100);
61 return LIBAVFORMAT_VERSION_INT;
64 const char *avformat_configuration(void)
66 return FFMPEG_CONFIGURATION;
69 const char *avformat_license(void)
71 #define LICENSE_PREFIX "libavformat license: "
72 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
75 #define RELATIVE_TS_BASE (INT64_MAX - (1LL<<48))
77 static int is_relative(int64_t ts) {
78 return ts > (RELATIVE_TS_BASE - (1LL<<48));
82 * Wrap a given time stamp, if there is an indication for an overflow
85 * @param timestamp the time stamp to wrap
86 * @return resulting time stamp
88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
90 if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
91 st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
92 if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
93 timestamp < st->pts_wrap_reference)
94 return timestamp + (1ULL<<st->pts_wrap_bits);
95 else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
96 timestamp >= st->pts_wrap_reference)
97 return timestamp - (1ULL<<st->pts_wrap_bits);
102 #define MAKE_ACCESSORS(str, name, type, field) \
103 type av_##name##_get_##field(const str *s) { return s->field; } \
104 void av_##name##_set_##field(str *s, type v) { s->field = v; }
106 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
108 /** head of registered input format linked list */
109 static AVInputFormat *first_iformat = NULL;
110 /** head of registered output format linked list */
111 static AVOutputFormat *first_oformat = NULL;
113 AVInputFormat *av_iformat_next(AVInputFormat *f)
115 if(f) return f->next;
116 else return first_iformat;
119 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
121 if(f) return f->next;
122 else return first_oformat;
125 void av_register_input_format(AVInputFormat *format)
129 while (*p != NULL) p = &(*p)->next;
134 void av_register_output_format(AVOutputFormat *format)
138 while (*p != NULL) p = &(*p)->next;
143 int av_match_ext(const char *filename, const char *extensions)
151 ext = strrchr(filename, '.');
157 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
160 if (!av_strcasecmp(ext1, ext))
170 static int match_format(const char *name, const char *names)
178 namelen = strlen(name);
179 while ((p = strchr(names, ','))) {
180 len = FFMAX(p - names, namelen);
181 if (!av_strncasecmp(name, names, len))
185 return !av_strcasecmp(name, names);
188 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
189 const char *mime_type)
191 AVOutputFormat *fmt = NULL, *fmt_found;
192 int score_max, score;
194 /* specific test for image sequences */
195 #if CONFIG_IMAGE2_MUXER
196 if (!short_name && filename &&
197 av_filename_number_test(filename) &&
198 ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
199 return av_guess_format("image2", NULL, NULL);
202 /* Find the proper file type. */
205 while ((fmt = av_oformat_next(fmt))) {
207 if (fmt->name && short_name && match_format(short_name, fmt->name))
209 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
211 if (filename && fmt->extensions &&
212 av_match_ext(filename, fmt->extensions)) {
215 if (score > score_max) {
223 enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
224 const char *filename, const char *mime_type, enum AVMediaType type){
225 if (!strcmp(fmt->name, "segment") || !strcmp(fmt->name, "ssegment")) {
226 fmt = av_guess_format(NULL, filename, NULL);
229 if(type == AVMEDIA_TYPE_VIDEO){
230 enum AVCodecID codec_id= AV_CODEC_ID_NONE;
232 #if CONFIG_IMAGE2_MUXER
233 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
234 codec_id= ff_guess_image2_codec(filename);
237 if(codec_id == AV_CODEC_ID_NONE)
238 codec_id= fmt->video_codec;
240 }else if(type == AVMEDIA_TYPE_AUDIO)
241 return fmt->audio_codec;
242 else if (type == AVMEDIA_TYPE_SUBTITLE)
243 return fmt->subtitle_codec;
245 return AV_CODEC_ID_NONE;
248 AVInputFormat *av_find_input_format(const char *short_name)
250 AVInputFormat *fmt = NULL;
251 while ((fmt = av_iformat_next(fmt))) {
252 if (match_format(short_name, fmt->name))
258 /* an arbitrarily chosen "sane" max packet size -- 50M */
259 #define SANE_CHUNK_SIZE (50000000)
261 int ffio_limit(AVIOContext *s, int size)
264 int64_t remaining= s->maxsize - avio_tell(s);
265 if(remaining < size){
266 int64_t newsize= avio_size(s);
267 if(!s->maxsize || s->maxsize<newsize)
268 s->maxsize= newsize - !newsize;
269 remaining= s->maxsize - avio_tell(s);
270 remaining= FFMAX(remaining, 0);
273 if(s->maxsize>=0 && remaining+1 < size){
274 av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
282 * Read the data in sane-sized chunks and append to pkt.
283 * Return the number of bytes read or an error.
285 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
287 int orig_pos = pkt->pos; // av_grow_packet might reset pos
288 int orig_size = pkt->size;
292 int prev_size = pkt->size;
296 * When the caller requests a lot of data, limit it to the amount left
297 * in file or SANE_CHUNK_SIZE when it is not known
300 if (read_size > SANE_CHUNK_SIZE/10) {
301 read_size = ffio_limit(s, read_size);
302 // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
304 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
307 ret = av_grow_packet(pkt, read_size);
311 ret = avio_read(s, pkt->data + prev_size, read_size);
312 if (ret != read_size) {
313 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
320 pkt->flags |= AV_PKT_FLAG_CORRUPT;
325 return pkt->size > orig_size ? pkt->size - orig_size : ret;
328 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
333 pkt->pos = avio_tell(s);
335 return append_packet_chunked(s, pkt, size);
338 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
341 return av_get_packet(s, pkt, size);
342 return append_packet_chunked(s, pkt, size);
346 int av_filename_number_test(const char *filename)
349 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
352 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
354 AVProbeData lpd = *pd;
355 AVInputFormat *fmt1 = NULL, *fmt;
356 int score, nodat = 0, score_max=0;
357 const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
360 lpd.buf = zerobuffer;
362 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
363 int id3len = ff_id3v2_tag_len(lpd.buf);
364 if (lpd.buf_size > id3len + 16) {
366 lpd.buf_size -= id3len;
372 while ((fmt1 = av_iformat_next(fmt1))) {
373 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
376 if (fmt1->read_probe) {
377 score = fmt1->read_probe(&lpd);
378 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
379 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
380 } else if (fmt1->extensions) {
381 if (av_match_ext(lpd.filename, fmt1->extensions)) {
385 if (score > score_max) {
388 }else if (score == score_max)
392 score_max = FFMIN(AVPROBE_SCORE_MAX/4-1, score_max);
393 *score_ret= score_max;
398 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
401 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
402 if(score_ret > *score_max){
403 *score_max= score_ret;
409 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
411 return av_probe_input_format2(pd, is_opened, &score);
414 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
416 static const struct {
417 const char *name; enum AVCodecID id; enum AVMediaType type;
419 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
420 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
421 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
422 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
423 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
424 { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
425 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
426 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
427 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
431 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
433 if (fmt && st->request_probe <= score) {
435 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
436 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
437 for (i = 0; fmt_id_type[i].name; i++) {
438 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
439 st->codec->codec_id = fmt_id_type[i].id;
440 st->codec->codec_type = fmt_id_type[i].type;
448 /************************************************************/
449 /* input media file */
451 int av_demuxer_open(AVFormatContext *ic){
454 if (ic->iformat->read_header) {
455 err = ic->iformat->read_header(ic);
460 if (ic->pb && !ic->data_offset)
461 ic->data_offset = avio_tell(ic->pb);
467 /** size of probe buffer, for guessing file type from file contents */
468 #define PROBE_BUF_MIN 2048
469 #define PROBE_BUF_MAX (1<<20)
471 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
472 const char *filename, void *logctx,
473 unsigned int offset, unsigned int max_probe_size)
475 AVProbeData pd = { filename ? filename : "", NULL, -offset };
476 unsigned char *buf = NULL;
478 int ret = 0, probe_size, buf_offset = 0;
480 if (!max_probe_size) {
481 max_probe_size = PROBE_BUF_MAX;
482 } else if (max_probe_size > PROBE_BUF_MAX) {
483 max_probe_size = PROBE_BUF_MAX;
484 } else if (max_probe_size < PROBE_BUF_MIN) {
485 av_log(logctx, AV_LOG_ERROR,
486 "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
487 return AVERROR(EINVAL);
490 if (offset >= max_probe_size) {
491 return AVERROR(EINVAL);
494 if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
495 if (!av_strcasecmp(mime_type, "audio/aacp")) {
496 *fmt = av_find_input_format("aac");
498 av_freep(&mime_type);
501 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
502 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
503 int score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
506 if (probe_size < offset) {
510 /* read probe data */
511 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
514 return AVERROR(ENOMEM);
517 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
518 /* fail if error was not end of file, otherwise, lower score */
519 if (ret != AVERROR_EOF) {
524 ret = 0; /* error was end of file, nothing read */
526 pd.buf_size = buf_offset += ret;
527 pd.buf = &buf[offset];
529 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
531 /* guess file format */
532 *fmt = av_probe_input_format2(&pd, 1, &score);
534 if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
535 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
537 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
543 return AVERROR_INVALIDDATA;
546 /* rewind. reuse probe buffer to avoid seeking */
547 ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
552 /* open input file and probe the format if necessary */
553 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
556 AVProbeData pd = {filename, NULL, 0};
557 int score = AVPROBE_SCORE_RETRY;
560 s->flags |= AVFMT_FLAG_CUSTOM_IO;
562 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
563 else if (s->iformat->flags & AVFMT_NOFILE)
564 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
565 "will be ignored with AVFMT_NOFILE format.\n");
569 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
570 (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
573 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
574 &s->interrupt_callback, options)) < 0)
578 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
581 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
582 AVPacketList **plast_pktl){
583 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
588 (*plast_pktl)->next = pktl;
590 *packet_buffer = pktl;
592 /* add the packet in the buffered packet list */
598 int avformat_queue_attached_pictures(AVFormatContext *s)
601 for (i = 0; i < s->nb_streams; i++)
602 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
603 s->streams[i]->discard < AVDISCARD_ALL) {
604 AVPacket copy = s->streams[i]->attached_pic;
605 copy.buf = av_buffer_ref(copy.buf);
607 return AVERROR(ENOMEM);
609 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
614 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
616 AVFormatContext *s = *ps;
618 AVDictionary *tmp = NULL;
619 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
621 if (!s && !(s = avformat_alloc_context()))
622 return AVERROR(ENOMEM);
624 av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
625 return AVERROR(EINVAL);
631 av_dict_copy(&tmp, *options, 0);
633 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
636 if ((ret = init_input(s, filename, &tmp)) < 0)
638 avio_skip(s->pb, s->skip_initial_bytes);
640 /* check filename in case an image number is expected */
641 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
642 if (!av_filename_number_test(filename)) {
643 ret = AVERROR(EINVAL);
648 s->duration = s->start_time = AV_NOPTS_VALUE;
649 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
651 /* allocate private data */
652 if (s->iformat->priv_data_size > 0) {
653 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
654 ret = AVERROR(ENOMEM);
657 if (s->iformat->priv_class) {
658 *(const AVClass**)s->priv_data = s->iformat->priv_class;
659 av_opt_set_defaults(s->priv_data);
660 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
665 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
667 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
669 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
670 if ((ret = s->iformat->read_header(s)) < 0)
673 if (id3v2_extra_meta) {
674 if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac")) {
675 if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
678 av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
680 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
682 if ((ret = avformat_queue_attached_pictures(s)) < 0)
685 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
686 s->data_offset = avio_tell(s->pb);
688 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
691 av_dict_free(options);
698 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
700 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
702 avformat_free_context(s);
707 /*******************************************************/
709 static void force_codec_ids(AVFormatContext *s, AVStream *st)
711 switch(st->codec->codec_type){
712 case AVMEDIA_TYPE_VIDEO:
713 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
715 case AVMEDIA_TYPE_AUDIO:
716 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
718 case AVMEDIA_TYPE_SUBTITLE:
719 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
724 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
726 if(st->request_probe>0){
727 AVProbeData *pd = &st->probe_data;
729 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
733 uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
737 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
738 pd->buf_size += pkt->size;
739 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
742 st->probe_packets = 0;
744 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
749 end= s->raw_packet_buffer_remaining_size <= 0
750 || st->probe_packets<=0;
752 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
753 int score= set_codec_from_probe_data(s, st, pd);
754 if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
758 st->request_probe= -1;
759 if(st->codec->codec_id != AV_CODEC_ID_NONE){
760 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
762 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
764 force_codec_ids(s, st);
769 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
775 AVPacketList *pktl = s->raw_packet_buffer;
779 st = s->streams[pkt->stream_index];
780 if (s->raw_packet_buffer_remaining_size <= 0)
781 probe_codec(s, st, NULL);
782 if(st->request_probe <= 0){
783 s->raw_packet_buffer = pktl->next;
784 s->raw_packet_buffer_remaining_size += pkt->size;
793 ret= s->iformat->read_packet(s, pkt);
795 if (!pktl || ret == AVERROR(EAGAIN))
797 for (i = 0; i < s->nb_streams; i++) {
799 if (st->probe_packets) {
800 probe_codec(s, st, NULL);
802 av_assert0(st->request_probe <= 0);
807 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
808 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
809 av_log(s, AV_LOG_WARNING,
810 "Dropped corrupted packet (stream = %d)\n",
816 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
817 av_packet_merge_side_data(pkt);
819 if(pkt->stream_index >= (unsigned)s->nb_streams){
820 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
824 st= s->streams[pkt->stream_index];
825 pkt->dts = wrap_timestamp(st, pkt->dts);
826 pkt->pts = wrap_timestamp(st, pkt->pts);
828 force_codec_ids(s, st);
830 /* TODO: audio: time filter; video: frame reordering (pts != dts) */
831 if (s->use_wallclock_as_timestamps)
832 pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
834 if(!pktl && st->request_probe <= 0)
837 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
838 s->raw_packet_buffer_remaining_size -= pkt->size;
840 probe_codec(s, st, pkt);
844 #if FF_API_READ_PACKET
845 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
847 return ff_read_packet(s, pkt);
852 /**********************************************************/
854 static int determinable_frame_size(AVCodecContext *avctx)
856 if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
857 avctx->codec_id == AV_CODEC_ID_MP1 ||
858 avctx->codec_id == AV_CODEC_ID_MP2 ||
859 avctx->codec_id == AV_CODEC_ID_MP3/* ||
860 avctx->codec_id == AV_CODEC_ID_CELT*/)
866 * Get the number of samples of an audio frame. Return -1 on error.
868 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
872 /* give frame_size priority if demuxing */
873 if (!mux && enc->frame_size > 1)
874 return enc->frame_size;
876 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
879 /* fallback to using frame_size if muxing */
880 if (enc->frame_size > 1)
881 return enc->frame_size;
883 //For WMA we currently have no other means to calculate duration thus we
884 //do it here by assuming CBR, which is true for all known cases.
885 if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
886 if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
887 return ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
895 * Return the frame duration in seconds. Return 0 if not available.
897 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
898 AVCodecParserContext *pc, AVPacket *pkt)
904 switch(st->codec->codec_type) {
905 case AVMEDIA_TYPE_VIDEO:
906 if (st->r_frame_rate.num && !pc) {
907 *pnum = st->r_frame_rate.den;
908 *pden = st->r_frame_rate.num;
909 } else if(st->time_base.num*1000LL > st->time_base.den) {
910 *pnum = st->time_base.num;
911 *pden = st->time_base.den;
912 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
913 *pnum = st->codec->time_base.num;
914 *pden = st->codec->time_base.den;
915 if (pc && pc->repeat_pict) {
916 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
917 *pden /= 1 + pc->repeat_pict;
919 *pnum *= 1 + pc->repeat_pict;
921 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
922 //Thus if we have no parser in such case leave duration undefined.
923 if(st->codec->ticks_per_frame>1 && !pc){
928 case AVMEDIA_TYPE_AUDIO:
929 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
930 if (frame_size <= 0 || st->codec->sample_rate <= 0)
933 *pden = st->codec->sample_rate;
940 static int is_intra_only(AVCodecContext *enc){
941 const AVCodecDescriptor *desc;
943 if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
946 desc = av_codec_get_codec_descriptor(enc);
948 desc = avcodec_descriptor_get(enc->codec_id);
949 av_codec_set_codec_descriptor(enc, desc);
952 return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
956 static int has_decode_delay_been_guessed(AVStream *st)
958 if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
959 if(!st->info) // if we have left find_stream_info then nb_decoded_frames wont increase anymore for stream copy
961 #if CONFIG_H264_DECODER
962 if(st->codec->has_b_frames &&
963 avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
966 if(st->codec->has_b_frames<3)
967 return st->nb_decoded_frames >= 7;
968 else if(st->codec->has_b_frames<4)
969 return st->nb_decoded_frames >= 18;
971 return st->nb_decoded_frames >= 20;
974 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
978 if (pktl == s->parse_queue_end)
979 return s->packet_buffer;
983 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index)
985 if (s->correct_ts_overflow && st->pts_wrap_bits < 63 &&
986 st->pts_wrap_reference == AV_NOPTS_VALUE && st->first_dts != AV_NOPTS_VALUE) {
989 // reference time stamp should be 60 s before first time stamp
990 int64_t pts_wrap_reference = st->first_dts - av_rescale(60, st->time_base.den, st->time_base.num);
991 // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
992 int pts_wrap_behavior = (st->first_dts < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
993 (st->first_dts < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
994 AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
996 AVProgram *first_program = av_find_program_from_stream(s, NULL, stream_index);
998 if (!first_program) {
999 int default_stream_index = av_find_default_stream_index(s);
1000 if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
1001 for (i=0; i<s->nb_streams; i++) {
1002 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
1003 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
1007 st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
1008 st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
1012 AVProgram *program = first_program;
1014 if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
1015 pts_wrap_reference = program->pts_wrap_reference;
1016 pts_wrap_behavior = program->pts_wrap_behavior;
1019 program = av_find_program_from_stream(s, program, stream_index);
1022 // update every program with differing pts_wrap_reference
1023 program = first_program;
1025 if (program->pts_wrap_reference != pts_wrap_reference) {
1026 for (i=0; i<program->nb_stream_indexes; i++) {
1027 s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
1028 s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
1031 program->pts_wrap_reference = pts_wrap_reference;
1032 program->pts_wrap_behavior = pts_wrap_behavior;
1034 program = av_find_program_from_stream(s, program, stream_index);
1042 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
1043 int64_t dts, int64_t pts, AVPacket *pkt)
1045 AVStream *st= s->streams[stream_index];
1046 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1047 int64_t pts_buffer[MAX_REORDER_DELAY+1];
1051 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
1054 delay = st->codec->has_b_frames;
1055 st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
1057 shift = st->first_dts - RELATIVE_TS_BASE;
1059 for (i=0; i<MAX_REORDER_DELAY+1; i++)
1060 pts_buffer[i] = AV_NOPTS_VALUE;
1062 if (is_relative(pts))
1065 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1066 if(pktl->pkt.stream_index != stream_index)
1068 if(is_relative(pktl->pkt.pts))
1069 pktl->pkt.pts += shift;
1071 if(is_relative(pktl->pkt.dts))
1072 pktl->pkt.dts += shift;
1074 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
1075 st->start_time= pktl->pkt.pts;
1077 if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1078 pts_buffer[0]= pktl->pkt.pts;
1079 for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
1080 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
1081 if(pktl->pkt.dts == AV_NOPTS_VALUE)
1082 pktl->pkt.dts= pts_buffer[0];
1086 if (update_wrap_reference(s, st, stream_index) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
1087 // correct first time stamps to negative values
1088 st->first_dts = wrap_timestamp(st, st->first_dts);
1089 st->cur_dts = wrap_timestamp(st, st->cur_dts);
1090 pkt->dts = wrap_timestamp(st, pkt->dts);
1091 pkt->pts = wrap_timestamp(st, pkt->pts);
1092 pts = wrap_timestamp(st, pts);
1095 if (st->start_time == AV_NOPTS_VALUE)
1096 st->start_time = pts;
1099 static void update_initial_durations(AVFormatContext *s, AVStream *st,
1100 int stream_index, int duration)
1102 AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1103 int64_t cur_dts= RELATIVE_TS_BASE;
1105 if(st->first_dts != AV_NOPTS_VALUE){
1106 cur_dts= st->first_dts;
1107 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1108 if(pktl->pkt.stream_index == stream_index){
1109 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1111 cur_dts -= duration;
1114 if(pktl && pktl->pkt.dts != st->first_dts) {
1115 av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s in the queue\n", av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts));
1119 av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1122 pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1123 st->first_dts = cur_dts;
1124 }else if(st->cur_dts != RELATIVE_TS_BASE)
1127 for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1128 if(pktl->pkt.stream_index != stream_index)
1130 if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1131 && !pktl->pkt.duration){
1132 pktl->pkt.dts= cur_dts;
1133 if(!st->codec->has_b_frames)
1134 pktl->pkt.pts= cur_dts;
1135 // if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1136 pktl->pkt.duration = duration;
1139 cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1142 st->cur_dts= cur_dts;
1145 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1146 AVCodecParserContext *pc, AVPacket *pkt)
1148 int num, den, presentation_delayed, delay, i;
1151 if (s->flags & AVFMT_FLAG_NOFILLIN)
1154 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1155 pkt->dts= AV_NOPTS_VALUE;
1157 if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1158 //FIXME Set low_delay = 0 when has_b_frames = 1
1159 st->codec->has_b_frames = 1;
1161 /* do we have a video B-frame ? */
1162 delay= st->codec->has_b_frames;
1163 presentation_delayed = 0;
1165 /* XXX: need has_b_frame, but cannot get it if the codec is
1168 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1169 presentation_delayed = 1;
1171 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && st->pts_wrap_bits<63 && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts){
1172 if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1173 pkt->dts -= 1LL<<st->pts_wrap_bits;
1175 pkt->pts += 1LL<<st->pts_wrap_bits;
1178 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1179 // we take the conservative approach and discard both
1180 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1181 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1182 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1183 if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1184 pkt->dts= AV_NOPTS_VALUE;
1187 if (pkt->duration == 0) {
1188 ff_compute_frame_duration(&num, &den, st, pc, pkt);
1190 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1193 if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1194 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1196 /* correct timestamps with byte offset if demuxers only have timestamps
1197 on packet boundaries */
1198 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1199 /* this will estimate bitrate based on this frame's duration and size */
1200 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1201 if(pkt->pts != AV_NOPTS_VALUE)
1203 if(pkt->dts != AV_NOPTS_VALUE)
1207 if (pc && pc->dts_sync_point >= 0) {
1208 // we have synchronization info from the parser
1209 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1211 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1212 if (pkt->dts != AV_NOPTS_VALUE) {
1213 // got DTS from the stream, update reference timestamp
1214 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1215 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1216 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1217 // compute DTS based on reference timestamp
1218 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1219 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1221 if (pc->dts_sync_point > 0)
1222 st->reference_dts = pkt->dts; // new reference
1226 /* This may be redundant, but it should not hurt. */
1227 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1228 presentation_delayed = 1;
1230 av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1231 presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1232 /* interpolate PTS and DTS if they are not present */
1233 //We skip H264 currently because delay and has_b_frames are not reliably set
1234 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1235 if (presentation_delayed) {
1236 /* DTS = decompression timestamp */
1237 /* PTS = presentation timestamp */
1238 if (pkt->dts == AV_NOPTS_VALUE)
1239 pkt->dts = st->last_IP_pts;
1240 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1241 if (pkt->dts == AV_NOPTS_VALUE)
1242 pkt->dts = st->cur_dts;
1244 /* this is tricky: the dts must be incremented by the duration
1245 of the frame we are displaying, i.e. the last I- or P-frame */
1246 if (st->last_IP_duration == 0)
1247 st->last_IP_duration = pkt->duration;
1248 if(pkt->dts != AV_NOPTS_VALUE)
1249 st->cur_dts = pkt->dts + st->last_IP_duration;
1250 st->last_IP_duration = pkt->duration;
1251 st->last_IP_pts= pkt->pts;
1252 /* cannot compute PTS if not present (we can compute it only
1253 by knowing the future */
1254 } else if (pkt->pts != AV_NOPTS_VALUE ||
1255 pkt->dts != AV_NOPTS_VALUE ||
1257 int duration = pkt->duration;
1259 /* presentation is not delayed : PTS and DTS are the same */
1260 if (pkt->pts == AV_NOPTS_VALUE)
1261 pkt->pts = pkt->dts;
1262 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1264 if (pkt->pts == AV_NOPTS_VALUE)
1265 pkt->pts = st->cur_dts;
1266 pkt->dts = pkt->pts;
1267 if (pkt->pts != AV_NOPTS_VALUE)
1268 st->cur_dts = pkt->pts + duration;
1272 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1273 st->pts_buffer[0]= pkt->pts;
1274 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1275 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1276 if(pkt->dts == AV_NOPTS_VALUE)
1277 pkt->dts= st->pts_buffer[0];
1279 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1280 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1282 if(pkt->dts > st->cur_dts)
1283 st->cur_dts = pkt->dts;
1285 av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1286 presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1289 if (is_intra_only(st->codec))
1290 pkt->flags |= AV_PKT_FLAG_KEY;
1292 pkt->convergence_duration = pc->convergence_duration;
1295 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1298 AVPacketList *pktl = *pkt_buf;
1299 *pkt_buf = pktl->next;
1300 av_free_packet(&pktl->pkt);
1303 *pkt_buf_end = NULL;
1307 * Parse a packet, add all split parts to parse_queue
1309 * @param pkt packet to parse, NULL when flushing the parser at end of stream
1311 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1313 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1314 AVStream *st = s->streams[stream_index];
1315 uint8_t *data = pkt ? pkt->data : NULL;
1316 int size = pkt ? pkt->size : 0;
1317 int ret = 0, got_output = 0;
1320 av_init_packet(&flush_pkt);
1323 } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1324 // preserve 0-size sync packets
1325 compute_pkt_fields(s, st, st->parser, pkt);
1328 while (size > 0 || (pkt == &flush_pkt && got_output)) {
1331 av_init_packet(&out_pkt);
1332 len = av_parser_parse2(st->parser, st->codec,
1333 &out_pkt.data, &out_pkt.size, data, size,
1334 pkt->pts, pkt->dts, pkt->pos);
1336 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1338 /* increment read pointer */
1342 got_output = !!out_pkt.size;
1347 /* set the duration */
1348 out_pkt.duration = 0;
1349 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1350 if (st->codec->sample_rate > 0) {
1351 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1352 (AVRational){ 1, st->codec->sample_rate },
1356 } else if (st->codec->time_base.num != 0 &&
1357 st->codec->time_base.den != 0) {
1358 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1359 st->codec->time_base,
1364 out_pkt.stream_index = st->index;
1365 out_pkt.pts = st->parser->pts;
1366 out_pkt.dts = st->parser->dts;
1367 out_pkt.pos = st->parser->pos;
1369 if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1370 out_pkt.pos = st->parser->frame_offset;
1372 if (st->parser->key_frame == 1 ||
1373 (st->parser->key_frame == -1 &&
1374 st->parser->pict_type == AV_PICTURE_TYPE_I))
1375 out_pkt.flags |= AV_PKT_FLAG_KEY;
1377 if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1378 out_pkt.flags |= AV_PKT_FLAG_KEY;
1380 compute_pkt_fields(s, st, st->parser, &out_pkt);
1382 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1383 out_pkt.buf = pkt->buf;
1385 #if FF_API_DESTRUCT_PACKET
1386 out_pkt.destruct = pkt->destruct;
1387 pkt->destruct = NULL;
1390 if ((ret = av_dup_packet(&out_pkt)) < 0)
1393 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1394 av_free_packet(&out_pkt);
1395 ret = AVERROR(ENOMEM);
1401 /* end of the stream => close and free the parser */
1402 if (pkt == &flush_pkt) {
1403 av_parser_close(st->parser);
1408 av_free_packet(pkt);
1412 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1413 AVPacketList **pkt_buffer_end,
1417 av_assert0(*pkt_buffer);
1420 *pkt_buffer = pktl->next;
1422 *pkt_buffer_end = NULL;
1427 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1429 int ret = 0, i, got_packet = 0;
1431 av_init_packet(pkt);
1433 while (!got_packet && !s->parse_queue) {
1437 /* read next packet */
1438 ret = ff_read_packet(s, &cur_pkt);
1440 if (ret == AVERROR(EAGAIN))
1442 /* flush the parsers */
1443 for(i = 0; i < s->nb_streams; i++) {
1445 if (st->parser && st->need_parsing)
1446 parse_packet(s, NULL, st->index);
1448 /* all remaining packets are now in parse_queue =>
1449 * really terminate parsing */
1453 st = s->streams[cur_pkt.stream_index];
1455 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1456 cur_pkt.dts != AV_NOPTS_VALUE &&
1457 cur_pkt.pts < cur_pkt.dts) {
1458 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1459 cur_pkt.stream_index,
1460 av_ts2str(cur_pkt.pts),
1461 av_ts2str(cur_pkt.dts),
1464 if (s->debug & FF_FDEBUG_TS)
1465 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1466 cur_pkt.stream_index,
1467 av_ts2str(cur_pkt.pts),
1468 av_ts2str(cur_pkt.dts),
1473 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1474 st->parser = av_parser_init(st->codec->codec_id);
1476 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1477 "%s, packets or times may be invalid.\n",
1478 avcodec_get_name(st->codec->codec_id));
1479 /* no parser available: just output the raw packets */
1480 st->need_parsing = AVSTREAM_PARSE_NONE;
1481 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1482 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1483 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1484 st->parser->flags |= PARSER_FLAG_ONCE;
1485 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1486 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1490 if (!st->need_parsing || !st->parser) {
1491 /* no parsing needed: we just output the packet as is */
1493 compute_pkt_fields(s, st, NULL, pkt);
1494 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1495 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1496 ff_reduce_index(s, st->index);
1497 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1500 } else if (st->discard < AVDISCARD_ALL) {
1501 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1505 av_free_packet(&cur_pkt);
1507 if (pkt->flags & AV_PKT_FLAG_KEY)
1508 st->skip_to_keyframe = 0;
1509 if (st->skip_to_keyframe) {
1510 av_free_packet(&cur_pkt);
1515 if (!got_packet && s->parse_queue)
1516 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1518 if(s->debug & FF_FDEBUG_TS)
1519 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1521 av_ts2str(pkt->pts),
1522 av_ts2str(pkt->dts),
1530 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1532 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1538 ret = s->packet_buffer ?
1539 read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1540 read_frame_internal(s, pkt);
1547 AVPacketList *pktl = s->packet_buffer;
1550 AVPacket *next_pkt = &pktl->pkt;
1552 if (next_pkt->dts != AV_NOPTS_VALUE) {
1553 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1554 // last dts seen for this stream. if any of packets following
1555 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1556 int64_t last_dts = next_pkt->dts;
1557 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1558 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1559 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1560 if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1561 next_pkt->pts = pktl->pkt.dts;
1563 if (last_dts != AV_NOPTS_VALUE) {
1564 // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1565 last_dts = pktl->pkt.dts;
1570 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1571 // Fixing the last reference frame had none pts issue (For MXF etc).
1572 // We only do this when
1574 // 2. we are not able to resolve a pts value for current packet.
1575 // 3. the packets for this stream at the end of the files had valid dts.
1576 next_pkt->pts = last_dts + next_pkt->duration;
1578 pktl = s->packet_buffer;
1581 /* read packet from packet buffer, if there is data */
1582 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1583 next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1584 ret = read_from_packet_buffer(&s->packet_buffer,
1585 &s->packet_buffer_end, pkt);
1590 ret = read_frame_internal(s, pkt);
1592 if (pktl && ret != AVERROR(EAGAIN)) {
1599 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1600 &s->packet_buffer_end)) < 0)
1601 return AVERROR(ENOMEM);
1606 st = s->streams[pkt->stream_index];
1607 if (st->skip_samples) {
1608 uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1609 AV_WL32(p, st->skip_samples);
1610 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1611 st->skip_samples = 0;
1614 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1615 ff_reduce_index(s, st->index);
1616 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1619 if (is_relative(pkt->dts))
1620 pkt->dts -= RELATIVE_TS_BASE;
1621 if (is_relative(pkt->pts))
1622 pkt->pts -= RELATIVE_TS_BASE;
1627 /* XXX: suppress the packet queue */
1628 static void flush_packet_queue(AVFormatContext *s)
1630 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1631 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1632 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1634 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1637 /*******************************************************/
1640 int av_find_default_stream_index(AVFormatContext *s)
1642 int first_audio_index = -1;
1646 if (s->nb_streams <= 0)
1648 for(i = 0; i < s->nb_streams; i++) {
1650 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1651 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1654 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1655 first_audio_index = i;
1657 return first_audio_index >= 0 ? first_audio_index : 0;
1661 * Flush the frame reader.
1663 void ff_read_frame_flush(AVFormatContext *s)
1668 flush_packet_queue(s);
1670 /* for each stream, reset read state */
1671 for(i = 0; i < s->nb_streams; i++) {
1675 av_parser_close(st->parser);
1678 st->last_IP_pts = AV_NOPTS_VALUE;
1679 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1680 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1681 st->reference_dts = AV_NOPTS_VALUE;
1683 st->probe_packets = MAX_PROBE_PACKETS;
1685 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1686 st->pts_buffer[j]= AV_NOPTS_VALUE;
1690 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1694 for(i = 0; i < s->nb_streams; i++) {
1695 AVStream *st = s->streams[i];
1697 st->cur_dts = av_rescale(timestamp,
1698 st->time_base.den * (int64_t)ref_st->time_base.num,
1699 st->time_base.num * (int64_t)ref_st->time_base.den);
1703 void ff_reduce_index(AVFormatContext *s, int stream_index)
1705 AVStream *st= s->streams[stream_index];
1706 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1708 if((unsigned)st->nb_index_entries >= max_entries){
1710 for(i=0; 2*i<st->nb_index_entries; i++)
1711 st->index_entries[i]= st->index_entries[2*i];
1712 st->nb_index_entries= i;
1716 int ff_add_index_entry(AVIndexEntry **index_entries,
1717 int *nb_index_entries,
1718 unsigned int *index_entries_allocated_size,
1719 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1721 AVIndexEntry *entries, *ie;
1724 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1727 if(timestamp == AV_NOPTS_VALUE)
1728 return AVERROR(EINVAL);
1730 if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1731 timestamp -= RELATIVE_TS_BASE;
1733 entries = av_fast_realloc(*index_entries,
1734 index_entries_allocated_size,
1735 (*nb_index_entries + 1) *
1736 sizeof(AVIndexEntry));
1740 *index_entries= entries;
1742 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1745 index= (*nb_index_entries)++;
1746 ie= &entries[index];
1747 av_assert0(index==0 || ie[-1].timestamp < timestamp);
1749 ie= &entries[index];
1750 if(ie->timestamp != timestamp){
1751 if(ie->timestamp <= timestamp)
1753 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1754 (*nb_index_entries)++;
1755 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1756 distance= ie->min_distance;
1760 ie->timestamp = timestamp;
1761 ie->min_distance= distance;
1768 int av_add_index_entry(AVStream *st,
1769 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1771 timestamp = wrap_timestamp(st, timestamp);
1772 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1773 &st->index_entries_allocated_size, pos,
1774 timestamp, size, distance, flags);
1777 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1778 int64_t wanted_timestamp, int flags)
1786 //optimize appending index entries at the end
1787 if(b && entries[b-1].timestamp < wanted_timestamp)
1792 timestamp = entries[m].timestamp;
1793 if(timestamp >= wanted_timestamp)
1795 if(timestamp <= wanted_timestamp)
1798 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1800 if(!(flags & AVSEEK_FLAG_ANY)){
1801 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1802 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1811 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1814 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1815 wanted_timestamp, flags);
1818 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1819 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1821 int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1822 if (stream_index >= 0)
1823 ts = wrap_timestamp(s->streams[stream_index], ts);
1827 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1829 AVInputFormat *avif= s->iformat;
1830 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1831 int64_t ts_min, ts_max, ts;
1836 if (stream_index < 0)
1839 av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1842 ts_min= AV_NOPTS_VALUE;
1843 pos_limit= -1; //gcc falsely says it may be uninitialized
1845 st= s->streams[stream_index];
1846 if(st->index_entries){
1849 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1850 index= FFMAX(index, 0);
1851 e= &st->index_entries[index];
1853 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1855 ts_min= e->timestamp;
1856 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1857 pos_min, av_ts2str(ts_min));
1859 av_assert1(index==0);
1862 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1863 av_assert0(index < st->nb_index_entries);
1865 e= &st->index_entries[index];
1866 av_assert1(e->timestamp >= target_ts);
1868 ts_max= e->timestamp;
1869 pos_limit= pos_max - e->min_distance;
1870 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1871 pos_max, pos_limit, av_ts2str(ts_max));
1875 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1880 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1883 ff_read_frame_flush(s);
1884 ff_update_cur_dts(s, st, ts);
1889 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1890 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1891 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1892 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1895 int64_t start_pos, filesize;
1898 av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1900 if(ts_min == AV_NOPTS_VALUE){
1901 pos_min = s->data_offset;
1902 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1903 if (ts_min == AV_NOPTS_VALUE)
1907 if(ts_min >= target_ts){
1912 if(ts_max == AV_NOPTS_VALUE){
1914 filesize = avio_size(s->pb);
1915 pos_max = filesize - 1;
1917 pos_max = FFMAX(0, pos_max - step);
1918 ts_max = ff_read_timestamp(s, stream_index, &pos_max, pos_max + step, read_timestamp);
1920 }while(ts_max == AV_NOPTS_VALUE && pos_max > 0);
1921 if (ts_max == AV_NOPTS_VALUE)
1925 int64_t tmp_pos= pos_max + 1;
1926 int64_t tmp_ts= ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1927 if(tmp_ts == AV_NOPTS_VALUE)
1931 if(tmp_pos >= filesize)
1937 if(ts_max <= target_ts){
1942 if(ts_min > ts_max){
1944 }else if(ts_min == ts_max){
1949 while (pos_min < pos_limit) {
1950 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1951 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1952 assert(pos_limit <= pos_max);
1955 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1956 // interpolate position (better than dichotomy)
1957 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1958 + pos_min - approximate_keyframe_distance;
1959 }else if(no_change==1){
1960 // bisection, if interpolation failed to change min or max pos last time
1961 pos = (pos_min + pos_limit)>>1;
1963 /* linear search if bisection failed, can only happen if there
1964 are very few or no keyframes between min/max */
1969 else if(pos > pos_limit)
1973 ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1978 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1979 pos_min, pos, pos_max,
1980 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1981 pos_limit, start_pos, no_change);
1982 if(ts == AV_NOPTS_VALUE){
1983 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1986 assert(ts != AV_NOPTS_VALUE);
1987 if (target_ts <= ts) {
1988 pos_limit = start_pos - 1;
1992 if (target_ts >= ts) {
1998 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1999 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
2002 ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2004 ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
2005 av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
2006 pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
2012 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
2013 int64_t pos_min, pos_max;
2015 pos_min = s->data_offset;
2016 pos_max = avio_size(s->pb) - 1;
2018 if (pos < pos_min) pos= pos_min;
2019 else if(pos > pos_max) pos= pos_max;
2021 avio_seek(s->pb, pos, SEEK_SET);
2023 s->io_repositioned = 1;
2028 static int seek_frame_generic(AVFormatContext *s,
2029 int stream_index, int64_t timestamp, int flags)
2036 st = s->streams[stream_index];
2038 index = av_index_search_timestamp(st, timestamp, flags);
2040 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
2043 if(index < 0 || index==st->nb_index_entries-1){
2047 if(st->nb_index_entries){
2048 av_assert0(st->index_entries);
2049 ie= &st->index_entries[st->nb_index_entries-1];
2050 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2052 ff_update_cur_dts(s, st, ie->timestamp);
2054 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
2060 read_status = av_read_frame(s, &pkt);
2061 } while (read_status == AVERROR(EAGAIN));
2062 if (read_status < 0)
2064 av_free_packet(&pkt);
2065 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
2066 if(pkt.flags & AV_PKT_FLAG_KEY)
2068 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
2069 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);
2074 index = av_index_search_timestamp(st, timestamp, flags);
2079 ff_read_frame_flush(s);
2080 if (s->iformat->read_seek){
2081 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2084 ie = &st->index_entries[index];
2085 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2087 ff_update_cur_dts(s, st, ie->timestamp);
2092 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2093 int64_t timestamp, int flags)
2098 if (flags & AVSEEK_FLAG_BYTE) {
2099 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2101 ff_read_frame_flush(s);
2102 return seek_frame_byte(s, stream_index, timestamp, flags);
2105 if(stream_index < 0){
2106 stream_index= av_find_default_stream_index(s);
2107 if(stream_index < 0)
2110 st= s->streams[stream_index];
2111 /* timestamp for default must be expressed in AV_TIME_BASE units */
2112 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2115 /* first, we try the format specific seek */
2116 if (s->iformat->read_seek) {
2117 ff_read_frame_flush(s);
2118 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2125 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2126 ff_read_frame_flush(s);
2127 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2128 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2129 ff_read_frame_flush(s);
2130 return seek_frame_generic(s, stream_index, timestamp, flags);
2136 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2138 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
2141 ret = avformat_queue_attached_pictures(s);
2146 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2148 if(min_ts > ts || max_ts < ts)
2150 if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2151 return AVERROR(EINVAL);
2154 flags |= AVSEEK_FLAG_ANY;
2156 if (s->iformat->read_seek2) {
2158 ff_read_frame_flush(s);
2160 if (stream_index == -1 && s->nb_streams == 1) {
2161 AVRational time_base = s->streams[0]->time_base;
2162 ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2163 min_ts = av_rescale_rnd(min_ts, time_base.den,
2164 time_base.num * (int64_t)AV_TIME_BASE,
2165 AV_ROUND_UP | AV_ROUND_PASS_MINMAX);
2166 max_ts = av_rescale_rnd(max_ts, time_base.den,
2167 time_base.num * (int64_t)AV_TIME_BASE,
2168 AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2171 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2174 ret = avformat_queue_attached_pictures(s);
2178 if(s->iformat->read_timestamp){
2179 //try to seek via read_timestamp()
2182 //Fallback to old API if new is not implemented but old is
2183 //Note the old has somewhat different semantics
2184 if (s->iformat->read_seek || 1) {
2185 int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2186 int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2187 if (ret<0 && ts != min_ts && max_ts != ts) {
2188 ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2190 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2195 // try some generic seek like seek_frame_generic() but with new ts semantics
2196 return -1; //unreachable
2199 /*******************************************************/
2202 * Return TRUE if the stream has accurate duration in any stream.
2204 * @return TRUE if the stream has accurate duration for at least one component.
2206 static int has_duration(AVFormatContext *ic)
2211 for(i = 0;i < ic->nb_streams; i++) {
2212 st = ic->streams[i];
2213 if (st->duration != AV_NOPTS_VALUE)
2216 if (ic->duration != AV_NOPTS_VALUE)
2222 * Estimate the stream timings from the one of each components.
2224 * Also computes the global bitrate if possible.
2226 static void update_stream_timings(AVFormatContext *ic)
2228 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2229 int64_t duration, duration1, filesize;
2234 start_time = INT64_MAX;
2235 start_time_text = INT64_MAX;
2236 end_time = INT64_MIN;
2237 duration = INT64_MIN;
2238 for(i = 0;i < ic->nb_streams; i++) {
2239 st = ic->streams[i];
2240 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2241 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2242 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2243 if (start_time1 < start_time_text)
2244 start_time_text = start_time1;
2246 start_time = FFMIN(start_time, start_time1);
2247 end_time1 = AV_NOPTS_VALUE;
2248 if (st->duration != AV_NOPTS_VALUE) {
2249 end_time1 = start_time1
2250 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2251 end_time = FFMAX(end_time, end_time1);
2253 for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2254 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2255 p->start_time = start_time1;
2256 if(p->end_time < end_time1)
2257 p->end_time = end_time1;
2260 if (st->duration != AV_NOPTS_VALUE) {
2261 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2262 duration = FFMAX(duration, duration1);
2265 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2266 start_time = start_time_text;
2267 else if(start_time > start_time_text)
2268 av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2270 if (start_time != INT64_MAX) {
2271 ic->start_time = start_time;
2272 if (end_time != INT64_MIN) {
2273 if (ic->nb_programs) {
2274 for (i=0; i<ic->nb_programs; i++) {
2275 p = ic->programs[i];
2276 if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2277 duration = FFMAX(duration, p->end_time - p->start_time);
2280 duration = FFMAX(duration, end_time - start_time);
2283 if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2284 ic->duration = duration;
2286 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2287 /* compute the bitrate */
2288 double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2289 (double)ic->duration;
2290 if (bitrate >= 0 && bitrate <= INT_MAX)
2291 ic->bit_rate = bitrate;
2295 static void fill_all_stream_timings(AVFormatContext *ic)
2300 update_stream_timings(ic);
2301 for(i = 0;i < ic->nb_streams; i++) {
2302 st = ic->streams[i];
2303 if (st->start_time == AV_NOPTS_VALUE) {
2304 if(ic->start_time != AV_NOPTS_VALUE)
2305 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2306 if(ic->duration != AV_NOPTS_VALUE)
2307 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2312 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2314 int64_t filesize, duration;
2315 int bit_rate, i, show_warning = 0;
2318 /* if bit_rate is already set, we believe it */
2319 if (ic->bit_rate <= 0) {
2321 for(i=0;i<ic->nb_streams;i++) {
2322 st = ic->streams[i];
2323 if (st->codec->bit_rate > 0)
2324 bit_rate += st->codec->bit_rate;
2326 ic->bit_rate = bit_rate;
2329 /* if duration is already set, we believe it */
2330 if (ic->duration == AV_NOPTS_VALUE &&
2331 ic->bit_rate != 0) {
2332 filesize = ic->pb ? avio_size(ic->pb) : 0;
2334 for(i = 0; i < ic->nb_streams; i++) {
2335 st = ic->streams[i];
2336 if ( st->time_base.num <= INT64_MAX / ic->bit_rate
2337 && st->duration == AV_NOPTS_VALUE) {
2338 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2339 st->duration = duration;
2346 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2349 #define DURATION_MAX_READ_SIZE 250000LL
2350 #define DURATION_MAX_RETRY 4
2352 /* only usable for MPEG-PS streams */
2353 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2355 AVPacket pkt1, *pkt = &pkt1;
2357 int read_size, i, ret;
2359 int64_t filesize, offset, duration;
2362 /* flush packet queue */
2363 flush_packet_queue(ic);
2365 for (i=0; i<ic->nb_streams; i++) {
2366 st = ic->streams[i];
2367 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2368 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2371 av_parser_close(st->parser);
2376 /* estimate the end time (duration) */
2377 /* XXX: may need to support wrapping */
2378 filesize = ic->pb ? avio_size(ic->pb) : 0;
2379 end_time = AV_NOPTS_VALUE;
2381 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2385 avio_seek(ic->pb, offset, SEEK_SET);
2388 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2392 ret = ff_read_packet(ic, pkt);
2393 } while(ret == AVERROR(EAGAIN));
2396 read_size += pkt->size;
2397 st = ic->streams[pkt->stream_index];
2398 if (pkt->pts != AV_NOPTS_VALUE &&
2399 (st->start_time != AV_NOPTS_VALUE ||
2400 st->first_dts != AV_NOPTS_VALUE)) {
2401 duration = end_time = pkt->pts;
2402 if (st->start_time != AV_NOPTS_VALUE)
2403 duration -= st->start_time;
2405 duration -= st->first_dts;
2407 if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2408 (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2409 st->duration = duration;
2410 st->info->last_duration = duration;
2413 av_free_packet(pkt);
2415 }while( end_time==AV_NOPTS_VALUE
2416 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2417 && ++retry <= DURATION_MAX_RETRY);
2419 fill_all_stream_timings(ic);
2421 avio_seek(ic->pb, old_offset, SEEK_SET);
2422 for (i=0; i<ic->nb_streams; i++) {
2424 st->cur_dts= st->first_dts;
2425 st->last_IP_pts = AV_NOPTS_VALUE;
2426 st->reference_dts = AV_NOPTS_VALUE;
2430 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2434 /* get the file size, if possible */
2435 if (ic->iformat->flags & AVFMT_NOFILE) {
2438 file_size = avio_size(ic->pb);
2439 file_size = FFMAX(0, file_size);
2442 if ((!strcmp(ic->iformat->name, "mpeg") ||
2443 !strcmp(ic->iformat->name, "mpegts")) &&
2444 file_size && ic->pb->seekable) {
2445 /* get accurate estimate from the PTSes */
2446 estimate_timings_from_pts(ic, old_offset);
2447 ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2448 } else if (has_duration(ic)) {
2449 /* at least one component has timings - we use them for all
2451 fill_all_stream_timings(ic);
2452 ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2454 /* less precise: use bitrate info */
2455 estimate_timings_from_bit_rate(ic);
2456 ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2458 update_stream_timings(ic);
2462 AVStream av_unused *st;
2463 for(i = 0;i < ic->nb_streams; i++) {
2464 st = ic->streams[i];
2465 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2466 (double) st->start_time / AV_TIME_BASE,
2467 (double) st->duration / AV_TIME_BASE);
2469 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2470 (double) ic->start_time / AV_TIME_BASE,
2471 (double) ic->duration / AV_TIME_BASE,
2472 ic->bit_rate / 1000);
2476 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2478 AVCodecContext *avctx = st->codec;
2480 #define FAIL(errmsg) do { \
2482 *errmsg_ptr = errmsg; \
2486 switch (avctx->codec_type) {
2487 case AVMEDIA_TYPE_AUDIO:
2488 if (!avctx->frame_size && determinable_frame_size(avctx))
2489 FAIL("unspecified frame size");
2490 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2491 FAIL("unspecified sample format");
2492 if (!avctx->sample_rate)
2493 FAIL("unspecified sample rate");
2494 if (!avctx->channels)
2495 FAIL("unspecified number of channels");
2496 if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2497 FAIL("no decodable DTS frames");
2499 case AVMEDIA_TYPE_VIDEO:
2501 FAIL("unspecified size");
2502 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2503 FAIL("unspecified pixel format");
2504 if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2505 if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2506 FAIL("no frame in rv30/40 and no sar");
2508 case AVMEDIA_TYPE_SUBTITLE:
2509 if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2510 FAIL("unspecified size");
2512 case AVMEDIA_TYPE_DATA:
2513 if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2516 if (avctx->codec_id == AV_CODEC_ID_NONE)
2517 FAIL("unknown codec");
2521 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2522 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2524 const AVCodec *codec;
2525 int got_picture = 1, ret = 0;
2526 AVFrame *frame = avcodec_alloc_frame();
2527 AVSubtitle subtitle;
2528 AVPacket pkt = *avpkt;
2531 return AVERROR(ENOMEM);
2533 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2534 AVDictionary *thread_opt = NULL;
2536 codec = st->codec->codec ? st->codec->codec :
2537 avcodec_find_decoder(st->codec->codec_id);
2540 st->info->found_decoder = -1;
2545 /* force thread count to 1 since the h264 decoder will not extract SPS
2546 * and PPS to extradata during multi-threaded decoding */
2547 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2548 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2550 av_dict_free(&thread_opt);
2552 st->info->found_decoder = -1;
2555 st->info->found_decoder = 1;
2556 } else if (!st->info->found_decoder)
2557 st->info->found_decoder = 1;
2559 if (st->info->found_decoder < 0) {
2564 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2566 (!has_codec_parameters(st, NULL) ||
2567 !has_decode_delay_been_guessed(st) ||
2568 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2570 avcodec_get_frame_defaults(frame);
2571 switch(st->codec->codec_type) {
2572 case AVMEDIA_TYPE_VIDEO:
2573 ret = avcodec_decode_video2(st->codec, frame,
2574 &got_picture, &pkt);
2576 case AVMEDIA_TYPE_AUDIO:
2577 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2579 case AVMEDIA_TYPE_SUBTITLE:
2580 ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2581 &got_picture, &pkt);
2589 st->nb_decoded_frames++;
2596 if(!pkt.data && !got_picture)
2600 avcodec_free_frame(&frame);
2604 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2606 while (tags->id != AV_CODEC_ID_NONE) {
2614 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2617 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2618 if(tag == tags[i].tag)
2621 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2622 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2625 return AV_CODEC_ID_NONE;
2628 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2632 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2633 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2634 default: return AV_CODEC_ID_NONE;
2639 if (sflags & (1 << (bps - 1))) {
2641 case 1: return AV_CODEC_ID_PCM_S8;
2642 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2643 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2644 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2645 default: return AV_CODEC_ID_NONE;
2649 case 1: return AV_CODEC_ID_PCM_U8;
2650 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2651 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2652 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2653 default: return AV_CODEC_ID_NONE;
2659 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2662 if (!av_codec_get_tag2(tags, id, &tag))
2667 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2671 for(i=0; tags && tags[i]; i++){
2672 const AVCodecTag *codec_tags = tags[i];
2673 while (codec_tags->id != AV_CODEC_ID_NONE) {
2674 if (codec_tags->id == id) {
2675 *tag = codec_tags->tag;
2684 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2687 for(i=0; tags && tags[i]; i++){
2688 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2689 if(id!=AV_CODEC_ID_NONE) return id;
2691 return AV_CODEC_ID_NONE;
2694 static void compute_chapters_end(AVFormatContext *s)
2697 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2699 for (i = 0; i < s->nb_chapters; i++)
2700 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2701 AVChapter *ch = s->chapters[i];
2702 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2705 for (j = 0; j < s->nb_chapters; j++) {
2706 AVChapter *ch1 = s->chapters[j];
2707 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2708 if (j != i && next_start > ch->start && next_start < end)
2711 ch->end = (end == INT64_MAX) ? ch->start : end;
2715 static int get_std_framerate(int i){
2716 if(i<60*12) return (i+1)*1001;
2717 else return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2721 * Is the time base unreliable.
2722 * This is a heuristic to balance between quick acceptance of the values in
2723 * the headers vs. some extra checks.
2724 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2725 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2726 * And there are "variable" fps files this needs to detect as well.
2728 static int tb_unreliable(AVCodecContext *c){
2729 if( c->time_base.den >= 101L*c->time_base.num
2730 || c->time_base.den < 5L*c->time_base.num
2731 /* || c->codec_tag == AV_RL32("DIVX")
2732 || c->codec_tag == AV_RL32("XVID")*/
2733 || c->codec_tag == AV_RL32("mp4v")
2734 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2735 || c->codec_id == AV_CODEC_ID_H264
2741 #if FF_API_FORMAT_PARAMETERS
2742 int av_find_stream_info(AVFormatContext *ic)
2744 return avformat_find_stream_info(ic, NULL);
2748 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2750 int i, count, ret, j;
2753 AVPacket pkt1, *pkt;
2754 int64_t old_offset = avio_tell(ic->pb);
2755 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2756 int flush_codecs = ic->probesize > 0;
2759 av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
2761 for(i=0;i<ic->nb_streams;i++) {
2762 const AVCodec *codec;
2763 AVDictionary *thread_opt = NULL;
2764 st = ic->streams[i];
2766 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2767 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2768 /* if(!st->time_base.num)
2770 if(!st->codec->time_base.num)
2771 st->codec->time_base= st->time_base;
2773 //only for the split stuff
2774 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2775 st->parser = av_parser_init(st->codec->codec_id);
2777 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2778 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2779 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2780 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2782 } else if (st->need_parsing) {
2783 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2784 "%s, packets or times may be invalid.\n",
2785 avcodec_get_name(st->codec->codec_id));
2788 codec = st->codec->codec ? st->codec->codec :
2789 avcodec_find_decoder(st->codec->codec_id);
2791 /* force thread count to 1 since the h264 decoder will not extract SPS
2792 * and PPS to extradata during multi-threaded decoding */
2793 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2795 /* Ensure that subtitle_header is properly set. */
2796 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2797 && codec && !st->codec->codec)
2798 avcodec_open2(st->codec, codec, options ? &options[i]
2801 //try to just open decoders, in case this is enough to get parameters
2802 if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2803 if (codec && !st->codec->codec)
2804 avcodec_open2(st->codec, codec, options ? &options[i]
2808 av_dict_free(&thread_opt);
2811 for (i=0; i<ic->nb_streams; i++) {
2812 #if FF_API_R_FRAME_RATE
2813 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2815 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2816 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2822 if (ff_check_interrupt(&ic->interrupt_callback)){
2824 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2828 /* check if one codec still needs to be handled */
2829 for(i=0;i<ic->nb_streams;i++) {
2830 int fps_analyze_framecount = 20;
2832 st = ic->streams[i];
2833 if (!has_codec_parameters(st, NULL))
2835 /* if the timebase is coarse (like the usual millisecond precision
2836 of mkv), we need to analyze more frames to reliably arrive at
2838 if (av_q2d(st->time_base) > 0.0005)
2839 fps_analyze_framecount *= 2;
2840 if (ic->fps_probe_size >= 0)
2841 fps_analyze_framecount = ic->fps_probe_size;
2842 if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2843 fps_analyze_framecount = 0;
2844 /* variable fps and no guess at the real fps */
2845 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2846 && st->info->duration_count < fps_analyze_framecount
2847 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2849 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2851 if (st->first_dts == AV_NOPTS_VALUE &&
2852 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2853 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2856 if (i == ic->nb_streams) {
2857 /* NOTE: if the format has no header, then we need to read
2858 some packets to get most of the streams, so we cannot
2860 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2861 /* if we found the info for all the codecs, we can stop */
2863 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2868 /* we did not get all the codec info, but we read too much data */
2869 if (read_size >= ic->probesize) {
2871 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2872 for (i = 0; i < ic->nb_streams; i++)
2873 if (!ic->streams[i]->r_frame_rate.num &&
2874 ic->streams[i]->info->duration_count <= 1)
2875 av_log(ic, AV_LOG_WARNING,
2876 "Stream #%d: not enough frames to estimate rate; "
2877 "consider increasing probesize\n", i);
2881 /* NOTE: a new stream can be added there if no header in file
2882 (AVFMTCTX_NOHEADER) */
2883 ret = read_frame_internal(ic, &pkt1);
2884 if (ret == AVERROR(EAGAIN))
2892 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2895 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2896 &ic->packet_buffer_end);
2897 if ((ret = av_dup_packet(pkt)) < 0)
2898 goto find_stream_info_err;
2901 read_size += pkt->size;
2903 st = ic->streams[pkt->stream_index];
2904 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2905 /* check for non-increasing dts */
2906 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2907 st->info->fps_last_dts >= pkt->dts) {
2908 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2909 "packet %d with DTS %"PRId64", packet %d with DTS "
2910 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2911 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2912 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2914 /* check for a discontinuity in dts - if the difference in dts
2915 * is more than 1000 times the average packet duration in the sequence,
2916 * we treat it as a discontinuity */
2917 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2918 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2919 (pkt->dts - st->info->fps_last_dts) / 1000 >
2920 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2921 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2922 "packet %d with DTS %"PRId64", packet %d with DTS "
2923 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2924 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2925 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2928 /* update stored dts values */
2929 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2930 st->info->fps_first_dts = pkt->dts;
2931 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2933 st->info->fps_last_dts = pkt->dts;
2934 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2936 if (st->codec_info_nb_frames>1) {
2938 if (st->time_base.den > 0)
2939 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2940 if (st->avg_frame_rate.num > 0)
2941 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2943 if (t >= ic->max_analyze_duration) {
2944 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
2947 if (pkt->duration) {
2948 st->info->codec_info_duration += pkt->duration;
2949 st->info->codec_info_duration_fields += st->parser && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
2952 #if FF_API_R_FRAME_RATE
2954 int64_t last = st->info->last_dts;
2956 if( pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last
2957 && pkt->dts - (uint64_t)last < INT64_MAX){
2958 double dts= (is_relative(pkt->dts) ? pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2959 int64_t duration= pkt->dts - last;
2961 if (!st->info->duration_error)
2962 st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2964 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2965 // av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2966 for (i=0; i<MAX_STD_TIMEBASES; i++) {
2967 int framerate= get_std_framerate(i);
2968 double sdts= dts*framerate/(1001*12);
2970 int64_t ticks= llrint(sdts+j*0.5);
2971 double error= sdts - ticks + j*0.5;
2972 st->info->duration_error[j][0][i] += error;
2973 st->info->duration_error[j][1][i] += error*error;
2976 st->info->duration_count++;
2977 // ignore the first 4 values, they might have some random jitter
2978 if (st->info->duration_count > 3 && is_relative(pkt->dts) == is_relative(last))
2979 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2981 if (pkt->dts != AV_NOPTS_VALUE)
2982 st->info->last_dts = pkt->dts;
2985 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2986 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2987 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2988 st->codec->extradata_size= i;
2989 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2990 if (!st->codec->extradata)
2991 return AVERROR(ENOMEM);
2992 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2993 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2997 /* if still no information, we try to open the codec and to
2998 decompress the frame. We try to avoid that in most cases as
2999 it takes longer and uses more memory. For MPEG-4, we need to
3000 decompress for QuickTime.
3002 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3003 least one frame of codec data, this makes sure the codec initializes
3004 the channel configuration and does not only trust the values from the container.
3006 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3008 st->codec_info_nb_frames++;
3013 AVPacket empty_pkt = { 0 };
3015 av_init_packet(&empty_pkt);
3017 ret = -1; /* we could not have all the codec parameters before EOF */
3018 for(i=0;i<ic->nb_streams;i++) {
3021 st = ic->streams[i];
3023 /* flush the decoders */
3024 if (st->info->found_decoder == 1) {
3026 err = try_decode_frame(st, &empty_pkt,
3027 (options && i < orig_nb_streams) ?
3028 &options[i] : NULL);
3029 } while (err > 0 && !has_codec_parameters(st, NULL));
3032 av_log(ic, AV_LOG_INFO,
3033 "decoding for stream %d failed\n", st->index);
3037 if (!has_codec_parameters(st, &errmsg)) {
3039 avcodec_string(buf, sizeof(buf), st->codec, 0);
3040 av_log(ic, AV_LOG_WARNING,
3041 "Could not find codec parameters for stream %d (%s): %s\n"
3042 "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3050 // close codecs which were opened in try_decode_frame()
3051 for(i=0;i<ic->nb_streams;i++) {
3052 st = ic->streams[i];
3053 avcodec_close(st->codec);
3055 for(i=0;i<ic->nb_streams;i++) {
3056 st = ic->streams[i];
3057 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3058 if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3059 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3060 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3061 st->codec->codec_tag= tag;
3064 /* estimate average framerate if not set by demuxer */
3065 if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3067 double best_error = 0.01;
3069 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3070 st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3071 st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3073 /* round guessed framerate to a "standard" framerate if it's
3074 * within 1% of the original estimate*/
3075 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3076 AVRational std_fps = { get_std_framerate(j), 12*1001 };
3077 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3079 if (error < best_error) {
3081 best_fps = std_fps.num;
3085 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3086 best_fps, 12*1001, INT_MAX);
3089 // the check for tb_unreliable() is not completely correct, since this is not about handling
3090 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
3091 // ipmovie.c produces.
3092 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)
3093 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);
3094 if (st->info->duration_count>1 && !st->r_frame_rate.num
3095 && tb_unreliable(st->codec)) {
3097 double best_error= 0.01;
3099 for (j=0; j<MAX_STD_TIMEBASES; j++) {
3102 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
3104 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
3107 int n= st->info->duration_count;
3108 double a= st->info->duration_error[k][0][j] / n;
3109 double error= st->info->duration_error[k][1][j]/n - a*a;
3111 if(error < best_error && best_error> 0.000000001){
3113 num = get_std_framerate(j);
3116 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
3119 // do not increase frame rate by more than 1 % in order to match a standard rate.
3120 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
3121 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
3124 if (!st->r_frame_rate.num){
3125 if( st->codec->time_base.den * (int64_t)st->time_base.num
3126 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3127 st->r_frame_rate.num = st->codec->time_base.den;
3128 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3130 st->r_frame_rate.num = st->time_base.den;
3131 st->r_frame_rate.den = st->time_base.num;
3134 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3135 if(!st->codec->bits_per_coded_sample)
3136 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3137 // set stream disposition based on audio service type
3138 switch (st->codec->audio_service_type) {
3139 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3140 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
3141 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3142 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
3143 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3144 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3145 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3146 st->disposition = AV_DISPOSITION_COMMENT; break;
3147 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3148 st->disposition = AV_DISPOSITION_KARAOKE; break;
3154 estimate_timings(ic, old_offset);
3156 compute_chapters_end(ic);
3158 find_stream_info_err:
3159 for (i=0; i < ic->nb_streams; i++) {
3160 st = ic->streams[i];
3161 if (ic->streams[i]->codec)
3162 ic->streams[i]->codec->thread_count = 0;
3164 av_freep(&st->info->duration_error);
3165 av_freep(&ic->streams[i]->info);
3168 av_log(ic, AV_LOG_DEBUG, "File position after avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb));
3172 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3176 for (i = 0; i < ic->nb_programs; i++) {
3177 if (ic->programs[i] == last) {
3181 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3182 if (ic->programs[i]->stream_index[j] == s)
3183 return ic->programs[i];
3189 int av_find_best_stream(AVFormatContext *ic,
3190 enum AVMediaType type,
3191 int wanted_stream_nb,
3193 AVCodec **decoder_ret,
3196 int i, nb_streams = ic->nb_streams;
3197 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3198 unsigned *program = NULL;
3199 AVCodec *decoder = NULL, *best_decoder = NULL;
3201 if (related_stream >= 0 && wanted_stream_nb < 0) {
3202 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3204 program = p->stream_index;
3205 nb_streams = p->nb_stream_indexes;
3208 for (i = 0; i < nb_streams; i++) {
3209 int real_stream_index = program ? program[i] : i;
3210 AVStream *st = ic->streams[real_stream_index];
3211 AVCodecContext *avctx = st->codec;
3212 if (avctx->codec_type != type)
3214 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3216 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3219 decoder = avcodec_find_decoder(st->codec->codec_id);
3222 ret = AVERROR_DECODER_NOT_FOUND;
3226 count = st->codec_info_nb_frames;
3227 bitrate = avctx->bit_rate;
3228 multiframe = FFMIN(5, count);
3229 if ((best_multiframe > multiframe) ||
3230 (best_multiframe == multiframe && best_bitrate > bitrate) ||
3231 (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3234 best_bitrate = bitrate;
3235 best_multiframe = multiframe;
3236 ret = real_stream_index;
3237 best_decoder = decoder;
3238 if (program && i == nb_streams - 1 && ret < 0) {
3240 nb_streams = ic->nb_streams;
3241 i = 0; /* no related stream found, try again with everything */
3245 *decoder_ret = best_decoder;
3249 /*******************************************************/
3251 int av_read_play(AVFormatContext *s)
3253 if (s->iformat->read_play)
3254 return s->iformat->read_play(s);
3256 return avio_pause(s->pb, 0);
3257 return AVERROR(ENOSYS);
3260 int av_read_pause(AVFormatContext *s)
3262 if (s->iformat->read_pause)
3263 return s->iformat->read_pause(s);
3265 return avio_pause(s->pb, 1);
3266 return AVERROR(ENOSYS);
3269 void ff_free_stream(AVFormatContext *s, AVStream *st){
3270 av_assert0(s->nb_streams>0);
3271 av_assert0(s->streams[ s->nb_streams-1 ] == st);
3274 av_parser_close(st->parser);
3276 if (st->attached_pic.data)
3277 av_free_packet(&st->attached_pic);
3278 av_dict_free(&st->metadata);
3279 av_freep(&st->probe_data.buf);
3280 av_freep(&st->index_entries);
3281 av_freep(&st->codec->extradata);
3282 av_freep(&st->codec->subtitle_header);
3283 av_freep(&st->codec);
3284 av_freep(&st->priv_data);
3286 av_freep(&st->info->duration_error);
3287 av_freep(&st->info);
3288 av_freep(&s->streams[ --s->nb_streams ]);
3291 void avformat_free_context(AVFormatContext *s)
3299 if (s->iformat && s->iformat->priv_class && s->priv_data)
3300 av_opt_free(s->priv_data);
3302 for(i=s->nb_streams-1; i>=0; i--) {
3303 ff_free_stream(s, s->streams[i]);
3305 for(i=s->nb_programs-1; i>=0; i--) {
3306 av_dict_free(&s->programs[i]->metadata);
3307 av_freep(&s->programs[i]->stream_index);
3308 av_freep(&s->programs[i]);
3310 av_freep(&s->programs);
3311 av_freep(&s->priv_data);
3312 while(s->nb_chapters--) {
3313 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3314 av_freep(&s->chapters[s->nb_chapters]);
3316 av_freep(&s->chapters);
3317 av_dict_free(&s->metadata);
3318 av_freep(&s->streams);
3322 #if FF_API_CLOSE_INPUT_FILE
3323 void av_close_input_file(AVFormatContext *s)
3325 avformat_close_input(&s);
3329 void avformat_close_input(AVFormatContext **ps)
3331 AVFormatContext *s = *ps;
3332 AVIOContext *pb = s->pb;
3334 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3335 (s->flags & AVFMT_FLAG_CUSTOM_IO))
3338 flush_packet_queue(s);
3341 if (s->iformat->read_close)
3342 s->iformat->read_close(s);
3345 avformat_free_context(s);
3352 #if FF_API_NEW_STREAM
3353 AVStream *av_new_stream(AVFormatContext *s, int id)
3355 AVStream *st = avformat_new_stream(s, NULL);
3362 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3368 if (s->nb_streams >= INT_MAX/sizeof(*streams))
3370 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
3373 s->streams = streams;
3375 st = av_mallocz(sizeof(AVStream));
3378 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3382 st->info->last_dts = AV_NOPTS_VALUE;
3384 st->codec = avcodec_alloc_context3(c);
3386 /* no default bitrate if decoding */
3387 st->codec->bit_rate = 0;
3389 st->index = s->nb_streams;
3390 st->start_time = AV_NOPTS_VALUE;
3391 st->duration = AV_NOPTS_VALUE;
3392 /* we set the current DTS to 0 so that formats without any timestamps
3393 but durations get some timestamps, formats with some unknown
3394 timestamps have their first few packets buffered and the
3395 timestamps corrected before they are returned to the user */
3396 st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3397 st->first_dts = AV_NOPTS_VALUE;
3398 st->probe_packets = MAX_PROBE_PACKETS;
3399 st->pts_wrap_reference = AV_NOPTS_VALUE;
3400 st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3402 /* default pts setting is MPEG-like */
3403 avpriv_set_pts_info(st, 33, 1, 90000);
3404 st->last_IP_pts = AV_NOPTS_VALUE;
3405 for(i=0; i<MAX_REORDER_DELAY+1; i++)
3406 st->pts_buffer[i]= AV_NOPTS_VALUE;
3407 st->reference_dts = AV_NOPTS_VALUE;
3409 st->sample_aspect_ratio = (AVRational){0,1};
3411 #if FF_API_R_FRAME_RATE
3412 st->info->last_dts = AV_NOPTS_VALUE;
3414 st->info->fps_first_dts = AV_NOPTS_VALUE;
3415 st->info->fps_last_dts = AV_NOPTS_VALUE;
3417 s->streams[s->nb_streams++] = st;
3421 AVProgram *av_new_program(AVFormatContext *ac, int id)
3423 AVProgram *program=NULL;
3426 av_dlog(ac, "new_program: id=0x%04x\n", id);
3428 for(i=0; i<ac->nb_programs; i++)
3429 if(ac->programs[i]->id == id)
3430 program = ac->programs[i];
3433 program = av_mallocz(sizeof(AVProgram));
3436 dynarray_add(&ac->programs, &ac->nb_programs, program);
3437 program->discard = AVDISCARD_NONE;
3440 program->pts_wrap_reference = AV_NOPTS_VALUE;
3441 program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3443 program->start_time =
3444 program->end_time = AV_NOPTS_VALUE;
3449 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3451 AVChapter *chapter = NULL;
3454 for(i=0; i<s->nb_chapters; i++)
3455 if(s->chapters[i]->id == id)
3456 chapter = s->chapters[i];
3459 chapter= av_mallocz(sizeof(AVChapter));
3462 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3464 av_dict_set(&chapter->metadata, "title", title, 0);
3466 chapter->time_base= time_base;
3467 chapter->start = start;
3473 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3476 AVProgram *program=NULL;
3479 if (idx >= ac->nb_streams) {
3480 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3484 for(i=0; i<ac->nb_programs; i++){
3485 if(ac->programs[i]->id != progid)
3487 program = ac->programs[i];
3488 for(j=0; j<program->nb_stream_indexes; j++)
3489 if(program->stream_index[j] == idx)
3492 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3495 program->stream_index = tmp;
3496 program->stream_index[program->nb_stream_indexes++] = idx;
3501 static void print_fps(double d, const char *postfix){
3502 uint64_t v= lrintf(d*100);
3503 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3504 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3505 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3508 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3510 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3511 AVDictionaryEntry *tag=NULL;
3513 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3514 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3515 if(strcmp("language", tag->key)){
3516 const char *p = tag->value;
3517 av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
3520 size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3521 av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3522 av_log(ctx, AV_LOG_INFO, "%s", tmp);
3524 if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3525 if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
3528 av_log(ctx, AV_LOG_INFO, "\n");
3534 /* "user interface" functions */
3535 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3538 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3539 AVStream *st = ic->streams[i];
3540 int g = av_gcd(st->time_base.num, st->time_base.den);
3541 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3542 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3543 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3544 /* the pid is an important information, so we display it */
3545 /* XXX: add a generic system */
3546 if (flags & AVFMT_SHOW_IDS)
3547 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3549 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3550 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3551 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3552 if (st->sample_aspect_ratio.num && // default
3553 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3554 AVRational display_aspect_ratio;
3555 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3556 st->codec->width*st->sample_aspect_ratio.num,
3557 st->codec->height*st->sample_aspect_ratio.den,
3559 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3560 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3561 display_aspect_ratio.num, display_aspect_ratio.den);
3563 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3564 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3565 print_fps(av_q2d(st->avg_frame_rate), "fps");
3566 #if FF_API_R_FRAME_RATE
3567 if(st->r_frame_rate.den && st->r_frame_rate.num)
3568 print_fps(av_q2d(st->r_frame_rate), "tbr");
3570 if(st->time_base.den && st->time_base.num)
3571 print_fps(1/av_q2d(st->time_base), "tbn");
3572 if(st->codec->time_base.den && st->codec->time_base.num)
3573 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3575 if (st->disposition & AV_DISPOSITION_DEFAULT)
3576 av_log(NULL, AV_LOG_INFO, " (default)");
3577 if (st->disposition & AV_DISPOSITION_DUB)
3578 av_log(NULL, AV_LOG_INFO, " (dub)");
3579 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3580 av_log(NULL, AV_LOG_INFO, " (original)");
3581 if (st->disposition & AV_DISPOSITION_COMMENT)
3582 av_log(NULL, AV_LOG_INFO, " (comment)");
3583 if (st->disposition & AV_DISPOSITION_LYRICS)
3584 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3585 if (st->disposition & AV_DISPOSITION_KARAOKE)
3586 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3587 if (st->disposition & AV_DISPOSITION_FORCED)
3588 av_log(NULL, AV_LOG_INFO, " (forced)");
3589 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3590 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3591 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3592 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3593 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3594 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3595 av_log(NULL, AV_LOG_INFO, "\n");
3596 dump_metadata(NULL, st->metadata, " ");
3599 void av_dump_format(AVFormatContext *ic,
3605 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3606 if (ic->nb_streams && !printed)
3609 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3610 is_output ? "Output" : "Input",
3612 is_output ? ic->oformat->name : ic->iformat->name,
3613 is_output ? "to" : "from", url);
3614 dump_metadata(NULL, ic->metadata, " ");
3616 av_log(NULL, AV_LOG_INFO, " Duration: ");
3617 if (ic->duration != AV_NOPTS_VALUE) {
3618 int hours, mins, secs, us;
3619 int64_t duration = ic->duration + 5000;
3620 secs = duration / AV_TIME_BASE;
3621 us = duration % AV_TIME_BASE;
3626 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3627 (100 * us) / AV_TIME_BASE);
3629 av_log(NULL, AV_LOG_INFO, "N/A");
3631 if (ic->start_time != AV_NOPTS_VALUE) {
3633 av_log(NULL, AV_LOG_INFO, ", start: ");
3634 secs = ic->start_time / AV_TIME_BASE;
3635 us = abs(ic->start_time % AV_TIME_BASE);
3636 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3637 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3639 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3641 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3643 av_log(NULL, AV_LOG_INFO, "N/A");
3645 av_log(NULL, AV_LOG_INFO, "\n");
3647 for (i = 0; i < ic->nb_chapters; i++) {
3648 AVChapter *ch = ic->chapters[i];
3649 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3650 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3651 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3653 dump_metadata(NULL, ch->metadata, " ");
3655 if(ic->nb_programs) {
3656 int j, k, total = 0;
3657 for(j=0; j<ic->nb_programs; j++) {
3658 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3660 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3661 name ? name->value : "");
3662 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3663 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3664 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3665 printed[ic->programs[j]->stream_index[k]] = 1;
3667 total += ic->programs[j]->nb_stream_indexes;
3669 if (total < ic->nb_streams)
3670 av_log(NULL, AV_LOG_INFO, " No Program\n");
3672 for(i=0;i<ic->nb_streams;i++)
3674 dump_stream_format(ic, i, index, is_output);
3679 uint64_t ff_ntp_time(void)
3681 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3684 int av_get_frame_filename(char *buf, int buf_size,
3685 const char *path, int number)
3688 char *q, buf1[20], c;
3689 int nd, len, percentd_found;
3701 while (av_isdigit(*p)) {
3702 nd = nd * 10 + *p++ - '0';
3705 } while (av_isdigit(c));
3714 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3716 if ((q - buf + len) > buf_size - 1)
3718 memcpy(q, buf1, len);
3726 if ((q - buf) < buf_size - 1)
3730 if (!percentd_found)
3739 static void hex_dump_internal(void *avcl, FILE *f, int level,
3740 const uint8_t *buf, int size)
3743 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3745 for(i=0;i<size;i+=16) {
3752 PRINT(" %02x", buf[i+j]);
3757 for(j=0;j<len;j++) {
3759 if (c < ' ' || c > '~')
3768 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3770 hex_dump_internal(NULL, f, 0, buf, size);
3773 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3775 hex_dump_internal(avcl, NULL, level, buf, size);
3778 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3780 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3781 PRINT("stream #%d:\n", pkt->stream_index);
3782 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3783 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3784 /* DTS is _always_ valid after av_read_frame() */
3786 if (pkt->dts == AV_NOPTS_VALUE)
3789 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3790 /* PTS may not be known if B-frames are present. */
3792 if (pkt->pts == AV_NOPTS_VALUE)
3795 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3797 PRINT(" size=%d\n", pkt->size);
3800 av_hex_dump(f, pkt->data, pkt->size);
3804 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3806 AVRational tb = { 1, AV_TIME_BASE };
3807 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3811 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3813 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3817 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3819 AVRational tb = { 1, AV_TIME_BASE };
3820 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3824 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3827 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3830 void av_url_split(char *proto, int proto_size,
3831 char *authorization, int authorization_size,
3832 char *hostname, int hostname_size,
3834 char *path, int path_size,
3837 const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3839 if (port_ptr) *port_ptr = -1;
3840 if (proto_size > 0) proto[0] = 0;
3841 if (authorization_size > 0) authorization[0] = 0;
3842 if (hostname_size > 0) hostname[0] = 0;
3843 if (path_size > 0) path[0] = 0;
3845 /* parse protocol */
3846 if ((p = strchr(url, ':'))) {
3847 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3852 /* no protocol means plain filename */
3853 av_strlcpy(path, url, path_size);
3857 /* separate path from hostname */
3858 ls = strchr(p, '/');
3859 ls2 = strchr(p, '?');
3863 ls = FFMIN(ls, ls2);
3865 av_strlcpy(path, ls, path_size);
3867 ls = &p[strlen(p)]; // XXX
3869 /* the rest is hostname, use that to parse auth/port */
3871 /* authorization (user[:pass]@hostname) */
3873 while ((at = strchr(p, '@')) && at < ls) {
3874 av_strlcpy(authorization, at2,
3875 FFMIN(authorization_size, at + 1 - at2));
3876 p = at + 1; /* skip '@' */
3879 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3881 av_strlcpy(hostname, p + 1,
3882 FFMIN(hostname_size, brk - p));
3883 if (brk[1] == ':' && port_ptr)
3884 *port_ptr = atoi(brk + 2);
3885 } else if ((col = strchr(p, ':')) && col < ls) {
3886 av_strlcpy(hostname, p,
3887 FFMIN(col + 1 - p, hostname_size));
3888 if (port_ptr) *port_ptr = atoi(col + 1);
3890 av_strlcpy(hostname, p,
3891 FFMIN(ls + 1 - p, hostname_size));
3895 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3898 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3901 'C', 'D', 'E', 'F' };
3902 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3905 'c', 'd', 'e', 'f' };
3906 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3908 for(i = 0; i < s; i++) {
3909 buff[i * 2] = hex_table[src[i] >> 4];
3910 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3916 int ff_hex_to_data(uint8_t *data, const char *p)
3923 p += strspn(p, SPACE_CHARS);
3926 c = av_toupper((unsigned char) *p++);
3927 if (c >= '0' && c <= '9')
3929 else if (c >= 'A' && c <= 'F')
3944 #if FF_API_SET_PTS_INFO
3945 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3946 unsigned int pts_num, unsigned int pts_den)
3948 avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3952 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3953 unsigned int pts_num, unsigned int pts_den)
3956 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3957 if(new_tb.num != pts_num)
3958 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3960 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3962 if(new_tb.num <= 0 || new_tb.den <= 0) {
3963 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
3966 s->time_base = new_tb;
3967 av_codec_set_pkt_timebase(s->codec, new_tb);
3968 s->pts_wrap_bits = pts_wrap_bits;
3971 int ff_url_join(char *str, int size, const char *proto,
3972 const char *authorization, const char *hostname,
3973 int port, const char *fmt, ...)
3976 struct addrinfo hints = { 0 }, *ai;
3981 av_strlcatf(str, size, "%s://", proto);
3982 if (authorization && authorization[0])
3983 av_strlcatf(str, size, "%s@", authorization);
3984 #if CONFIG_NETWORK && defined(AF_INET6)
3985 /* Determine if hostname is a numerical IPv6 address,
3986 * properly escape it within [] in that case. */
3987 hints.ai_flags = AI_NUMERICHOST;
3988 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3989 if (ai->ai_family == AF_INET6) {
3990 av_strlcat(str, "[", size);
3991 av_strlcat(str, hostname, size);
3992 av_strlcat(str, "]", size);
3994 av_strlcat(str, hostname, size);
3999 /* Not an IPv6 address, just output the plain string. */
4000 av_strlcat(str, hostname, size);
4003 av_strlcatf(str, size, ":%d", port);
4006 int len = strlen(str);
4009 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4015 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4016 AVFormatContext *src)
4021 local_pkt.stream_index = dst_stream;
4022 if (pkt->pts != AV_NOPTS_VALUE)
4023 local_pkt.pts = av_rescale_q(pkt->pts,
4024 src->streams[pkt->stream_index]->time_base,
4025 dst->streams[dst_stream]->time_base);
4026 if (pkt->dts != AV_NOPTS_VALUE)
4027 local_pkt.dts = av_rescale_q(pkt->dts,
4028 src->streams[pkt->stream_index]->time_base,
4029 dst->streams[dst_stream]->time_base);
4031 local_pkt.duration = av_rescale_q(pkt->duration,
4032 src->streams[pkt->stream_index]->time_base,
4033 dst->streams[dst_stream]->time_base);
4034 return av_write_frame(dst, &local_pkt);
4037 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4040 const char *ptr = str;
4042 /* Parse key=value pairs. */
4045 char *dest = NULL, *dest_end;
4046 int key_len, dest_len = 0;
4048 /* Skip whitespace and potential commas. */
4049 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
4056 if (!(ptr = strchr(key, '=')))
4059 key_len = ptr - key;
4061 callback_get_buf(context, key, key_len, &dest, &dest_len);
4062 dest_end = dest + dest_len - 1;
4066 while (*ptr && *ptr != '\"') {
4070 if (dest && dest < dest_end)
4074 if (dest && dest < dest_end)
4082 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4083 if (dest && dest < dest_end)
4091 int ff_find_stream_index(AVFormatContext *s, int id)
4094 for (i = 0; i < s->nb_streams; i++) {
4095 if (s->streams[i]->id == id)
4101 void ff_make_absolute_url(char *buf, int size, const char *base,
4104 char *sep, *path_query;
4105 /* Absolute path, relative to the current server */
4106 if (base && strstr(base, "://") && rel[0] == '/') {
4108 av_strlcpy(buf, base, size);
4109 sep = strstr(buf, "://");
4111 /* Take scheme from base url */
4112 if (rel[1] == '/') {
4115 /* Take scheme and host from base url */
4117 sep = strchr(sep, '/');
4122 av_strlcat(buf, rel, size);
4125 /* If rel actually is an absolute url, just copy it */
4126 if (!base || strstr(rel, "://") || rel[0] == '/') {
4127 av_strlcpy(buf, rel, size);
4131 av_strlcpy(buf, base, size);
4133 /* Strip off any query string from base */
4134 path_query = strchr(buf, '?');
4135 if (path_query != NULL)
4138 /* Is relative path just a new query part? */
4139 if (rel[0] == '?') {
4140 av_strlcat(buf, rel, size);
4144 /* Remove the file name from the base url */
4145 sep = strrchr(buf, '/');
4150 while (av_strstart(rel, "../", NULL) && sep) {
4151 /* Remove the path delimiter at the end */
4153 sep = strrchr(buf, '/');
4154 /* If the next directory name to pop off is "..", break here */
4155 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4156 /* Readd the slash we just removed */
4157 av_strlcat(buf, "/", size);
4160 /* Cut off the directory name */
4167 av_strlcat(buf, rel, size);
4170 int64_t ff_iso8601_to_unix_time(const char *datestr)
4172 struct tm time1 = {0}, time2 = {0};
4174 ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4175 ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4177 return av_timegm(&time2);
4179 return av_timegm(&time1);
4182 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4185 if (ofmt->query_codec)
4186 return ofmt->query_codec(codec_id, std_compliance);
4187 else if (ofmt->codec_tag)
4188 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4189 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4190 codec_id == ofmt->subtitle_codec)
4193 return AVERROR_PATCHWELCOME;
4196 int avformat_network_init(void)
4200 ff_network_inited_globally = 1;
4201 if ((ret = ff_network_init()) < 0)
4208 int avformat_network_deinit(void)
4217 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4218 uint64_t channel_layout, int32_t sample_rate,
4219 int32_t width, int32_t height)
4225 return AVERROR(EINVAL);
4228 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4230 if (channel_layout) {
4232 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4236 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4238 if (width || height) {
4240 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4242 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4244 return AVERROR(ENOMEM);
4245 bytestream_put_le32(&data, flags);
4247 bytestream_put_le32(&data, channels);
4249 bytestream_put_le64(&data, channel_layout);
4251 bytestream_put_le32(&data, sample_rate);
4252 if (width || height) {
4253 bytestream_put_le32(&data, width);
4254 bytestream_put_le32(&data, height);
4259 const struct AVCodecTag *avformat_get_riff_video_tags(void)
4261 return ff_codec_bmp_tags;
4263 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
4265 return ff_codec_wav_tags;
4268 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4270 AVRational undef = {0, 1};
4271 AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4272 AVRational codec_sample_aspect_ratio = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4273 AVRational frame_sample_aspect_ratio = frame ? frame->sample_aspect_ratio : codec_sample_aspect_ratio;
4275 av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4276 stream_sample_aspect_ratio.num, stream_sample_aspect_ratio.den, INT_MAX);
4277 if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4278 stream_sample_aspect_ratio = undef;
4280 av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4281 frame_sample_aspect_ratio.num, frame_sample_aspect_ratio.den, INT_MAX);
4282 if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4283 frame_sample_aspect_ratio = undef;
4285 if (stream_sample_aspect_ratio.num)
4286 return stream_sample_aspect_ratio;
4288 return frame_sample_aspect_ratio;
4291 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4293 AVRational fr = st->r_frame_rate;
4295 if (st->codec->ticks_per_frame > 1) {
4296 AVRational codec_fr = av_inv_q(st->codec->time_base);
4297 AVRational avg_fr = st->avg_frame_rate;
4298 codec_fr.den *= st->codec->ticks_per_frame;
4299 if ( codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4300 && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4307 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4310 if (*spec <= '9' && *spec >= '0') /* opt:index */
4311 return strtol(spec, NULL, 0) == st->index;
4312 else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4313 *spec == 't') { /* opt:[vasdt] */
4314 enum AVMediaType type;
4317 case 'v': type = AVMEDIA_TYPE_VIDEO; break;
4318 case 'a': type = AVMEDIA_TYPE_AUDIO; break;
4319 case 's': type = AVMEDIA_TYPE_SUBTITLE; break;
4320 case 'd': type = AVMEDIA_TYPE_DATA; break;
4321 case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4322 default: av_assert0(0);
4324 if (type != st->codec->codec_type)
4326 if (*spec++ == ':') { /* possibly followed by :index */
4327 int i, index = strtol(spec, NULL, 0);
4328 for (i = 0; i < s->nb_streams; i++)
4329 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4330 return i == st->index;
4334 } else if (*spec == 'p' && *(spec + 1) == ':') {
4338 prog_id = strtol(spec, &endptr, 0);
4339 for (i = 0; i < s->nb_programs; i++) {
4340 if (s->programs[i]->id != prog_id)
4343 if (*endptr++ == ':') {
4344 int stream_idx = strtol(endptr, NULL, 0);
4345 return stream_idx >= 0 &&
4346 stream_idx < s->programs[i]->nb_stream_indexes &&
4347 st->index == s->programs[i]->stream_index[stream_idx];
4350 for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4351 if (st->index == s->programs[i]->stream_index[j])
4355 } else if (*spec == '#') {
4358 sid = strtol(spec + 1, &endptr, 0);
4360 return st->id == sid;
4361 } else if (!*spec) /* empty specifier, matches everything */
4364 av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4365 return AVERROR(EINVAL);
4368 void ff_generate_avci_extradata(AVStream *st)
4370 static const uint8_t avci100_1080p_extradata[] = {
4372 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4373 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4374 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4375 0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4376 0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4377 0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4378 0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4379 0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4380 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4382 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4385 static const uint8_t avci100_1080i_extradata[] = {
4387 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4388 0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4389 0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4390 0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4391 0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4392 0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4393 0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4394 0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4395 0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4396 0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4397 0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4399 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4402 static const uint8_t avci50_1080i_extradata[] = {
4404 0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4405 0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4406 0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4407 0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4408 0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4409 0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4410 0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4411 0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4412 0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4413 0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4414 0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4416 0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4419 static const uint8_t avci100_720p_extradata[] = {
4421 0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4422 0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4423 0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4424 0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4425 0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4426 0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4427 0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4428 0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4429 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4430 0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4432 0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4436 const uint8_t *data = 0;
4437 if (st->codec->width == 1920) {
4438 if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4439 data = avci100_1080p_extradata;
4440 size = sizeof(avci100_1080p_extradata);
4442 data = avci100_1080i_extradata;
4443 size = sizeof(avci100_1080i_extradata);
4445 } else if (st->codec->width == 1440) {
4446 data = avci50_1080i_extradata;
4447 size = sizeof(avci50_1080i_extradata);
4448 } else if (st->codec->width == 1280) {
4449 data = avci100_720p_extradata;
4450 size = sizeof(avci100_720p_extradata);
4454 av_freep(&st->codec->extradata);
4455 st->codec->extradata_size = 0;
4456 st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
4457 if (!st->codec->extradata)
4459 memcpy(st->codec->extradata, data, size);
4460 st->codec->extradata_size = size;
4463 static int match_host_pattern(const char *pattern, const char *hostname)
4466 if (!strcmp(pattern, "*"))
4468 // Skip a possible *. at the start of the pattern
4469 if (pattern[0] == '*')
4471 if (pattern[0] == '.')
4473 len_p = strlen(pattern);
4474 len_h = strlen(hostname);
4477 // Simply check if the end of hostname is equal to 'pattern'
4478 if (!strcmp(pattern, &hostname[len_h - len_p])) {
4480 return 1; // Exact match
4481 if (hostname[len_h - len_p - 1] == '.')
4482 return 1; // The matched substring is a domain and not just a substring of a domain
4487 int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
4495 buf = av_strdup(no_proxy);
4500 char *sep, *next = NULL;
4501 start += strspn(start, " ,");
4502 sep = start + strcspn(start, " ,");
4507 if (match_host_pattern(start, hostname)) {