2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "avio_internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/bytestream.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/pixdesc.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/parseutils.h"
37 #include "libavutil/time.h"
39 #include "audiointerleave.h"
51 * various utility functions for use within Libav
54 unsigned avformat_version(void)
56 return LIBAVFORMAT_VERSION_INT;
59 const char *avformat_configuration(void)
61 return LIBAV_CONFIGURATION;
64 const char *avformat_license(void)
66 #define LICENSE_PREFIX "libavformat license: "
67 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
70 /* an arbitrarily chosen "sane" max packet size -- 50M */
71 #define SANE_CHUNK_SIZE (50000000)
74 * Read the data in sane-sized chunks and append to pkt.
75 * Return the number of bytes read or an error.
77 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
79 int64_t chunk_size = size;
80 int orig_pos = pkt->pos; // av_grow_packet might reset pos
81 int orig_size = pkt->size;
85 int prev_size = pkt->size;
89 * When the caller requests a lot of data, limit it to the amount left
90 * in file or SANE_CHUNK_SIZE when it is not known
92 if (size > SANE_CHUNK_SIZE) {
93 int64_t filesize = avio_size(s) - avio_tell(s);
94 chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
96 read_size = FFMIN(size, chunk_size);
98 ret = av_grow_packet(pkt, read_size);
102 ret = avio_read(s, pkt->data + prev_size, read_size);
103 if (ret != read_size) {
104 av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
114 return pkt->size > orig_size ? pkt->size - orig_size : ret;
117 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
122 pkt->pos = avio_tell(s);
124 return append_packet_chunked(s, pkt, size);
127 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
130 return av_get_packet(s, pkt, size);
131 return append_packet_chunked(s, pkt, size);
135 int av_filename_number_test(const char *filename)
138 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
141 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
143 AVProbeData lpd = *pd;
144 AVInputFormat *fmt1 = NULL, *fmt;
147 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
148 int id3len = ff_id3v2_tag_len(lpd.buf);
149 if (lpd.buf_size > id3len + 16) {
151 lpd.buf_size -= id3len;
157 while ((fmt1 = av_iformat_next(fmt1))) {
158 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
161 if (fmt1->read_probe) {
162 score = fmt1->read_probe(&lpd);
163 } else if (fmt1->extensions) {
164 if (av_match_ext(lpd.filename, fmt1->extensions)) {
165 score = AVPROBE_SCORE_EXTENSION;
168 if (score > *score_max) {
171 }else if (score == *score_max)
175 /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
176 if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
177 while ((fmt = av_iformat_next(fmt)))
178 if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
179 *score_max = AVPROBE_SCORE_EXTENSION / 2;
184 if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
185 while ((fmt = av_iformat_next(fmt)))
186 if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
187 *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
195 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
197 return av_probe_input_format2(pd, is_opened, &score);
200 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
202 static const struct {
203 const char *name; enum AVCodecID id; enum AVMediaType type;
205 { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
206 { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
207 { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
208 { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
209 { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
210 { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
211 { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
212 { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
215 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
219 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
220 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
221 for (i = 0; fmt_id_type[i].name; i++) {
222 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
223 st->codec->codec_id = fmt_id_type[i].id;
224 st->codec->codec_type = fmt_id_type[i].type;
232 /************************************************************/
233 /* input media file */
235 /** size of probe buffer, for guessing file type from file contents */
236 #define PROBE_BUF_MIN 2048
237 #define PROBE_BUF_MAX (1<<20)
239 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
240 const char *filename, void *logctx,
241 unsigned int offset, unsigned int max_probe_size)
243 AVProbeData pd = { filename ? filename : "", NULL, -offset };
244 unsigned char *buf = NULL;
245 int ret = 0, probe_size;
247 if (!max_probe_size) {
248 max_probe_size = PROBE_BUF_MAX;
249 } else if (max_probe_size > PROBE_BUF_MAX) {
250 max_probe_size = PROBE_BUF_MAX;
251 } else if (max_probe_size < PROBE_BUF_MIN) {
252 return AVERROR(EINVAL);
255 if (offset >= max_probe_size) {
256 return AVERROR(EINVAL);
259 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
260 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
261 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
262 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
264 if (probe_size < offset) {
268 /* read probe data */
269 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
270 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
271 /* fail if error was not end of file, otherwise, lower score */
272 if (ret != AVERROR_EOF) {
277 ret = 0; /* error was end of file, nothing read */
280 pd.buf = &buf[offset];
282 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
284 /* guess file format */
285 *fmt = av_probe_input_format2(&pd, 1, &score);
287 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
288 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
290 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
296 return AVERROR_INVALIDDATA;
299 /* rewind. reuse probe buffer to avoid seeking */
300 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
306 /* open input file and probe the format if necessary */
307 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
310 AVProbeData pd = {filename, NULL, 0};
313 s->flags |= AVFMT_FLAG_CUSTOM_IO;
315 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
316 else if (s->iformat->flags & AVFMT_NOFILE)
317 return AVERROR(EINVAL);
321 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
322 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
325 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
326 &s->interrupt_callback, options)) < 0)
330 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
333 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
334 AVPacketList **plast_pktl){
335 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
340 (*plast_pktl)->next = pktl;
342 *packet_buffer = pktl;
344 /* add the packet in the buffered packet list */
350 static int queue_attached_pictures(AVFormatContext *s)
353 for (i = 0; i < s->nb_streams; i++)
354 if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
355 s->streams[i]->discard < AVDISCARD_ALL) {
356 AVPacket copy = s->streams[i]->attached_pic;
357 copy.buf = av_buffer_ref(copy.buf);
359 return AVERROR(ENOMEM);
361 add_to_pktbuf(&s->raw_packet_buffer, ©, &s->raw_packet_buffer_end);
366 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
368 AVFormatContext *s = *ps;
370 AVDictionary *tmp = NULL;
371 ID3v2ExtraMeta *id3v2_extra_meta = NULL;
373 if (!s && !(s = avformat_alloc_context()))
374 return AVERROR(ENOMEM);
379 av_dict_copy(&tmp, *options, 0);
381 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
384 if ((ret = init_input(s, filename, &tmp)) < 0)
387 /* check filename in case an image number is expected */
388 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
389 if (!av_filename_number_test(filename)) {
390 ret = AVERROR(EINVAL);
395 s->duration = s->start_time = AV_NOPTS_VALUE;
396 av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
398 /* allocate private data */
399 if (s->iformat->priv_data_size > 0) {
400 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
401 ret = AVERROR(ENOMEM);
404 if (s->iformat->priv_class) {
405 *(const AVClass**)s->priv_data = s->iformat->priv_class;
406 av_opt_set_defaults(s->priv_data);
407 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
412 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
414 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
416 if (s->iformat->read_header)
417 if ((ret = s->iformat->read_header(s)) < 0)
420 if (id3v2_extra_meta &&
421 (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
423 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
425 if ((ret = queue_attached_pictures(s)) < 0)
428 if (s->pb && !s->data_offset)
429 s->data_offset = avio_tell(s->pb);
431 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
434 av_dict_free(options);
441 ff_id3v2_free_extra_meta(&id3v2_extra_meta);
443 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
445 avformat_free_context(s);
450 /*******************************************************/
452 static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
454 if(st->codec->codec_id == AV_CODEC_ID_PROBE){
455 AVProbeData *pd = &st->probe_data;
456 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
460 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
461 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
462 pd->buf_size += pkt->size;
463 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
465 st->probe_packets = 0;
467 av_log(s, AV_LOG_ERROR, "nothing to probe for stream %d\n",
473 if (!st->probe_packets ||
474 av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
475 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
476 if(st->codec->codec_id != AV_CODEC_ID_PROBE){
479 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
485 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
491 AVPacketList *pktl = s->raw_packet_buffer;
495 st = s->streams[pkt->stream_index];
496 if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
497 s->raw_packet_buffer_remaining_size < pkt->size) {
499 if (st->probe_packets) {
500 probe_codec(s, st, NULL);
502 pd = &st->probe_data;
505 s->raw_packet_buffer = pktl->next;
506 s->raw_packet_buffer_remaining_size += pkt->size;
515 ret= s->iformat->read_packet(s, pkt);
517 if (!pktl || ret == AVERROR(EAGAIN))
519 for (i = 0; i < s->nb_streams; i++) {
521 if (st->probe_packets) {
522 probe_codec(s, st, NULL);
528 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
529 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
530 av_log(s, AV_LOG_WARNING,
531 "Dropped corrupted packet (stream = %d)\n",
537 st= s->streams[pkt->stream_index];
539 switch(st->codec->codec_type){
540 case AVMEDIA_TYPE_VIDEO:
541 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
543 case AVMEDIA_TYPE_AUDIO:
544 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
546 case AVMEDIA_TYPE_SUBTITLE:
547 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
551 if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
555 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
556 s->raw_packet_buffer_remaining_size -= pkt->size;
558 probe_codec(s, st, pkt);
562 /**********************************************************/
565 * Get the number of samples of an audio frame. Return -1 on error.
567 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
571 /* give frame_size priority if demuxing */
572 if (!mux && enc->frame_size > 1)
573 return enc->frame_size;
575 if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
578 /* Fall back on using frame_size if muxing. */
579 if (enc->frame_size > 1)
580 return enc->frame_size;
587 * Return the frame duration in seconds. Return 0 if not available.
589 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
590 AVCodecParserContext *pc, AVPacket *pkt)
596 switch(st->codec->codec_type) {
597 case AVMEDIA_TYPE_VIDEO:
598 if (st->avg_frame_rate.num) {
599 *pnum = st->avg_frame_rate.den;
600 *pden = st->avg_frame_rate.num;
601 } else if(st->time_base.num*1000LL > st->time_base.den) {
602 *pnum = st->time_base.num;
603 *pden = st->time_base.den;
604 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
605 *pnum = st->codec->time_base.num;
606 *pden = st->codec->time_base.den;
607 if (pc && pc->repeat_pict) {
608 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
609 *pden /= 1 + pc->repeat_pict;
611 *pnum *= 1 + pc->repeat_pict;
613 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
614 //Thus if we have no parser in such case leave duration undefined.
615 if(st->codec->ticks_per_frame>1 && !pc){
620 case AVMEDIA_TYPE_AUDIO:
621 frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
622 if (frame_size <= 0 || st->codec->sample_rate <= 0)
625 *pden = st->codec->sample_rate;
632 static int is_intra_only(enum AVCodecID id)
634 const AVCodecDescriptor *d = avcodec_descriptor_get(id);
637 if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
642 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
643 int64_t dts, int64_t pts)
645 AVStream *st= s->streams[stream_index];
646 AVPacketList *pktl= s->packet_buffer;
648 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
651 st->first_dts= dts - st->cur_dts;
654 for(; pktl; pktl= pktl->next){
655 if(pktl->pkt.stream_index != stream_index)
657 //FIXME think more about this check
658 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
659 pktl->pkt.pts += st->first_dts;
661 if(pktl->pkt.dts != AV_NOPTS_VALUE)
662 pktl->pkt.dts += st->first_dts;
664 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
665 st->start_time= pktl->pkt.pts;
667 if (st->start_time == AV_NOPTS_VALUE)
668 st->start_time = pts;
671 static void update_initial_durations(AVFormatContext *s, AVStream *st,
672 int stream_index, int duration)
674 AVPacketList *pktl= s->packet_buffer;
677 if(st->first_dts != AV_NOPTS_VALUE){
678 cur_dts= st->first_dts;
679 for(; pktl; pktl= pktl->next){
680 if(pktl->pkt.stream_index == stream_index){
681 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
686 pktl= s->packet_buffer;
687 st->first_dts = cur_dts;
688 }else if(st->cur_dts)
691 for(; pktl; pktl= pktl->next){
692 if(pktl->pkt.stream_index != stream_index)
694 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
695 && !pktl->pkt.duration){
696 pktl->pkt.dts= cur_dts;
697 if(!st->codec->has_b_frames)
698 pktl->pkt.pts= cur_dts;
700 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
701 pktl->pkt.duration = duration;
705 if(st->first_dts == AV_NOPTS_VALUE)
706 st->cur_dts= cur_dts;
709 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
710 AVCodecParserContext *pc, AVPacket *pkt)
712 int num, den, presentation_delayed, delay, i;
715 if (s->flags & AVFMT_FLAG_NOFILLIN)
718 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
719 pkt->dts= AV_NOPTS_VALUE;
721 /* do we have a video B-frame ? */
722 delay= st->codec->has_b_frames;
723 presentation_delayed = 0;
725 /* XXX: need has_b_frame, but cannot get it if the codec is
728 pc && pc->pict_type != AV_PICTURE_TYPE_B)
729 presentation_delayed = 1;
731 if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
732 st->pts_wrap_bits < 63 &&
733 pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
734 pkt->dts -= 1LL<<st->pts_wrap_bits;
737 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
738 // we take the conservative approach and discard both
739 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
740 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
741 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
742 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
745 if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
746 ff_compute_frame_duration(&num, &den, st, pc, pkt);
748 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
750 if(pkt->duration != 0 && s->packet_buffer)
751 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
755 /* correct timestamps with byte offset if demuxers only have timestamps
756 on packet boundaries */
757 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
758 /* this will estimate bitrate based on this frame's duration and size */
759 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
760 if(pkt->pts != AV_NOPTS_VALUE)
762 if(pkt->dts != AV_NOPTS_VALUE)
766 if (pc && pc->dts_sync_point >= 0) {
767 // we have synchronization info from the parser
768 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
770 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
771 if (pkt->dts != AV_NOPTS_VALUE) {
772 // got DTS from the stream, update reference timestamp
773 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
774 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
775 } else if (st->reference_dts != AV_NOPTS_VALUE) {
776 // compute DTS based on reference timestamp
777 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
778 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
780 if (pc->dts_sync_point > 0)
781 st->reference_dts = pkt->dts; // new reference
785 /* This may be redundant, but it should not hurt. */
786 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
787 presentation_delayed = 1;
790 "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n",
791 presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
792 pkt->stream_index, pc);
793 /* interpolate PTS and DTS if they are not present */
794 //We skip H264 currently because delay and has_b_frames are not reliably set
795 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
796 if (presentation_delayed) {
797 /* DTS = decompression timestamp */
798 /* PTS = presentation timestamp */
799 if (pkt->dts == AV_NOPTS_VALUE)
800 pkt->dts = st->last_IP_pts;
801 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
802 if (pkt->dts == AV_NOPTS_VALUE)
803 pkt->dts = st->cur_dts;
805 /* this is tricky: the dts must be incremented by the duration
806 of the frame we are displaying, i.e. the last I- or P-frame */
807 if (st->last_IP_duration == 0)
808 st->last_IP_duration = pkt->duration;
809 if(pkt->dts != AV_NOPTS_VALUE)
810 st->cur_dts = pkt->dts + st->last_IP_duration;
811 st->last_IP_duration = pkt->duration;
812 st->last_IP_pts= pkt->pts;
813 /* cannot compute PTS if not present (we can compute it only
814 by knowing the future */
815 } else if (pkt->pts != AV_NOPTS_VALUE ||
816 pkt->dts != AV_NOPTS_VALUE ||
818 st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
819 int duration = pkt->duration;
820 if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
821 ff_compute_frame_duration(&num, &den, st, pc, pkt);
823 duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
824 den * (int64_t)st->time_base.num,
826 if (duration != 0 && s->packet_buffer) {
827 update_initial_durations(s, st, pkt->stream_index,
833 if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
835 /* presentation is not delayed : PTS and DTS are the same */
836 if (pkt->pts == AV_NOPTS_VALUE)
838 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
840 if (pkt->pts == AV_NOPTS_VALUE)
841 pkt->pts = st->cur_dts;
843 if (pkt->pts != AV_NOPTS_VALUE)
844 st->cur_dts = pkt->pts + duration;
849 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
850 st->pts_buffer[0]= pkt->pts;
851 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
852 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
853 if(pkt->dts == AV_NOPTS_VALUE)
854 pkt->dts= st->pts_buffer[0];
855 if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
856 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
858 if(pkt->dts > st->cur_dts)
859 st->cur_dts = pkt->dts;
863 "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
864 presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
867 if (is_intra_only(st->codec->codec_id))
868 pkt->flags |= AV_PKT_FLAG_KEY;
870 pkt->convergence_duration = pc->convergence_duration;
873 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
876 AVPacketList *pktl = *pkt_buf;
877 *pkt_buf = pktl->next;
878 av_free_packet(&pktl->pkt);
885 * Parse a packet, add all split parts to parse_queue
887 * @param pkt packet to parse, NULL when flushing the parser at end of stream
889 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
891 AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
892 AVStream *st = s->streams[stream_index];
893 uint8_t *data = pkt ? pkt->data : NULL;
894 int size = pkt ? pkt->size : 0;
895 int ret = 0, got_output = 0;
898 av_init_packet(&flush_pkt);
903 while (size > 0 || (pkt == &flush_pkt && got_output)) {
906 av_init_packet(&out_pkt);
907 len = av_parser_parse2(st->parser, st->codec,
908 &out_pkt.data, &out_pkt.size, data, size,
909 pkt->pts, pkt->dts, pkt->pos);
911 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
912 /* increment read pointer */
916 got_output = !!out_pkt.size;
921 if (pkt->side_data) {
922 out_pkt.side_data = pkt->side_data;
923 out_pkt.side_data_elems = pkt->side_data_elems;
924 pkt->side_data = NULL;
925 pkt->side_data_elems = 0;
928 /* set the duration */
929 out_pkt.duration = 0;
930 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
931 if (st->codec->sample_rate > 0) {
932 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
933 (AVRational){ 1, st->codec->sample_rate },
937 } else if (st->codec->time_base.num != 0 &&
938 st->codec->time_base.den != 0) {
939 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
940 st->codec->time_base,
945 out_pkt.stream_index = st->index;
946 out_pkt.pts = st->parser->pts;
947 out_pkt.dts = st->parser->dts;
948 out_pkt.pos = st->parser->pos;
950 if (st->parser->key_frame == 1 ||
951 (st->parser->key_frame == -1 &&
952 st->parser->pict_type == AV_PICTURE_TYPE_I))
953 out_pkt.flags |= AV_PKT_FLAG_KEY;
955 compute_pkt_fields(s, st, st->parser, &out_pkt);
957 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
958 out_pkt.flags & AV_PKT_FLAG_KEY) {
959 ff_reduce_index(s, st->index);
960 av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
961 0, 0, AVINDEX_KEYFRAME);
964 if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
965 out_pkt.buf = pkt->buf;
967 #if FF_API_DESTRUCT_PACKET
968 FF_DISABLE_DEPRECATION_WARNINGS
969 out_pkt.destruct = pkt->destruct;
970 pkt->destruct = NULL;
971 FF_ENABLE_DEPRECATION_WARNINGS
974 if ((ret = av_dup_packet(&out_pkt)) < 0)
977 if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
978 av_free_packet(&out_pkt);
979 ret = AVERROR(ENOMEM);
985 /* end of the stream => close and free the parser */
986 if (pkt == &flush_pkt) {
987 av_parser_close(st->parser);
996 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
997 AVPacketList **pkt_buffer_end,
1001 av_assert0(*pkt_buffer);
1004 *pkt_buffer = pktl->next;
1006 *pkt_buffer_end = NULL;
1011 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1013 int ret = 0, i, got_packet = 0;
1015 av_init_packet(pkt);
1017 while (!got_packet && !s->parse_queue) {
1021 /* read next packet */
1022 ret = ff_read_packet(s, &cur_pkt);
1024 if (ret == AVERROR(EAGAIN))
1026 /* flush the parsers */
1027 for(i = 0; i < s->nb_streams; i++) {
1029 if (st->parser && st->need_parsing)
1030 parse_packet(s, NULL, st->index);
1032 /* all remaining packets are now in parse_queue =>
1033 * really terminate parsing */
1037 st = s->streams[cur_pkt.stream_index];
1039 if (cur_pkt.pts != AV_NOPTS_VALUE &&
1040 cur_pkt.dts != AV_NOPTS_VALUE &&
1041 cur_pkt.pts < cur_pkt.dts) {
1042 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1043 cur_pkt.stream_index,
1048 if (s->debug & FF_FDEBUG_TS)
1049 av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1050 cur_pkt.stream_index,
1057 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1058 st->parser = av_parser_init(st->codec->codec_id);
1060 /* no parser available: just output the raw packets */
1061 st->need_parsing = AVSTREAM_PARSE_NONE;
1062 } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1063 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1064 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1065 st->parser->flags |= PARSER_FLAG_ONCE;
1069 if (!st->need_parsing || !st->parser) {
1070 /* no parsing needed: we just output the packet as is */
1072 compute_pkt_fields(s, st, NULL, pkt);
1073 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1074 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1075 ff_reduce_index(s, st->index);
1076 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1079 } else if (st->discard < AVDISCARD_ALL) {
1080 if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1084 av_free_packet(&cur_pkt);
1088 if (!got_packet && s->parse_queue)
1089 ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1091 if(s->debug & FF_FDEBUG_TS)
1092 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1103 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1105 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1109 return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1110 &s->packet_buffer_end,
1112 read_frame_internal(s, pkt);
1116 AVPacketList *pktl = s->packet_buffer;
1119 AVPacket *next_pkt = &pktl->pkt;
1121 if (next_pkt->dts != AV_NOPTS_VALUE) {
1122 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1123 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1124 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1125 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1126 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1127 next_pkt->pts = pktl->pkt.dts;
1131 pktl = s->packet_buffer;
1134 /* read packet from packet buffer, if there is data */
1135 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1136 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1137 return read_from_packet_buffer(&s->packet_buffer,
1138 &s->packet_buffer_end, pkt);
1141 ret = read_frame_internal(s, pkt);
1143 if (pktl && ret != AVERROR(EAGAIN)) {
1150 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1151 &s->packet_buffer_end)) < 0)
1152 return AVERROR(ENOMEM);
1156 /* XXX: suppress the packet queue */
1157 static void flush_packet_queue(AVFormatContext *s)
1159 free_packet_buffer(&s->parse_queue, &s->parse_queue_end);
1160 free_packet_buffer(&s->packet_buffer, &s->packet_buffer_end);
1161 free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1163 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1166 /*******************************************************/
1169 int av_find_default_stream_index(AVFormatContext *s)
1171 int first_audio_index = -1;
1175 if (s->nb_streams <= 0)
1177 for(i = 0; i < s->nb_streams; i++) {
1179 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1180 !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1183 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1184 first_audio_index = i;
1186 return first_audio_index >= 0 ? first_audio_index : 0;
1190 * Flush the frame reader.
1192 void ff_read_frame_flush(AVFormatContext *s)
1197 flush_packet_queue(s);
1199 /* for each stream, reset read state */
1200 for(i = 0; i < s->nb_streams; i++) {
1204 av_parser_close(st->parser);
1207 st->last_IP_pts = AV_NOPTS_VALUE;
1208 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1209 st->reference_dts = AV_NOPTS_VALUE;
1211 st->probe_packets = MAX_PROBE_PACKETS;
1213 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1214 st->pts_buffer[j]= AV_NOPTS_VALUE;
1218 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1222 for(i = 0; i < s->nb_streams; i++) {
1223 AVStream *st = s->streams[i];
1225 st->cur_dts = av_rescale(timestamp,
1226 st->time_base.den * (int64_t)ref_st->time_base.num,
1227 st->time_base.num * (int64_t)ref_st->time_base.den);
1231 void ff_reduce_index(AVFormatContext *s, int stream_index)
1233 AVStream *st= s->streams[stream_index];
1234 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1236 if((unsigned)st->nb_index_entries >= max_entries){
1238 for(i=0; 2*i<st->nb_index_entries; i++)
1239 st->index_entries[i]= st->index_entries[2*i];
1240 st->nb_index_entries= i;
1244 int ff_add_index_entry(AVIndexEntry **index_entries,
1245 int *nb_index_entries,
1246 unsigned int *index_entries_allocated_size,
1247 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1249 AVIndexEntry *entries, *ie;
1252 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1255 entries = av_fast_realloc(*index_entries,
1256 index_entries_allocated_size,
1257 (*nb_index_entries + 1) *
1258 sizeof(AVIndexEntry));
1262 *index_entries= entries;
1264 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1267 index= (*nb_index_entries)++;
1268 ie= &entries[index];
1269 assert(index==0 || ie[-1].timestamp < timestamp);
1271 ie= &entries[index];
1272 if(ie->timestamp != timestamp){
1273 if(ie->timestamp <= timestamp)
1275 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1276 (*nb_index_entries)++;
1277 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1278 distance= ie->min_distance;
1282 ie->timestamp = timestamp;
1283 ie->min_distance= distance;
1290 int av_add_index_entry(AVStream *st,
1291 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1293 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1294 &st->index_entries_allocated_size, pos,
1295 timestamp, size, distance, flags);
1298 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1299 int64_t wanted_timestamp, int flags)
1307 //optimize appending index entries at the end
1308 if(b && entries[b-1].timestamp < wanted_timestamp)
1313 timestamp = entries[m].timestamp;
1314 if(timestamp >= wanted_timestamp)
1316 if(timestamp <= wanted_timestamp)
1319 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1321 if(!(flags & AVSEEK_FLAG_ANY)){
1322 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1323 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1332 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1335 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1336 wanted_timestamp, flags);
1339 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1341 AVInputFormat *avif= s->iformat;
1342 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1343 int64_t ts_min, ts_max, ts;
1348 if (stream_index < 0)
1351 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1354 ts_min= AV_NOPTS_VALUE;
1355 pos_limit= -1; //gcc falsely says it may be uninitialized
1357 st= s->streams[stream_index];
1358 if(st->index_entries){
1361 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()
1362 index= FFMAX(index, 0);
1363 e= &st->index_entries[index];
1365 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1367 ts_min= e->timestamp;
1368 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1374 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1375 assert(index < st->nb_index_entries);
1377 e= &st->index_entries[index];
1378 assert(e->timestamp >= target_ts);
1380 ts_max= e->timestamp;
1381 pos_limit= pos_max - e->min_distance;
1382 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1383 pos_max,pos_limit, ts_max);
1387 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1392 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1395 ff_update_cur_dts(s, st, ts);
1400 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1401 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1402 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1403 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1406 int64_t start_pos, filesize;
1409 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1411 if(ts_min == AV_NOPTS_VALUE){
1412 pos_min = s->data_offset;
1413 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1414 if (ts_min == AV_NOPTS_VALUE)
1418 if(ts_max == AV_NOPTS_VALUE){
1420 filesize = avio_size(s->pb);
1421 pos_max = filesize - 1;
1424 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1426 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1427 if (ts_max == AV_NOPTS_VALUE)
1431 int64_t tmp_pos= pos_max + 1;
1432 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1433 if(tmp_ts == AV_NOPTS_VALUE)
1437 if(tmp_pos >= filesize)
1443 if(ts_min > ts_max){
1445 }else if(ts_min == ts_max){
1450 while (pos_min < pos_limit) {
1451 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1452 pos_min, pos_max, ts_min, ts_max);
1453 assert(pos_limit <= pos_max);
1456 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1457 // interpolate position (better than dichotomy)
1458 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1459 + pos_min - approximate_keyframe_distance;
1460 }else if(no_change==1){
1461 // bisection, if interpolation failed to change min or max pos last time
1462 pos = (pos_min + pos_limit)>>1;
1464 /* linear search if bisection failed, can only happen if there
1465 are very few or no keyframes between min/max */
1470 else if(pos > pos_limit)
1474 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1479 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1480 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1481 pos_limit, start_pos, no_change);
1482 if(ts == AV_NOPTS_VALUE){
1483 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1486 assert(ts != AV_NOPTS_VALUE);
1487 if (target_ts <= ts) {
1488 pos_limit = start_pos - 1;
1492 if (target_ts >= ts) {
1498 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1499 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1501 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1503 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1504 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1505 pos, ts_min, target_ts, ts_max);
1510 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1511 int64_t pos_min, pos_max;
1513 pos_min = s->data_offset;
1514 pos_max = avio_size(s->pb) - 1;
1516 if (pos < pos_min) pos= pos_min;
1517 else if(pos > pos_max) pos= pos_max;
1519 avio_seek(s->pb, pos, SEEK_SET);
1524 static int seek_frame_generic(AVFormatContext *s,
1525 int stream_index, int64_t timestamp, int flags)
1532 st = s->streams[stream_index];
1534 index = av_index_search_timestamp(st, timestamp, flags);
1536 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1539 if(index < 0 || index==st->nb_index_entries-1){
1542 if(st->nb_index_entries){
1543 assert(st->index_entries);
1544 ie= &st->index_entries[st->nb_index_entries-1];
1545 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1547 ff_update_cur_dts(s, st, ie->timestamp);
1549 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1555 read_status = av_read_frame(s, &pkt);
1556 } while (read_status == AVERROR(EAGAIN));
1557 if (read_status < 0)
1559 av_free_packet(&pkt);
1560 if(stream_index == pkt.stream_index){
1561 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1565 index = av_index_search_timestamp(st, timestamp, flags);
1570 ff_read_frame_flush(s);
1571 if (s->iformat->read_seek){
1572 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1575 ie = &st->index_entries[index];
1576 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1578 ff_update_cur_dts(s, st, ie->timestamp);
1583 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1584 int64_t timestamp, int flags)
1589 if (flags & AVSEEK_FLAG_BYTE) {
1590 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1592 ff_read_frame_flush(s);
1593 return seek_frame_byte(s, stream_index, timestamp, flags);
1596 if(stream_index < 0){
1597 stream_index= av_find_default_stream_index(s);
1598 if(stream_index < 0)
1601 st= s->streams[stream_index];
1602 /* timestamp for default must be expressed in AV_TIME_BASE units */
1603 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1606 /* first, we try the format specific seek */
1607 if (s->iformat->read_seek) {
1608 ff_read_frame_flush(s);
1609 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1616 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1617 ff_read_frame_flush(s);
1618 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1619 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1620 ff_read_frame_flush(s);
1621 return seek_frame_generic(s, stream_index, timestamp, flags);
1627 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1629 int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1632 ret = queue_attached_pictures(s);
1637 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1639 if(min_ts > ts || max_ts < ts)
1642 if (s->iformat->read_seek2) {
1644 ff_read_frame_flush(s);
1645 ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1648 ret = queue_attached_pictures(s);
1652 if(s->iformat->read_timestamp){
1653 //try to seek via read_timestamp()
1656 // Fall back on old API if new is not implemented but old is.
1657 // Note the old API has somewhat different semantics.
1658 if(s->iformat->read_seek || 1)
1659 return av_seek_frame(s, stream_index, ts, flags | ((uint64_t)ts - min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0));
1661 // try some generic seek like seek_frame_generic() but with new ts semantics
1664 /*******************************************************/
1667 * Return TRUE if the stream has accurate duration in any stream.
1669 * @return TRUE if the stream has accurate duration for at least one component.
1671 static int has_duration(AVFormatContext *ic)
1676 for(i = 0;i < ic->nb_streams; i++) {
1677 st = ic->streams[i];
1678 if (st->duration != AV_NOPTS_VALUE)
1681 if (ic->duration != AV_NOPTS_VALUE)
1687 * Estimate the stream timings from the one of each components.
1689 * Also computes the global bitrate if possible.
1691 static void update_stream_timings(AVFormatContext *ic)
1693 int64_t start_time, start_time1, end_time, end_time1;
1694 int64_t duration, duration1, filesize;
1698 start_time = INT64_MAX;
1699 end_time = INT64_MIN;
1700 duration = INT64_MIN;
1701 for(i = 0;i < ic->nb_streams; i++) {
1702 st = ic->streams[i];
1703 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1704 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1705 start_time = FFMIN(start_time, start_time1);
1706 if (st->duration != AV_NOPTS_VALUE) {
1707 end_time1 = start_time1
1708 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1709 end_time = FFMAX(end_time, end_time1);
1712 if (st->duration != AV_NOPTS_VALUE) {
1713 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1714 duration = FFMAX(duration, duration1);
1717 if (start_time != INT64_MAX) {
1718 ic->start_time = start_time;
1719 if (end_time != INT64_MIN)
1720 duration = FFMAX(duration, end_time - start_time);
1722 if (duration != INT64_MIN) {
1723 ic->duration = duration;
1724 if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1725 /* compute the bitrate */
1726 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1727 (double)ic->duration;
1732 static void fill_all_stream_timings(AVFormatContext *ic)
1737 update_stream_timings(ic);
1738 for(i = 0;i < ic->nb_streams; i++) {
1739 st = ic->streams[i];
1740 if (st->start_time == AV_NOPTS_VALUE) {
1741 if(ic->start_time != AV_NOPTS_VALUE)
1742 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1743 if(ic->duration != AV_NOPTS_VALUE)
1744 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1749 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1751 int64_t filesize, duration;
1755 /* if bit_rate is already set, we believe it */
1756 if (ic->bit_rate <= 0) {
1758 for(i=0;i<ic->nb_streams;i++) {
1759 st = ic->streams[i];
1760 if (st->codec->bit_rate > 0)
1761 bit_rate += st->codec->bit_rate;
1763 ic->bit_rate = bit_rate;
1766 /* if duration is already set, we believe it */
1767 if (ic->duration == AV_NOPTS_VALUE &&
1768 ic->bit_rate != 0) {
1769 filesize = ic->pb ? avio_size(ic->pb) : 0;
1771 for(i = 0; i < ic->nb_streams; i++) {
1772 st = ic->streams[i];
1773 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1774 if (st->duration == AV_NOPTS_VALUE)
1775 st->duration = duration;
1781 #define DURATION_MAX_READ_SIZE 250000
1782 #define DURATION_MAX_RETRY 3
1784 /* only usable for MPEG-PS streams */
1785 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1787 AVPacket pkt1, *pkt = &pkt1;
1789 int read_size, i, ret;
1791 int64_t filesize, offset, duration;
1794 /* flush packet queue */
1795 flush_packet_queue(ic);
1797 for (i=0; i<ic->nb_streams; i++) {
1798 st = ic->streams[i];
1799 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1800 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1803 av_parser_close(st->parser);
1808 /* estimate the end time (duration) */
1809 /* XXX: may need to support wrapping */
1810 filesize = ic->pb ? avio_size(ic->pb) : 0;
1811 end_time = AV_NOPTS_VALUE;
1813 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1817 avio_seek(ic->pb, offset, SEEK_SET);
1820 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1824 ret = ff_read_packet(ic, pkt);
1825 } while(ret == AVERROR(EAGAIN));
1828 read_size += pkt->size;
1829 st = ic->streams[pkt->stream_index];
1830 if (pkt->pts != AV_NOPTS_VALUE &&
1831 (st->start_time != AV_NOPTS_VALUE ||
1832 st->first_dts != AV_NOPTS_VALUE)) {
1833 duration = end_time = pkt->pts;
1834 if (st->start_time != AV_NOPTS_VALUE)
1835 duration -= st->start_time;
1837 duration -= st->first_dts;
1839 duration += 1LL<<st->pts_wrap_bits;
1841 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1842 st->duration = duration;
1845 av_free_packet(pkt);
1847 }while( end_time==AV_NOPTS_VALUE
1848 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1849 && ++retry <= DURATION_MAX_RETRY);
1851 fill_all_stream_timings(ic);
1853 avio_seek(ic->pb, old_offset, SEEK_SET);
1854 for (i=0; i<ic->nb_streams; i++) {
1856 st->cur_dts= st->first_dts;
1857 st->last_IP_pts = AV_NOPTS_VALUE;
1858 st->reference_dts = AV_NOPTS_VALUE;
1862 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1866 /* get the file size, if possible */
1867 if (ic->iformat->flags & AVFMT_NOFILE) {
1870 file_size = avio_size(ic->pb);
1871 file_size = FFMAX(0, file_size);
1874 if ((!strcmp(ic->iformat->name, "mpeg") ||
1875 !strcmp(ic->iformat->name, "mpegts")) &&
1876 file_size && ic->pb->seekable) {
1877 /* get accurate estimate from the PTSes */
1878 estimate_timings_from_pts(ic, old_offset);
1879 } else if (has_duration(ic)) {
1880 /* at least one component has timings - we use them for all
1882 fill_all_stream_timings(ic);
1884 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1885 /* less precise: use bitrate info */
1886 estimate_timings_from_bit_rate(ic);
1888 update_stream_timings(ic);
1892 AVStream av_unused *st;
1893 for(i = 0;i < ic->nb_streams; i++) {
1894 st = ic->streams[i];
1895 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1896 (double) st->start_time / AV_TIME_BASE,
1897 (double) st->duration / AV_TIME_BASE);
1899 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1900 (double) ic->start_time / AV_TIME_BASE,
1901 (double) ic->duration / AV_TIME_BASE,
1902 ic->bit_rate / 1000);
1906 static int has_codec_parameters(AVStream *st)
1908 AVCodecContext *avctx = st->codec;
1910 switch (avctx->codec_type) {
1911 case AVMEDIA_TYPE_AUDIO:
1912 val = avctx->sample_rate && avctx->channels;
1913 if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1916 case AVMEDIA_TYPE_VIDEO:
1918 if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1925 return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1928 static int has_decode_delay_been_guessed(AVStream *st)
1930 return st->codec->codec_id != AV_CODEC_ID_H264 ||
1931 st->info->nb_decoded_frames >= 6;
1934 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1935 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
1937 const AVCodec *codec;
1938 int got_picture = 1, ret = 0;
1939 AVFrame *frame = avcodec_alloc_frame();
1940 AVPacket pkt = *avpkt;
1943 return AVERROR(ENOMEM);
1945 if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
1946 AVDictionary *thread_opt = NULL;
1948 codec = st->codec->codec ? st->codec->codec :
1949 avcodec_find_decoder(st->codec->codec_id);
1952 st->info->found_decoder = -1;
1957 /* force thread count to 1 since the h264 decoder will not extract SPS
1958 * and PPS to extradata during multi-threaded decoding */
1959 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
1960 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
1962 av_dict_free(&thread_opt);
1964 st->info->found_decoder = -1;
1967 st->info->found_decoder = 1;
1968 } else if (!st->info->found_decoder)
1969 st->info->found_decoder = 1;
1971 if (st->info->found_decoder < 0) {
1976 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
1978 (!has_codec_parameters(st) ||
1979 !has_decode_delay_been_guessed(st) ||
1980 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
1982 avcodec_get_frame_defaults(frame);
1983 switch(st->codec->codec_type) {
1984 case AVMEDIA_TYPE_VIDEO:
1985 ret = avcodec_decode_video2(st->codec, frame,
1986 &got_picture, &pkt);
1988 case AVMEDIA_TYPE_AUDIO:
1989 ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
1996 st->info->nb_decoded_frames++;
2004 avcodec_free_frame(&frame);
2008 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2010 while (tags->id != AV_CODEC_ID_NONE) {
2018 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2021 for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2022 if(tag == tags[i].tag)
2025 for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2026 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2029 return AV_CODEC_ID_NONE;
2032 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2036 case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2037 case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2038 default: return AV_CODEC_ID_NONE;
2042 if (sflags & (1 << (bps - 1))) {
2044 case 1: return AV_CODEC_ID_PCM_S8;
2045 case 2: return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2046 case 3: return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2047 case 4: return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2048 default: return AV_CODEC_ID_NONE;
2052 case 1: return AV_CODEC_ID_PCM_U8;
2053 case 2: return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2054 case 3: return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2055 case 4: return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2056 default: return AV_CODEC_ID_NONE;
2062 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2065 for(i=0; tags && tags[i]; i++){
2066 int tag= ff_codec_get_tag(tags[i], id);
2072 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2075 for(i=0; tags && tags[i]; i++){
2076 enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2077 if(id!=AV_CODEC_ID_NONE) return id;
2079 return AV_CODEC_ID_NONE;
2082 static void compute_chapters_end(AVFormatContext *s)
2085 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2087 for (i = 0; i < s->nb_chapters; i++)
2088 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2089 AVChapter *ch = s->chapters[i];
2090 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2093 for (j = 0; j < s->nb_chapters; j++) {
2094 AVChapter *ch1 = s->chapters[j];
2095 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2096 if (j != i && next_start > ch->start && next_start < end)
2099 ch->end = (end == INT64_MAX) ? ch->start : end;
2103 static int get_std_framerate(int i){
2104 if(i<60*12) return i*1001;
2105 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2109 * Is the time base unreliable.
2110 * This is a heuristic to balance between quick acceptance of the values in
2111 * the headers vs. some extra checks.
2112 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2113 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2114 * And there are "variable" fps files this needs to detect as well.
2116 static int tb_unreliable(AVCodecContext *c){
2117 if( c->time_base.den >= 101L*c->time_base.num
2118 || c->time_base.den < 5L*c->time_base.num
2119 /* || c->codec_tag == AV_RL32("DIVX")
2120 || c->codec_tag == AV_RL32("XVID")*/
2121 || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2122 || c->codec_id == AV_CODEC_ID_H264
2128 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2130 int i, count, ret, read_size, j;
2132 AVPacket pkt1, *pkt;
2133 int64_t old_offset = avio_tell(ic->pb);
2134 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2136 for(i=0;i<ic->nb_streams;i++) {
2137 const AVCodec *codec;
2138 AVDictionary *thread_opt = NULL;
2139 st = ic->streams[i];
2141 //only for the split stuff
2142 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2143 st->parser = av_parser_init(st->codec->codec_id);
2144 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2145 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2148 codec = st->codec->codec ? st->codec->codec :
2149 avcodec_find_decoder(st->codec->codec_id);
2151 /* force thread count to 1 since the h264 decoder will not extract SPS
2152 * and PPS to extradata during multi-threaded decoding */
2153 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2155 /* Ensure that subtitle_header is properly set. */
2156 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2157 && codec && !st->codec->codec)
2158 avcodec_open2(st->codec, codec, options ? &options[i]
2161 //try to just open decoders, in case this is enough to get parameters
2162 if (!has_codec_parameters(st)) {
2163 if (codec && !st->codec->codec)
2164 avcodec_open2(st->codec, codec, options ? &options[i]
2168 av_dict_free(&thread_opt);
2171 for (i=0; i<ic->nb_streams; i++) {
2172 ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2173 ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
2179 if (ff_check_interrupt(&ic->interrupt_callback)){
2181 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2185 /* check if one codec still needs to be handled */
2186 for(i=0;i<ic->nb_streams;i++) {
2187 int fps_analyze_framecount = 20;
2189 st = ic->streams[i];
2190 if (!has_codec_parameters(st))
2192 /* if the timebase is coarse (like the usual millisecond precision
2193 of mkv), we need to analyze more frames to reliably arrive at
2195 if (av_q2d(st->time_base) > 0.0005)
2196 fps_analyze_framecount *= 2;
2197 if (ic->fps_probe_size >= 0)
2198 fps_analyze_framecount = ic->fps_probe_size;
2199 /* variable fps and no guess at the real fps */
2200 if( tb_unreliable(st->codec) && !st->avg_frame_rate.num
2201 && st->codec_info_nb_frames < fps_analyze_framecount
2202 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2204 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2206 if (st->first_dts == AV_NOPTS_VALUE &&
2207 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2208 st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2211 if (i == ic->nb_streams) {
2212 /* NOTE: if the format has no header, then we need to read
2213 some packets to get most of the streams, so we cannot
2215 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2216 /* if we found the info for all the codecs, we can stop */
2218 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2222 /* we did not get all the codec info, but we read too much data */
2223 if (read_size >= ic->probesize) {
2225 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2229 /* NOTE: a new stream can be added there if no header in file
2230 (AVFMTCTX_NOHEADER) */
2231 ret = read_frame_internal(ic, &pkt1);
2232 if (ret == AVERROR(EAGAIN))
2237 AVPacket empty_pkt = { 0 };
2239 av_init_packet(&empty_pkt);
2241 ret = -1; /* we could not have all the codec parameters before EOF */
2242 for(i=0;i<ic->nb_streams;i++) {
2243 st = ic->streams[i];
2245 /* flush the decoders */
2246 if (st->info->found_decoder == 1) {
2248 err = try_decode_frame(st, &empty_pkt,
2249 (options && i < orig_nb_streams) ?
2250 &options[i] : NULL);
2251 } while (err > 0 && !has_codec_parameters(st));
2255 av_log(ic, AV_LOG_WARNING,
2256 "decoding for stream %d failed\n", st->index);
2257 } else if (!has_codec_parameters(st)) {
2259 avcodec_string(buf, sizeof(buf), st->codec, 0);
2260 av_log(ic, AV_LOG_WARNING,
2261 "Could not find codec parameters (%s)\n", buf);
2269 if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2272 pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2273 &ic->packet_buffer_end);
2274 if ((ret = av_dup_packet(pkt)) < 0)
2275 goto find_stream_info_err;
2278 read_size += pkt->size;
2280 st = ic->streams[pkt->stream_index];
2281 if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2282 /* check for non-increasing dts */
2283 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2284 st->info->fps_last_dts >= pkt->dts) {
2285 av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
2286 "packet %d with DTS %"PRId64", packet %d with DTS "
2287 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2288 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2289 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2291 /* check for a discontinuity in dts - if the difference in dts
2292 * is more than 1000 times the average packet duration in the sequence,
2293 * we treat it as a discontinuity */
2294 if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2295 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2296 (pkt->dts - st->info->fps_last_dts) / 1000 >
2297 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2298 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2299 "packet %d with DTS %"PRId64", packet %d with DTS "
2300 "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2301 st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2302 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2305 /* update stored dts values */
2306 if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2307 st->info->fps_first_dts = pkt->dts;
2308 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2310 st->info->fps_last_dts = pkt->dts;
2311 st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2313 /* check max_analyze_duration */
2314 if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2315 AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2316 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2320 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2321 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2322 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2323 st->codec->extradata_size= i;
2324 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2325 if (!st->codec->extradata)
2326 return AVERROR(ENOMEM);
2327 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2328 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2332 /* if still no information, we try to open the codec and to
2333 decompress the frame. We try to avoid that in most cases as
2334 it takes longer and uses more memory. For MPEG-4, we need to
2335 decompress for QuickTime.
2337 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2338 least one frame of codec data, this makes sure the codec initializes
2339 the channel configuration and does not only trust the values from the container.
2341 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2343 st->codec_info_nb_frames++;
2347 // close codecs which were opened in try_decode_frame()
2348 for(i=0;i<ic->nb_streams;i++) {
2349 st = ic->streams[i];
2350 avcodec_close(st->codec);
2352 for(i=0;i<ic->nb_streams;i++) {
2353 st = ic->streams[i];
2354 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2355 /* estimate average framerate if not set by demuxer */
2356 if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
2357 int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
2358 int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
2360 double best_error = 0.01;
2362 if (delta_dts >= INT64_MAX / st->time_base.num ||
2363 delta_packets >= INT64_MAX / st->time_base.den)
2365 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2366 delta_packets*(int64_t)st->time_base.den,
2367 delta_dts*(int64_t)st->time_base.num, 60000);
2369 /* round guessed framerate to a "standard" framerate if it's
2370 * within 1% of the original estimate*/
2371 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2372 AVRational std_fps = { get_std_framerate(j), 12*1001 };
2373 double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2375 if (error < best_error) {
2377 best_fps = std_fps.num;
2381 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2382 best_fps, 12*1001, INT_MAX);
2385 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2386 if(!st->codec->bits_per_coded_sample)
2387 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2388 // set stream disposition based on audio service type
2389 switch (st->codec->audio_service_type) {
2390 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2391 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2392 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2393 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2394 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2395 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2396 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2397 st->disposition = AV_DISPOSITION_COMMENT; break;
2398 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2399 st->disposition = AV_DISPOSITION_KARAOKE; break;
2404 estimate_timings(ic, old_offset);
2406 compute_chapters_end(ic);
2408 find_stream_info_err:
2409 for (i=0; i < ic->nb_streams; i++) {
2410 if (ic->streams[i]->codec)
2411 ic->streams[i]->codec->thread_count = 0;
2412 av_freep(&ic->streams[i]->info);
2417 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2421 for (i = 0; i < ic->nb_programs; i++)
2422 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2423 if (ic->programs[i]->stream_index[j] == s)
2424 return ic->programs[i];
2428 int av_find_best_stream(AVFormatContext *ic,
2429 enum AVMediaType type,
2430 int wanted_stream_nb,
2432 AVCodec **decoder_ret,
2435 int i, nb_streams = ic->nb_streams;
2436 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2437 unsigned *program = NULL;
2438 AVCodec *decoder = NULL, *best_decoder = NULL;
2440 if (related_stream >= 0 && wanted_stream_nb < 0) {
2441 AVProgram *p = find_program_from_stream(ic, related_stream);
2443 program = p->stream_index;
2444 nb_streams = p->nb_stream_indexes;
2447 for (i = 0; i < nb_streams; i++) {
2448 int real_stream_index = program ? program[i] : i;
2449 AVStream *st = ic->streams[real_stream_index];
2450 AVCodecContext *avctx = st->codec;
2451 if (avctx->codec_type != type)
2453 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2455 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2458 decoder = avcodec_find_decoder(st->codec->codec_id);
2461 ret = AVERROR_DECODER_NOT_FOUND;
2465 if (best_count >= st->codec_info_nb_frames)
2467 best_count = st->codec_info_nb_frames;
2468 ret = real_stream_index;
2469 best_decoder = decoder;
2470 if (program && i == nb_streams - 1 && ret < 0) {
2472 nb_streams = ic->nb_streams;
2473 i = 0; /* no related stream found, try again with everything */
2477 *decoder_ret = best_decoder;
2481 /*******************************************************/
2483 int av_read_play(AVFormatContext *s)
2485 if (s->iformat->read_play)
2486 return s->iformat->read_play(s);
2488 return avio_pause(s->pb, 0);
2489 return AVERROR(ENOSYS);
2492 int av_read_pause(AVFormatContext *s)
2494 if (s->iformat->read_pause)
2495 return s->iformat->read_pause(s);
2497 return avio_pause(s->pb, 1);
2498 return AVERROR(ENOSYS);
2501 void avformat_free_context(AVFormatContext *s)
2507 if (s->iformat && s->iformat->priv_class && s->priv_data)
2508 av_opt_free(s->priv_data);
2510 for(i=0;i<s->nb_streams;i++) {
2511 /* free all data in a stream component */
2514 av_parser_close(st->parser);
2516 if (st->attached_pic.data)
2517 av_free_packet(&st->attached_pic);
2518 av_dict_free(&st->metadata);
2519 av_freep(&st->probe_data.buf);
2520 av_free(st->index_entries);
2521 av_free(st->codec->extradata);
2522 av_free(st->codec->subtitle_header);
2524 av_free(st->priv_data);
2528 for(i=s->nb_programs-1; i>=0; i--) {
2529 av_dict_free(&s->programs[i]->metadata);
2530 av_freep(&s->programs[i]->stream_index);
2531 av_freep(&s->programs[i]);
2533 av_freep(&s->programs);
2534 av_freep(&s->priv_data);
2535 while(s->nb_chapters--) {
2536 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2537 av_free(s->chapters[s->nb_chapters]);
2539 av_freep(&s->chapters);
2540 av_dict_free(&s->metadata);
2541 av_freep(&s->streams);
2545 void avformat_close_input(AVFormatContext **ps)
2547 AVFormatContext *s = *ps;
2548 AVIOContext *pb = s->pb;
2550 if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2551 (s->flags & AVFMT_FLAG_CUSTOM_IO))
2554 flush_packet_queue(s);
2557 if (s->iformat->read_close)
2558 s->iformat->read_close(s);
2561 avformat_free_context(s);
2568 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2574 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2576 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2579 s->streams = streams;
2581 st = av_mallocz(sizeof(AVStream));
2584 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2589 st->codec = avcodec_alloc_context3(c);
2591 /* no default bitrate if decoding */
2592 st->codec->bit_rate = 0;
2594 st->index = s->nb_streams;
2595 st->start_time = AV_NOPTS_VALUE;
2596 st->duration = AV_NOPTS_VALUE;
2597 /* we set the current DTS to 0 so that formats without any timestamps
2598 but durations get some timestamps, formats with some unknown
2599 timestamps have their first few packets buffered and the
2600 timestamps corrected before they are returned to the user */
2602 st->first_dts = AV_NOPTS_VALUE;
2603 st->probe_packets = MAX_PROBE_PACKETS;
2605 /* default pts setting is MPEG-like */
2606 avpriv_set_pts_info(st, 33, 1, 90000);
2607 st->last_IP_pts = AV_NOPTS_VALUE;
2608 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2609 st->pts_buffer[i]= AV_NOPTS_VALUE;
2610 st->reference_dts = AV_NOPTS_VALUE;
2612 st->sample_aspect_ratio = (AVRational){0,1};
2614 st->info->fps_first_dts = AV_NOPTS_VALUE;
2615 st->info->fps_last_dts = AV_NOPTS_VALUE;
2617 s->streams[s->nb_streams++] = st;
2621 AVProgram *av_new_program(AVFormatContext *ac, int id)
2623 AVProgram *program=NULL;
2626 av_dlog(ac, "new_program: id=0x%04x\n", id);
2628 for(i=0; i<ac->nb_programs; i++)
2629 if(ac->programs[i]->id == id)
2630 program = ac->programs[i];
2633 program = av_mallocz(sizeof(AVProgram));
2636 dynarray_add(&ac->programs, &ac->nb_programs, program);
2637 program->discard = AVDISCARD_NONE;
2644 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2646 AVChapter *chapter = NULL;
2649 for(i=0; i<s->nb_chapters; i++)
2650 if(s->chapters[i]->id == id)
2651 chapter = s->chapters[i];
2654 chapter= av_mallocz(sizeof(AVChapter));
2657 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2659 av_dict_set(&chapter->metadata, "title", title, 0);
2661 chapter->time_base= time_base;
2662 chapter->start = start;
2668 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2671 AVProgram *program=NULL;
2674 if (idx >= ac->nb_streams) {
2675 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2679 for(i=0; i<ac->nb_programs; i++){
2680 if(ac->programs[i]->id != progid)
2682 program = ac->programs[i];
2683 for(j=0; j<program->nb_stream_indexes; j++)
2684 if(program->stream_index[j] == idx)
2687 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2690 program->stream_index = tmp;
2691 program->stream_index[program->nb_stream_indexes++] = idx;
2696 static void print_fps(double d, const char *postfix){
2697 uint64_t v= lrintf(d*100);
2698 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2699 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2700 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2703 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
2705 if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
2706 AVDictionaryEntry *tag=NULL;
2708 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2709 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
2710 if(strcmp("language", tag->key))
2711 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2716 /* "user interface" functions */
2717 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2720 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2721 AVStream *st = ic->streams[i];
2722 int g = av_gcd(st->time_base.num, st->time_base.den);
2723 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
2724 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2725 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2726 /* the pid is an important information, so we display it */
2727 /* XXX: add a generic system */
2728 if (flags & AVFMT_SHOW_IDS)
2729 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2731 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2732 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2733 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2734 if (st->sample_aspect_ratio.num && // default
2735 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2736 AVRational display_aspect_ratio;
2737 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2738 st->codec->width*st->sample_aspect_ratio.num,
2739 st->codec->height*st->sample_aspect_ratio.den,
2741 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2742 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2743 display_aspect_ratio.num, display_aspect_ratio.den);
2745 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2746 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2747 print_fps(av_q2d(st->avg_frame_rate), "fps");
2748 if(st->time_base.den && st->time_base.num)
2749 print_fps(1/av_q2d(st->time_base), "tbn");
2750 if(st->codec->time_base.den && st->codec->time_base.num)
2751 print_fps(1/av_q2d(st->codec->time_base), "tbc");
2753 if (st->disposition & AV_DISPOSITION_DEFAULT)
2754 av_log(NULL, AV_LOG_INFO, " (default)");
2755 if (st->disposition & AV_DISPOSITION_DUB)
2756 av_log(NULL, AV_LOG_INFO, " (dub)");
2757 if (st->disposition & AV_DISPOSITION_ORIGINAL)
2758 av_log(NULL, AV_LOG_INFO, " (original)");
2759 if (st->disposition & AV_DISPOSITION_COMMENT)
2760 av_log(NULL, AV_LOG_INFO, " (comment)");
2761 if (st->disposition & AV_DISPOSITION_LYRICS)
2762 av_log(NULL, AV_LOG_INFO, " (lyrics)");
2763 if (st->disposition & AV_DISPOSITION_KARAOKE)
2764 av_log(NULL, AV_LOG_INFO, " (karaoke)");
2765 if (st->disposition & AV_DISPOSITION_FORCED)
2766 av_log(NULL, AV_LOG_INFO, " (forced)");
2767 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
2768 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
2769 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
2770 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
2771 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
2772 av_log(NULL, AV_LOG_INFO, " (clean effects)");
2773 av_log(NULL, AV_LOG_INFO, "\n");
2774 dump_metadata(NULL, st->metadata, " ");
2777 void av_dump_format(AVFormatContext *ic,
2783 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
2784 if (ic->nb_streams && !printed)
2787 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2788 is_output ? "Output" : "Input",
2790 is_output ? ic->oformat->name : ic->iformat->name,
2791 is_output ? "to" : "from", url);
2792 dump_metadata(NULL, ic->metadata, " ");
2794 av_log(NULL, AV_LOG_INFO, " Duration: ");
2795 if (ic->duration != AV_NOPTS_VALUE) {
2796 int hours, mins, secs, us;
2797 secs = ic->duration / AV_TIME_BASE;
2798 us = ic->duration % AV_TIME_BASE;
2803 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2804 (100 * us) / AV_TIME_BASE);
2806 av_log(NULL, AV_LOG_INFO, "N/A");
2808 if (ic->start_time != AV_NOPTS_VALUE) {
2810 av_log(NULL, AV_LOG_INFO, ", start: ");
2811 secs = ic->start_time / AV_TIME_BASE;
2812 us = abs(ic->start_time % AV_TIME_BASE);
2813 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2814 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2816 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2818 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2820 av_log(NULL, AV_LOG_INFO, "N/A");
2822 av_log(NULL, AV_LOG_INFO, "\n");
2824 for (i = 0; i < ic->nb_chapters; i++) {
2825 AVChapter *ch = ic->chapters[i];
2826 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
2827 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
2828 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
2830 dump_metadata(NULL, ch->metadata, " ");
2832 if(ic->nb_programs) {
2833 int j, k, total = 0;
2834 for(j=0; j<ic->nb_programs; j++) {
2835 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
2837 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
2838 name ? name->value : "");
2839 dump_metadata(NULL, ic->programs[j]->metadata, " ");
2840 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2841 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2842 printed[ic->programs[j]->stream_index[k]] = 1;
2844 total += ic->programs[j]->nb_stream_indexes;
2846 if (total < ic->nb_streams)
2847 av_log(NULL, AV_LOG_INFO, " No Program\n");
2849 for(i=0;i<ic->nb_streams;i++)
2851 dump_stream_format(ic, i, index, is_output);
2856 uint64_t ff_ntp_time(void)
2858 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2861 int av_get_frame_filename(char *buf, int buf_size,
2862 const char *path, int number)
2865 char *q, buf1[20], c;
2866 int nd, len, percentd_found;
2878 while (av_isdigit(*p)) {
2879 nd = nd * 10 + *p++ - '0';
2882 } while (av_isdigit(c));
2891 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2893 if ((q - buf + len) > buf_size - 1)
2895 memcpy(q, buf1, len);
2903 if ((q - buf) < buf_size - 1)
2907 if (!percentd_found)
2916 static void hex_dump_internal(void *avcl, FILE *f, int level,
2917 const uint8_t *buf, int size)
2920 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2922 for(i=0;i<size;i+=16) {
2929 PRINT(" %02x", buf[i+j]);
2934 for(j=0;j<len;j++) {
2936 if (c < ' ' || c > '~')
2945 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
2947 hex_dump_internal(NULL, f, 0, buf, size);
2950 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
2952 hex_dump_internal(avcl, NULL, level, buf, size);
2955 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
2957 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2958 PRINT("stream #%d:\n", pkt->stream_index);
2959 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
2960 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
2961 /* DTS is _always_ valid after av_read_frame() */
2963 if (pkt->dts == AV_NOPTS_VALUE)
2966 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
2967 /* PTS may not be known if B-frames are present. */
2969 if (pkt->pts == AV_NOPTS_VALUE)
2972 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
2974 PRINT(" size=%d\n", pkt->size);
2977 av_hex_dump(f, pkt->data, pkt->size);
2980 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
2982 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
2985 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
2988 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
2991 void av_url_split(char *proto, int proto_size,
2992 char *authorization, int authorization_size,
2993 char *hostname, int hostname_size,
2995 char *path, int path_size,
2998 const char *p, *ls, *at, *col, *brk;
3000 if (port_ptr) *port_ptr = -1;
3001 if (proto_size > 0) proto[0] = 0;
3002 if (authorization_size > 0) authorization[0] = 0;
3003 if (hostname_size > 0) hostname[0] = 0;
3004 if (path_size > 0) path[0] = 0;
3006 /* parse protocol */
3007 if ((p = strchr(url, ':'))) {
3008 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3013 /* no protocol means plain filename */
3014 av_strlcpy(path, url, path_size);
3018 /* separate path from hostname */
3019 ls = strchr(p, '/');
3021 ls = strchr(p, '?');
3023 av_strlcpy(path, ls, path_size);
3025 ls = &p[strlen(p)]; // XXX
3027 /* the rest is hostname, use that to parse auth/port */
3029 /* authorization (user[:pass]@hostname) */
3030 if ((at = strchr(p, '@')) && at < ls) {
3031 av_strlcpy(authorization, p,
3032 FFMIN(authorization_size, at + 1 - p));
3033 p = at + 1; /* skip '@' */
3036 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3038 av_strlcpy(hostname, p + 1,
3039 FFMIN(hostname_size, brk - p));
3040 if (brk[1] == ':' && port_ptr)
3041 *port_ptr = atoi(brk + 2);
3042 } else if ((col = strchr(p, ':')) && col < ls) {
3043 av_strlcpy(hostname, p,
3044 FFMIN(col + 1 - p, hostname_size));
3045 if (port_ptr) *port_ptr = atoi(col + 1);
3047 av_strlcpy(hostname, p,
3048 FFMIN(ls + 1 - p, hostname_size));
3052 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3055 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3058 'C', 'D', 'E', 'F' };
3059 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3062 'c', 'd', 'e', 'f' };
3063 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3065 for(i = 0; i < s; i++) {
3066 buff[i * 2] = hex_table[src[i] >> 4];
3067 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3073 int ff_hex_to_data(uint8_t *data, const char *p)
3080 p += strspn(p, SPACE_CHARS);
3083 c = av_toupper((unsigned char) *p++);
3084 if (c >= '0' && c <= '9')
3086 else if (c >= 'A' && c <= 'F')
3101 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3102 unsigned int pts_num, unsigned int pts_den)
3105 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3106 if(new_tb.num != pts_num)
3107 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3109 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3111 if(new_tb.num <= 0 || new_tb.den <= 0) {
3112 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3115 s->time_base = new_tb;
3116 s->pts_wrap_bits = pts_wrap_bits;
3119 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3122 const char *ptr = str;
3124 /* Parse key=value pairs. */
3127 char *dest = NULL, *dest_end;
3128 int key_len, dest_len = 0;
3130 /* Skip whitespace and potential commas. */
3131 while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3138 if (!(ptr = strchr(key, '=')))
3141 key_len = ptr - key;
3143 callback_get_buf(context, key, key_len, &dest, &dest_len);
3144 dest_end = dest + dest_len - 1;
3148 while (*ptr && *ptr != '\"') {
3152 if (dest && dest < dest_end)
3156 if (dest && dest < dest_end)
3164 for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3165 if (dest && dest < dest_end)
3173 int ff_find_stream_index(AVFormatContext *s, int id)
3176 for (i = 0; i < s->nb_streams; i++) {
3177 if (s->streams[i]->id == id)
3183 int64_t ff_iso8601_to_unix_time(const char *datestr)
3186 struct tm time1 = {0}, time2 = {0};
3188 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3189 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3191 return av_timegm(&time2);
3193 return av_timegm(&time1);
3195 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3196 "the date string.\n");
3201 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
3204 if (ofmt->query_codec)
3205 return ofmt->query_codec(codec_id, std_compliance);
3206 else if (ofmt->codec_tag)
3207 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3208 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3209 codec_id == ofmt->subtitle_codec)
3212 return AVERROR_PATCHWELCOME;
3215 int avformat_network_init(void)
3219 ff_network_inited_globally = 1;
3220 if ((ret = ff_network_init()) < 0)
3227 int avformat_network_deinit(void)
3236 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3237 uint64_t channel_layout, int32_t sample_rate,
3238 int32_t width, int32_t height)
3244 return AVERROR(EINVAL);
3247 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3249 if (channel_layout) {
3251 flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3255 flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3257 if (width || height) {
3259 flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3261 data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3263 return AVERROR(ENOMEM);
3264 bytestream_put_le32(&data, flags);
3266 bytestream_put_le32(&data, channels);
3268 bytestream_put_le64(&data, channel_layout);
3270 bytestream_put_le32(&data, sample_rate);
3271 if (width || height) {
3272 bytestream_put_le32(&data, width);
3273 bytestream_put_le32(&data, height);