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 "libavutil/opt.h"
32 #include "libavutil/avstring.h"
34 #include "audiointerleave.h"
49 * various utility functions for use within FFmpeg
52 unsigned avformat_version(void)
54 return LIBAVFORMAT_VERSION_INT;
57 const char *avformat_configuration(void)
59 return FFMPEG_CONFIGURATION;
62 const char *avformat_license(void)
64 #define LICENSE_PREFIX "libavformat license: "
65 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
68 /* fraction handling */
71 * f = val + (num / den) + 0.5.
73 * 'num' is normalized so that it is such as 0 <= num < den.
75 * @param f fractional number
76 * @param val integer value
77 * @param num must be >= 0
78 * @param den must be >= 1
80 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
93 * Fractional addition to f: f = f + (incr / f->den).
95 * @param f fractional number
96 * @param incr increment, can be positive or negative
98 static void av_frac_add(AVFrac *f, int64_t incr)
111 } else if (num >= den) {
118 /** head of registered input format linked list */
119 static AVInputFormat *first_iformat = NULL;
120 /** head of registered output format linked list */
121 static AVOutputFormat *first_oformat = NULL;
123 AVInputFormat *av_iformat_next(AVInputFormat *f)
125 if(f) return f->next;
126 else return first_iformat;
129 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
131 if(f) return f->next;
132 else return first_oformat;
135 void av_register_input_format(AVInputFormat *format)
139 while (*p != NULL) p = &(*p)->next;
144 void av_register_output_format(AVOutputFormat *format)
148 while (*p != NULL) p = &(*p)->next;
153 int av_match_ext(const char *filename, const char *extensions)
161 ext = strrchr(filename, '.');
167 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
170 if (!strcasecmp(ext1, ext))
180 static int match_format(const char *name, const char *names)
188 namelen = strlen(name);
189 while ((p = strchr(names, ','))) {
190 len = FFMAX(p - names, namelen);
191 if (!strncasecmp(name, names, len))
195 return !strcasecmp(name, names);
198 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199 const char *mime_type)
201 AVOutputFormat *fmt = NULL, *fmt_found;
202 int score_max, score;
204 /* specific test for image sequences */
205 #if CONFIG_IMAGE2_MUXER
206 if (!short_name && filename &&
207 av_filename_number_test(filename) &&
208 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
209 return av_guess_format("image2", NULL, NULL);
212 /* Find the proper file type. */
215 while ((fmt = av_oformat_next(fmt))) {
217 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
219 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
221 if (filename && fmt->extensions &&
222 av_match_ext(filename, fmt->extensions)) {
225 if (score > score_max) {
233 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
234 const char *filename, const char *mime_type, enum AVMediaType type){
235 if(type == AVMEDIA_TYPE_VIDEO){
236 enum CodecID codec_id= CODEC_ID_NONE;
238 #if CONFIG_IMAGE2_MUXER
239 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
240 codec_id= ff_guess_image2_codec(filename);
243 if(codec_id == CODEC_ID_NONE)
244 codec_id= fmt->video_codec;
246 }else if(type == AVMEDIA_TYPE_AUDIO)
247 return fmt->audio_codec;
248 else if (type == AVMEDIA_TYPE_SUBTITLE)
249 return fmt->subtitle_codec;
251 return CODEC_ID_NONE;
254 AVInputFormat *av_find_input_format(const char *short_name)
256 AVInputFormat *fmt = NULL;
257 while ((fmt = av_iformat_next(fmt))) {
258 if (match_format(short_name, fmt->name))
265 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
267 int ret= av_new_packet(pkt, size);
272 pkt->pos= avio_tell(s);
274 ret= avio_read(s, pkt->data, size);
278 av_shrink_packet(pkt, ret);
283 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
288 return av_get_packet(s, pkt, size);
289 old_size = pkt->size;
290 ret = av_grow_packet(pkt, size);
293 ret = avio_read(s, pkt->data + old_size, size);
294 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
299 int av_filename_number_test(const char *filename)
302 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
305 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
307 AVProbeData lpd = *pd;
308 AVInputFormat *fmt1 = NULL, *fmt;
309 int score, score_max=0;
311 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
312 int id3len = ff_id3v2_tag_len(lpd.buf);
313 if (lpd.buf_size > id3len + 16) {
315 lpd.buf_size -= id3len;
320 while ((fmt1 = av_iformat_next(fmt1))) {
321 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
324 if (fmt1->read_probe) {
325 score = fmt1->read_probe(&lpd);
326 if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
328 } else if (fmt1->extensions) {
329 if (av_match_ext(lpd.filename, fmt1->extensions)) {
333 if (score > score_max) {
336 }else if (score == score_max)
339 *score_ret= score_max;
343 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
346 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
347 if(score_ret > *score_max){
348 *score_max= score_ret;
354 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
356 return av_probe_input_format2(pd, is_opened, &score);
359 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
361 static const struct {
362 const char *name; enum CodecID id; enum AVMediaType type;
364 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
365 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
366 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
367 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
368 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
369 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
370 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
371 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
375 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
379 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
380 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
381 for (i = 0; fmt_id_type[i].name; i++) {
382 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
383 st->codec->codec_id = fmt_id_type[i].id;
384 st->codec->codec_type = fmt_id_type[i].type;
392 /************************************************************/
393 /* input media file */
396 * Open a media file from an IO stream. 'fmt' must be specified.
398 int av_open_input_stream(AVFormatContext **ic_ptr,
399 AVIOContext *pb, const char *filename,
400 AVInputFormat *fmt, AVFormatParameters *ap)
404 AVFormatParameters default_ap;
408 memset(ap, 0, sizeof(default_ap));
411 if(!ap->prealloced_context)
412 ic = avformat_alloc_context();
416 err = AVERROR(ENOMEM);
421 ic->duration = AV_NOPTS_VALUE;
422 ic->start_time = AV_NOPTS_VALUE;
423 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
425 /* allocate private data */
426 if (fmt->priv_data_size > 0) {
427 ic->priv_data = av_mallocz(fmt->priv_data_size);
428 if (!ic->priv_data) {
429 err = AVERROR(ENOMEM);
433 ic->priv_data = NULL;
436 // e.g. AVFMT_NOFILE formats will not have a AVIOContext
438 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
440 if (ic->iformat->read_header) {
441 err = ic->iformat->read_header(ic, ap);
446 if (pb && !ic->data_offset)
447 ic->data_offset = avio_tell(ic->pb);
449 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
456 av_freep(&ic->priv_data);
457 for(i=0;i<ic->nb_streams;i++) {
458 AVStream *st = ic->streams[i];
460 av_free(st->priv_data);
461 av_free(st->codec->extradata);
473 /** size of probe buffer, for guessing file type from file contents */
474 #define PROBE_BUF_MIN 2048
475 #define PROBE_BUF_MAX (1<<20)
477 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
478 const char *filename, void *logctx,
479 unsigned int offset, unsigned int max_probe_size)
481 AVProbeData pd = { filename ? filename : "", NULL, -offset };
482 unsigned char *buf = NULL;
483 int ret = 0, probe_size;
485 if (!max_probe_size) {
486 max_probe_size = PROBE_BUF_MAX;
487 } else if (max_probe_size > PROBE_BUF_MAX) {
488 max_probe_size = PROBE_BUF_MAX;
489 } else if (max_probe_size < PROBE_BUF_MIN) {
490 return AVERROR(EINVAL);
493 if (offset >= max_probe_size) {
494 return AVERROR(EINVAL);
497 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
498 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
499 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
500 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
502 if (probe_size < offset) {
506 /* read probe data */
507 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
508 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
509 /* fail if error was not end of file, otherwise, lower score */
510 if (ret != AVERROR_EOF) {
515 ret = 0; /* error was end of file, nothing read */
518 pd.buf = &buf[offset];
520 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
522 /* guess file format */
523 *fmt = av_probe_input_format2(&pd, 1, &score);
525 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
526 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
528 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
534 return AVERROR_INVALIDDATA;
537 /* rewind. reuse probe buffer to avoid seeking */
538 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
544 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
547 AVFormatParameters *ap)
550 AVProbeData probe_data, *pd = &probe_data;
551 AVIOContext *pb = NULL;
552 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
556 pd->filename = filename;
561 /* guess format if no file can be opened */
562 fmt = av_probe_input_format(pd, 0);
565 /* Do not open file if the format does not need it. XXX: specific
566 hack needed to handle RTSP/TCP */
567 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
568 /* if no file needed do not try to open one */
569 if ((err=avio_open(&pb, filename, AVIO_FLAG_READ)) < 0) {
573 ffio_set_buf_size(pb, buf_size);
575 if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
580 /* if still no format found, error */
582 err = AVERROR_INVALIDDATA;
586 /* check filename in case an image number is expected */
587 if (fmt->flags & AVFMT_NEEDNUMBER) {
588 if (!av_filename_number_test(filename)) {
589 err = AVERROR(EINVAL);
593 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
601 if (ap && ap->prealloced_context)
608 /*******************************************************/
610 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
611 AVPacketList **plast_pktl){
612 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
617 (*plast_pktl)->next = pktl;
619 *packet_buffer = pktl;
621 /* add the packet in the buffered packet list */
627 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
633 AVPacketList *pktl = s->raw_packet_buffer;
637 if(s->streams[pkt->stream_index]->request_probe <= 0){
638 s->raw_packet_buffer = pktl->next;
639 s->raw_packet_buffer_remaining_size += pkt->size;
646 ret= s->iformat->read_packet(s, pkt);
648 if (!pktl || ret == AVERROR(EAGAIN))
650 for (i = 0; i < s->nb_streams; i++)
651 if(s->streams[i]->request_probe > 0)
652 s->streams[i]->request_probe = -1;
655 st= s->streams[pkt->stream_index];
657 switch(st->codec->codec_type){
658 case AVMEDIA_TYPE_VIDEO:
659 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
661 case AVMEDIA_TYPE_AUDIO:
662 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
664 case AVMEDIA_TYPE_SUBTITLE:
665 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
669 if(!pktl && st->request_probe <= 0)
672 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
673 s->raw_packet_buffer_remaining_size -= pkt->size;
675 if(st->request_probe>0){
676 AVProbeData *pd = &st->probe_data;
678 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
681 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
682 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
683 pd->buf_size += pkt->size;
684 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
686 end= s->raw_packet_buffer_remaining_size <= 0
687 || st->probe_packets<=0;
689 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
690 int score= set_codec_from_probe_data(s, st, pd);
691 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
695 st->request_probe= -1;
696 if(st->codec->codec_id != CODEC_ID_NONE){
697 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
699 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
706 /**********************************************************/
709 * Get the number of samples of an audio frame. Return -1 on error.
711 static int get_audio_frame_size(AVCodecContext *enc, int size)
715 if(enc->codec_id == CODEC_ID_VORBIS)
718 if (enc->frame_size <= 1) {
719 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
721 if (bits_per_sample) {
722 if (enc->channels == 0)
724 frame_size = (size << 3) / (bits_per_sample * enc->channels);
726 /* used for example by ADPCM codecs */
727 if (enc->bit_rate == 0)
729 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
732 frame_size = enc->frame_size;
739 * Return the frame duration in seconds. Return 0 if not available.
741 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
742 AVCodecParserContext *pc, AVPacket *pkt)
748 switch(st->codec->codec_type) {
749 case AVMEDIA_TYPE_VIDEO:
750 if(st->time_base.num*1000LL > st->time_base.den){
751 *pnum = st->time_base.num;
752 *pden = st->time_base.den;
753 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
754 *pnum = st->codec->time_base.num;
755 *pden = st->codec->time_base.den;
756 if (pc && pc->repeat_pict) {
757 *pnum = (*pnum) * (1 + pc->repeat_pict);
759 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
760 //Thus if we have no parser in such case leave duration undefined.
761 if(st->codec->ticks_per_frame>1 && !pc){
766 case AVMEDIA_TYPE_AUDIO:
767 frame_size = get_audio_frame_size(st->codec, pkt->size);
768 if (frame_size <= 0 || st->codec->sample_rate <= 0)
771 *pden = st->codec->sample_rate;
778 static int is_intra_only(AVCodecContext *enc){
779 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
781 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
782 switch(enc->codec_id){
784 case CODEC_ID_MJPEGB:
786 case CODEC_ID_RAWVIDEO:
787 case CODEC_ID_DVVIDEO:
788 case CODEC_ID_HUFFYUV:
789 case CODEC_ID_FFVHUFF:
794 case CODEC_ID_JPEG2000:
802 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
803 int64_t dts, int64_t pts)
805 AVStream *st= s->streams[stream_index];
806 AVPacketList *pktl= s->packet_buffer;
808 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
811 st->first_dts= dts - st->cur_dts;
814 for(; pktl; pktl= pktl->next){
815 if(pktl->pkt.stream_index != stream_index)
817 //FIXME think more about this check
818 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
819 pktl->pkt.pts += st->first_dts;
821 if(pktl->pkt.dts != AV_NOPTS_VALUE)
822 pktl->pkt.dts += st->first_dts;
824 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
825 st->start_time= pktl->pkt.pts;
827 if (st->start_time == AV_NOPTS_VALUE)
828 st->start_time = pts;
831 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
833 AVPacketList *pktl= s->packet_buffer;
836 if(st->first_dts != AV_NOPTS_VALUE){
837 cur_dts= st->first_dts;
838 for(; pktl; pktl= pktl->next){
839 if(pktl->pkt.stream_index == pkt->stream_index){
840 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
842 cur_dts -= pkt->duration;
845 pktl= s->packet_buffer;
846 st->first_dts = cur_dts;
847 }else if(st->cur_dts)
850 for(; pktl; pktl= pktl->next){
851 if(pktl->pkt.stream_index != pkt->stream_index)
853 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
854 && !pktl->pkt.duration){
855 pktl->pkt.dts= cur_dts;
856 if(!st->codec->has_b_frames)
857 pktl->pkt.pts= cur_dts;
858 cur_dts += pkt->duration;
859 pktl->pkt.duration= pkt->duration;
863 if(st->first_dts == AV_NOPTS_VALUE)
864 st->cur_dts= cur_dts;
867 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
868 AVCodecParserContext *pc, AVPacket *pkt)
870 int num, den, presentation_delayed, delay, i;
873 if (s->flags & AVFMT_FLAG_NOFILLIN)
876 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
877 pkt->dts= AV_NOPTS_VALUE;
879 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
880 //FIXME Set low_delay = 0 when has_b_frames = 1
881 st->codec->has_b_frames = 1;
883 /* do we have a video B-frame ? */
884 delay= st->codec->has_b_frames;
885 presentation_delayed = 0;
887 // ignore delay caused by frame threading so that the mpeg2-without-dts
888 // warning will not trigger
889 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
890 delay -= st->codec->thread_count-1;
892 /* XXX: need has_b_frame, but cannot get it if the codec is
895 pc && pc->pict_type != FF_B_TYPE)
896 presentation_delayed = 1;
898 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
899 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
900 pkt->dts -= 1LL<<st->pts_wrap_bits;
903 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
904 // we take the conservative approach and discard both
905 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
906 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
907 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
908 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
911 if (pkt->duration == 0) {
912 compute_frame_duration(&num, &den, st, pc, pkt);
914 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
916 if(pkt->duration != 0 && s->packet_buffer)
917 update_initial_durations(s, st, pkt);
921 /* correct timestamps with byte offset if demuxers only have timestamps
922 on packet boundaries */
923 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
924 /* this will estimate bitrate based on this frame's duration and size */
925 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
926 if(pkt->pts != AV_NOPTS_VALUE)
928 if(pkt->dts != AV_NOPTS_VALUE)
932 if (pc && pc->dts_sync_point >= 0) {
933 // we have synchronization info from the parser
934 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
936 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
937 if (pkt->dts != AV_NOPTS_VALUE) {
938 // got DTS from the stream, update reference timestamp
939 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
940 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
941 } else if (st->reference_dts != AV_NOPTS_VALUE) {
942 // compute DTS based on reference timestamp
943 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
944 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
946 if (pc->dts_sync_point > 0)
947 st->reference_dts = pkt->dts; // new reference
951 /* This may be redundant, but it should not hurt. */
952 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
953 presentation_delayed = 1;
955 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
956 /* interpolate PTS and DTS if they are not present */
957 //We skip H264 currently because delay and has_b_frames are not reliably set
958 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
959 if (presentation_delayed) {
960 /* DTS = decompression timestamp */
961 /* PTS = presentation timestamp */
962 if (pkt->dts == AV_NOPTS_VALUE)
963 pkt->dts = st->last_IP_pts;
964 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
965 if (pkt->dts == AV_NOPTS_VALUE)
966 pkt->dts = st->cur_dts;
968 /* this is tricky: the dts must be incremented by the duration
969 of the frame we are displaying, i.e. the last I- or P-frame */
970 if (st->last_IP_duration == 0)
971 st->last_IP_duration = pkt->duration;
972 if(pkt->dts != AV_NOPTS_VALUE)
973 st->cur_dts = pkt->dts + st->last_IP_duration;
974 st->last_IP_duration = pkt->duration;
975 st->last_IP_pts= pkt->pts;
976 /* cannot compute PTS if not present (we can compute it only
977 by knowing the future */
978 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
979 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
980 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
981 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
982 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
983 pkt->pts += pkt->duration;
984 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
988 /* presentation is not delayed : PTS and DTS are the same */
989 if(pkt->pts == AV_NOPTS_VALUE)
991 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
992 if(pkt->pts == AV_NOPTS_VALUE)
993 pkt->pts = st->cur_dts;
995 if(pkt->pts != AV_NOPTS_VALUE)
996 st->cur_dts = pkt->pts + pkt->duration;
1000 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1001 st->pts_buffer[0]= pkt->pts;
1002 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1003 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1004 if(pkt->dts == AV_NOPTS_VALUE)
1005 pkt->dts= st->pts_buffer[0];
1006 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1007 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1009 if(pkt->dts > st->cur_dts)
1010 st->cur_dts = pkt->dts;
1013 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1016 if(is_intra_only(st->codec))
1017 pkt->flags |= AV_PKT_FLAG_KEY;
1020 /* keyframe computation */
1021 if (pc->key_frame == 1)
1022 pkt->flags |= AV_PKT_FLAG_KEY;
1023 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1024 pkt->flags |= AV_PKT_FLAG_KEY;
1027 pkt->convergence_duration = pc->convergence_duration;
1031 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1036 av_init_packet(pkt);
1039 /* select current input stream component */
1042 if (!st->need_parsing || !st->parser) {
1043 /* no parsing needed: we just output the packet as is */
1044 /* raw data support */
1045 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1046 compute_pkt_fields(s, st, NULL, pkt);
1048 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1049 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1050 ff_reduce_index(s, st->index);
1051 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1054 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1055 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1056 st->cur_ptr, st->cur_len,
1057 st->cur_pkt.pts, st->cur_pkt.dts,
1059 st->cur_pkt.pts = AV_NOPTS_VALUE;
1060 st->cur_pkt.dts = AV_NOPTS_VALUE;
1061 /* increment read pointer */
1065 /* return packet if any */
1069 pkt->stream_index = st->index;
1070 pkt->pts = st->parser->pts;
1071 pkt->dts = st->parser->dts;
1072 pkt->pos = st->parser->pos;
1073 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1075 pkt->destruct= st->cur_pkt.destruct;
1076 st->cur_pkt.destruct= NULL;
1077 st->cur_pkt.data = NULL;
1078 assert(st->cur_len == 0);
1080 pkt->destruct = NULL;
1082 compute_pkt_fields(s, st, st->parser, pkt);
1084 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1085 ff_reduce_index(s, st->index);
1086 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1087 0, 0, AVINDEX_KEYFRAME);
1094 av_free_packet(&st->cur_pkt);
1099 /* read next packet */
1100 ret = av_read_packet(s, &cur_pkt);
1102 if (ret == AVERROR(EAGAIN))
1104 /* return the last frames, if any */
1105 for(i = 0; i < s->nb_streams; i++) {
1107 if (st->parser && st->need_parsing) {
1108 av_parser_parse2(st->parser, st->codec,
1109 &pkt->data, &pkt->size,
1111 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1117 /* no more packets: really terminate parsing */
1120 st = s->streams[cur_pkt.stream_index];
1121 st->cur_pkt= cur_pkt;
1123 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1124 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1125 st->cur_pkt.pts < st->cur_pkt.dts){
1126 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1127 st->cur_pkt.stream_index,
1131 // av_free_packet(&st->cur_pkt);
1135 if(s->debug & FF_FDEBUG_TS)
1136 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1137 st->cur_pkt.stream_index,
1141 st->cur_pkt.duration,
1145 st->cur_ptr = st->cur_pkt.data;
1146 st->cur_len = st->cur_pkt.size;
1147 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1148 st->parser = av_parser_init(st->codec->codec_id);
1150 /* no parser available: just output the raw packets */
1151 st->need_parsing = AVSTREAM_PARSE_NONE;
1152 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1153 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1154 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1155 st->parser->flags |= PARSER_FLAG_ONCE;
1160 if(s->debug & FF_FDEBUG_TS)
1161 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1172 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1176 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1179 pktl = s->packet_buffer;
1181 AVPacket *next_pkt= &pktl->pkt;
1183 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1184 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1185 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1186 if( pktl->pkt.stream_index == next_pkt->stream_index
1187 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1188 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1189 next_pkt->pts= pktl->pkt.dts;
1193 pktl = s->packet_buffer;
1196 if( next_pkt->pts != AV_NOPTS_VALUE
1197 || next_pkt->dts == AV_NOPTS_VALUE
1199 /* read packet from packet buffer, if there is data */
1201 s->packet_buffer = pktl->next;
1207 int ret= av_read_frame_internal(s, pkt);
1209 if(pktl && ret != AVERROR(EAGAIN)){
1216 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1217 &s->packet_buffer_end)) < 0)
1218 return AVERROR(ENOMEM);
1220 assert(!s->packet_buffer);
1221 return av_read_frame_internal(s, pkt);
1226 /* XXX: suppress the packet queue */
1227 static void flush_packet_queue(AVFormatContext *s)
1232 pktl = s->packet_buffer;
1235 s->packet_buffer = pktl->next;
1236 av_free_packet(&pktl->pkt);
1239 while(s->raw_packet_buffer){
1240 pktl = s->raw_packet_buffer;
1241 s->raw_packet_buffer = pktl->next;
1242 av_free_packet(&pktl->pkt);
1245 s->packet_buffer_end=
1246 s->raw_packet_buffer_end= NULL;
1247 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1250 /*******************************************************/
1253 int av_find_default_stream_index(AVFormatContext *s)
1255 int first_audio_index = -1;
1259 if (s->nb_streams <= 0)
1261 for(i = 0; i < s->nb_streams; i++) {
1263 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1266 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1267 first_audio_index = i;
1269 return first_audio_index >= 0 ? first_audio_index : 0;
1273 * Flush the frame reader.
1275 void ff_read_frame_flush(AVFormatContext *s)
1280 flush_packet_queue(s);
1284 /* for each stream, reset read state */
1285 for(i = 0; i < s->nb_streams; i++) {
1289 av_parser_close(st->parser);
1291 av_free_packet(&st->cur_pkt);
1293 st->last_IP_pts = AV_NOPTS_VALUE;
1294 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1295 st->reference_dts = AV_NOPTS_VALUE;
1300 st->probe_packets = MAX_PROBE_PACKETS;
1302 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1303 st->pts_buffer[j]= AV_NOPTS_VALUE;
1307 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1310 for(i = 0; i < s->nb_streams; i++) {
1311 AVStream *st = s->streams[i];
1313 st->cur_dts = av_rescale(timestamp,
1314 st->time_base.den * (int64_t)ref_st->time_base.num,
1315 st->time_base.num * (int64_t)ref_st->time_base.den);
1319 void ff_reduce_index(AVFormatContext *s, int stream_index)
1321 AVStream *st= s->streams[stream_index];
1322 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1324 if((unsigned)st->nb_index_entries >= max_entries){
1326 for(i=0; 2*i<st->nb_index_entries; i++)
1327 st->index_entries[i]= st->index_entries[2*i];
1328 st->nb_index_entries= i;
1332 int ff_add_index_entry(AVIndexEntry **index_entries,
1333 int *nb_index_entries,
1334 unsigned int *index_entries_allocated_size,
1335 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1337 AVIndexEntry *entries, *ie;
1340 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1343 entries = av_fast_realloc(*index_entries,
1344 index_entries_allocated_size,
1345 (*nb_index_entries + 1) *
1346 sizeof(AVIndexEntry));
1350 *index_entries= entries;
1352 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1355 index= (*nb_index_entries)++;
1356 ie= &entries[index];
1357 assert(index==0 || ie[-1].timestamp < timestamp);
1359 ie= &entries[index];
1360 if(ie->timestamp != timestamp){
1361 if(ie->timestamp <= timestamp)
1363 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1364 (*nb_index_entries)++;
1365 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1366 distance= ie->min_distance;
1370 ie->timestamp = timestamp;
1371 ie->min_distance= distance;
1378 int av_add_index_entry(AVStream *st,
1379 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1381 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1382 &st->index_entries_allocated_size, pos,
1383 timestamp, size, distance, flags);
1386 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1387 int64_t wanted_timestamp, int flags)
1395 //optimize appending index entries at the end
1396 if(b && entries[b-1].timestamp < wanted_timestamp)
1401 timestamp = entries[m].timestamp;
1402 if(timestamp >= wanted_timestamp)
1404 if(timestamp <= wanted_timestamp)
1407 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1409 if(!(flags & AVSEEK_FLAG_ANY)){
1410 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1411 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1420 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1423 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1424 wanted_timestamp, flags);
1429 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1430 AVInputFormat *avif= s->iformat;
1431 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1432 int64_t ts_min, ts_max, ts;
1437 if (stream_index < 0)
1441 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1445 ts_min= AV_NOPTS_VALUE;
1446 pos_limit= -1; //gcc falsely says it may be uninitialized
1448 st= s->streams[stream_index];
1449 if(st->index_entries){
1452 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()
1453 index= FFMAX(index, 0);
1454 e= &st->index_entries[index];
1456 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1458 ts_min= e->timestamp;
1460 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1467 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1468 assert(index < st->nb_index_entries);
1470 e= &st->index_entries[index];
1471 assert(e->timestamp >= target_ts);
1473 ts_max= e->timestamp;
1474 pos_limit= pos_max - e->min_distance;
1476 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1477 pos_max,pos_limit, ts_max);
1482 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1487 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1490 av_update_cur_dts(s, st, ts);
1495 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1497 int64_t start_pos, filesize;
1501 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1504 if(ts_min == AV_NOPTS_VALUE){
1505 pos_min = s->data_offset;
1506 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1507 if (ts_min == AV_NOPTS_VALUE)
1511 if(ts_max == AV_NOPTS_VALUE){
1513 filesize = avio_size(s->pb);
1514 pos_max = filesize - 1;
1517 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1519 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1520 if (ts_max == AV_NOPTS_VALUE)
1524 int64_t tmp_pos= pos_max + 1;
1525 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1526 if(tmp_ts == AV_NOPTS_VALUE)
1530 if(tmp_pos >= filesize)
1536 if(ts_min > ts_max){
1538 }else if(ts_min == ts_max){
1543 while (pos_min < pos_limit) {
1545 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1549 assert(pos_limit <= pos_max);
1552 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1553 // interpolate position (better than dichotomy)
1554 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1555 + pos_min - approximate_keyframe_distance;
1556 }else if(no_change==1){
1557 // bisection, if interpolation failed to change min or max pos last time
1558 pos = (pos_min + pos_limit)>>1;
1560 /* linear search if bisection failed, can only happen if there
1561 are very few or no keyframes between min/max */
1566 else if(pos > pos_limit)
1570 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1576 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1577 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1578 start_pos, no_change);
1580 if(ts == AV_NOPTS_VALUE){
1581 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1584 assert(ts != AV_NOPTS_VALUE);
1585 if (target_ts <= ts) {
1586 pos_limit = start_pos - 1;
1590 if (target_ts >= ts) {
1596 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1597 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1600 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1602 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1603 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1604 pos, ts_min, target_ts, ts_max);
1610 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1611 int64_t pos_min, pos_max;
1615 if (stream_index < 0)
1618 st= s->streams[stream_index];
1621 pos_min = s->data_offset;
1622 pos_max = avio_size(s->pb) - 1;
1624 if (pos < pos_min) pos= pos_min;
1625 else if(pos > pos_max) pos= pos_max;
1627 avio_seek(s->pb, pos, SEEK_SET);
1630 av_update_cur_dts(s, st, ts);
1635 static int av_seek_frame_generic(AVFormatContext *s,
1636 int stream_index, int64_t timestamp, int flags)
1643 st = s->streams[stream_index];
1645 index = av_index_search_timestamp(st, timestamp, flags);
1647 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1650 if(index < 0 || index==st->nb_index_entries-1){
1654 if(st->nb_index_entries){
1655 assert(st->index_entries);
1656 ie= &st->index_entries[st->nb_index_entries-1];
1657 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1659 av_update_cur_dts(s, st, ie->timestamp);
1661 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1667 ret = av_read_frame(s, &pkt);
1668 }while(ret == AVERROR(EAGAIN));
1671 av_free_packet(&pkt);
1672 if(stream_index == pkt.stream_index){
1673 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1677 index = av_index_search_timestamp(st, timestamp, flags);
1682 ff_read_frame_flush(s);
1683 if (s->iformat->read_seek){
1684 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1687 ie = &st->index_entries[index];
1688 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1690 av_update_cur_dts(s, st, ie->timestamp);
1695 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1700 ff_read_frame_flush(s);
1702 if(flags & AVSEEK_FLAG_BYTE)
1703 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1705 if(stream_index < 0){
1706 stream_index= av_find_default_stream_index(s);
1707 if(stream_index < 0)
1710 st= s->streams[stream_index];
1711 /* timestamp for default must be expressed in AV_TIME_BASE units */
1712 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1715 /* first, we try the format specific seek */
1716 if (s->iformat->read_seek)
1717 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1724 if(s->iformat->read_timestamp)
1725 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1727 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1730 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1732 if(min_ts > ts || max_ts < ts)
1735 ff_read_frame_flush(s);
1737 if (s->iformat->read_seek2)
1738 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1740 if(s->iformat->read_timestamp){
1741 //try to seek via read_timestamp()
1744 //Fallback to old API if new is not implemented but old is
1745 //Note the old has somewat different sematics
1746 if(s->iformat->read_seek || 1)
1747 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1749 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1752 /*******************************************************/
1755 * Return TRUE if the stream has accurate duration in any stream.
1757 * @return TRUE if the stream has accurate duration for at least one component.
1759 static int av_has_duration(AVFormatContext *ic)
1764 for(i = 0;i < ic->nb_streams; i++) {
1765 st = ic->streams[i];
1766 if (st->duration != AV_NOPTS_VALUE)
1773 * Estimate the stream timings from the one of each components.
1775 * Also computes the global bitrate if possible.
1777 static void av_update_stream_timings(AVFormatContext *ic)
1779 int64_t start_time, start_time1, end_time, end_time1;
1780 int64_t duration, duration1;
1784 start_time = INT64_MAX;
1785 end_time = INT64_MIN;
1786 duration = INT64_MIN;
1787 for(i = 0;i < ic->nb_streams; i++) {
1788 st = ic->streams[i];
1789 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1790 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1791 if (start_time1 < start_time)
1792 start_time = start_time1;
1793 if (st->duration != AV_NOPTS_VALUE) {
1794 end_time1 = start_time1
1795 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1796 if (end_time1 > end_time)
1797 end_time = end_time1;
1800 if (st->duration != AV_NOPTS_VALUE) {
1801 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1802 if (duration1 > duration)
1803 duration = duration1;
1806 if (start_time != INT64_MAX) {
1807 ic->start_time = start_time;
1808 if (end_time != INT64_MIN) {
1809 if (end_time - start_time > duration)
1810 duration = end_time - start_time;
1813 if (duration != INT64_MIN) {
1814 ic->duration = duration;
1815 if (ic->file_size > 0) {
1816 /* compute the bitrate */
1817 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1818 (double)ic->duration;
1823 static void fill_all_stream_timings(AVFormatContext *ic)
1828 av_update_stream_timings(ic);
1829 for(i = 0;i < ic->nb_streams; i++) {
1830 st = ic->streams[i];
1831 if (st->start_time == AV_NOPTS_VALUE) {
1832 if(ic->start_time != AV_NOPTS_VALUE)
1833 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1834 if(ic->duration != AV_NOPTS_VALUE)
1835 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1840 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1842 int64_t filesize, duration;
1846 /* if bit_rate is already set, we believe it */
1847 if (ic->bit_rate <= 0) {
1849 for(i=0;i<ic->nb_streams;i++) {
1850 st = ic->streams[i];
1851 if (st->codec->bit_rate > 0)
1852 bit_rate += st->codec->bit_rate;
1854 ic->bit_rate = bit_rate;
1857 /* if duration is already set, we believe it */
1858 if (ic->duration == AV_NOPTS_VALUE &&
1859 ic->bit_rate != 0 &&
1860 ic->file_size != 0) {
1861 filesize = ic->file_size;
1863 for(i = 0; i < ic->nb_streams; i++) {
1864 st = ic->streams[i];
1865 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1866 if (st->duration == AV_NOPTS_VALUE)
1867 st->duration = duration;
1873 #define DURATION_MAX_READ_SIZE 250000
1874 #define DURATION_MAX_RETRY 3
1876 /* only usable for MPEG-PS streams */
1877 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1879 AVPacket pkt1, *pkt = &pkt1;
1881 int read_size, i, ret;
1883 int64_t filesize, offset, duration;
1888 /* flush packet queue */
1889 flush_packet_queue(ic);
1891 for (i=0; i<ic->nb_streams; i++) {
1892 st = ic->streams[i];
1893 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1894 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1897 av_parser_close(st->parser);
1899 av_free_packet(&st->cur_pkt);
1903 /* estimate the end time (duration) */
1904 /* XXX: may need to support wrapping */
1905 filesize = ic->file_size;
1906 end_time = AV_NOPTS_VALUE;
1908 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1912 avio_seek(ic->pb, offset, SEEK_SET);
1915 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1919 ret = av_read_packet(ic, pkt);
1920 }while(ret == AVERROR(EAGAIN));
1923 read_size += pkt->size;
1924 st = ic->streams[pkt->stream_index];
1925 if (pkt->pts != AV_NOPTS_VALUE &&
1926 (st->start_time != AV_NOPTS_VALUE ||
1927 st->first_dts != AV_NOPTS_VALUE)) {
1928 duration = end_time = pkt->pts;
1929 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1930 else duration -= st->first_dts;
1932 duration += 1LL<<st->pts_wrap_bits;
1934 if (st->duration == AV_NOPTS_VALUE ||
1935 st->duration < duration)
1936 st->duration = duration;
1939 av_free_packet(pkt);
1941 }while( end_time==AV_NOPTS_VALUE
1942 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1943 && ++retry <= DURATION_MAX_RETRY);
1945 fill_all_stream_timings(ic);
1947 avio_seek(ic->pb, old_offset, SEEK_SET);
1948 for (i=0; i<ic->nb_streams; i++) {
1950 st->cur_dts= st->first_dts;
1951 st->last_IP_pts = AV_NOPTS_VALUE;
1952 st->reference_dts = AV_NOPTS_VALUE;
1956 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1960 /* get the file size, if possible */
1961 if (ic->iformat->flags & AVFMT_NOFILE) {
1964 file_size = avio_size(ic->pb);
1968 ic->file_size = file_size;
1970 if ((!strcmp(ic->iformat->name, "mpeg") ||
1971 !strcmp(ic->iformat->name, "mpegts")) &&
1972 file_size && ic->pb->seekable) {
1973 /* get accurate estimate from the PTSes */
1974 av_estimate_timings_from_pts(ic, old_offset);
1975 } else if (av_has_duration(ic)) {
1976 /* at least one component has timings - we use them for all
1978 fill_all_stream_timings(ic);
1980 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1981 /* less precise: use bitrate info */
1982 av_estimate_timings_from_bit_rate(ic);
1984 av_update_stream_timings(ic);
1990 for(i = 0;i < ic->nb_streams; i++) {
1991 st = ic->streams[i];
1992 printf("%d: start_time: %0.3f duration: %0.3f\n",
1993 i, (double)st->start_time / AV_TIME_BASE,
1994 (double)st->duration / AV_TIME_BASE);
1996 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1997 (double)ic->start_time / AV_TIME_BASE,
1998 (double)ic->duration / AV_TIME_BASE,
1999 ic->bit_rate / 1000);
2004 static int has_codec_parameters(AVCodecContext *enc)
2007 switch(enc->codec_type) {
2008 case AVMEDIA_TYPE_AUDIO:
2009 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2010 if(!enc->frame_size &&
2011 (enc->codec_id == CODEC_ID_VORBIS ||
2012 enc->codec_id == CODEC_ID_AAC ||
2013 enc->codec_id == CODEC_ID_MP1 ||
2014 enc->codec_id == CODEC_ID_MP2 ||
2015 enc->codec_id == CODEC_ID_MP3 ||
2016 enc->codec_id == CODEC_ID_SPEEX ||
2017 enc->codec_id == CODEC_ID_CELT))
2020 case AVMEDIA_TYPE_VIDEO:
2021 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2027 return enc->codec_id != CODEC_ID_NONE && val != 0;
2030 static int has_decode_delay_been_guessed(AVStream *st)
2032 return st->codec->codec_id != CODEC_ID_H264 ||
2033 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2036 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2040 int got_picture, data_size, ret=0;
2043 if(!st->codec->codec){
2044 codec = avcodec_find_decoder(st->codec->codec_id);
2047 ret = avcodec_open(st->codec, codec);
2052 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2053 switch(st->codec->codec_type) {
2054 case AVMEDIA_TYPE_VIDEO:
2055 avcodec_get_frame_defaults(&picture);
2056 ret = avcodec_decode_video2(st->codec, &picture,
2057 &got_picture, avpkt);
2059 case AVMEDIA_TYPE_AUDIO:
2060 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2061 samples = av_malloc(data_size);
2064 ret = avcodec_decode_audio3(st->codec, samples,
2076 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2078 while (tags->id != CODEC_ID_NONE) {
2086 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2089 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2090 if(tag == tags[i].tag)
2093 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2094 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2097 return CODEC_ID_NONE;
2100 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2103 for(i=0; tags && tags[i]; i++){
2104 int tag= ff_codec_get_tag(tags[i], id);
2110 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2113 for(i=0; tags && tags[i]; i++){
2114 enum CodecID id= ff_codec_get_id(tags[i], tag);
2115 if(id!=CODEC_ID_NONE) return id;
2117 return CODEC_ID_NONE;
2120 static void compute_chapters_end(AVFormatContext *s)
2123 int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2125 for (i = 0; i < s->nb_chapters; i++)
2126 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2127 AVChapter *ch = s->chapters[i];
2128 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2131 for (j = 0; j < s->nb_chapters; j++) {
2132 AVChapter *ch1 = s->chapters[j];
2133 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2134 if (j != i && next_start > ch->start && next_start < end)
2137 ch->end = (end == INT64_MAX) ? ch->start : end;
2141 static int get_std_framerate(int i){
2142 if(i<60*12) return i*1001;
2143 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2147 * Is the time base unreliable.
2148 * This is a heuristic to balance between quick acceptance of the values in
2149 * the headers vs. some extra checks.
2150 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2151 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2152 * And there are "variable" fps files this needs to detect as well.
2154 static int tb_unreliable(AVCodecContext *c){
2155 if( c->time_base.den >= 101L*c->time_base.num
2156 || c->time_base.den < 5L*c->time_base.num
2157 /* || c->codec_tag == AV_RL32("DIVX")
2158 || c->codec_tag == AV_RL32("XVID")*/
2159 || c->codec_id == CODEC_ID_MPEG2VIDEO
2160 || c->codec_id == CODEC_ID_H264
2166 int av_find_stream_info(AVFormatContext *ic)
2168 int i, count, ret, read_size, j;
2170 AVPacket pkt1, *pkt;
2171 int64_t old_offset = avio_tell(ic->pb);
2173 for(i=0;i<ic->nb_streams;i++) {
2175 st = ic->streams[i];
2176 if (st->codec->codec_id == CODEC_ID_AAC) {
2177 st->codec->sample_rate = 0;
2178 st->codec->frame_size = 0;
2179 st->codec->channels = 0;
2181 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2182 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2183 /* if(!st->time_base.num)
2185 if(!st->codec->time_base.num)
2186 st->codec->time_base= st->time_base;
2188 //only for the split stuff
2189 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2190 st->parser = av_parser_init(st->codec->codec_id);
2191 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2192 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2195 assert(!st->codec->codec);
2196 codec = avcodec_find_decoder(st->codec->codec_id);
2198 /* Force decoding of at least one frame of codec data
2199 * this makes sure the codec initializes the channel configuration
2200 * and does not trust the values from the container.
2202 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2203 st->codec->channels = 0;
2205 /* Ensure that subtitle_header is properly set. */
2206 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2207 && codec && !st->codec->codec)
2208 avcodec_open(st->codec, codec);
2210 //try to just open decoders, in case this is enough to get parameters
2211 if(!has_codec_parameters(st->codec)){
2212 if (codec && !st->codec->codec)
2213 avcodec_open(st->codec, codec);
2217 for (i=0; i<ic->nb_streams; i++) {
2218 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2224 if(url_interrupt_cb()){
2226 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2230 /* check if one codec still needs to be handled */
2231 for(i=0;i<ic->nb_streams;i++) {
2232 int fps_analyze_framecount = 20;
2234 st = ic->streams[i];
2235 if (!has_codec_parameters(st->codec))
2237 /* if the timebase is coarse (like the usual millisecond precision
2238 of mkv), we need to analyze more frames to reliably arrive at
2240 if (av_q2d(st->time_base) > 0.0005)
2241 fps_analyze_framecount *= 2;
2242 /* variable fps and no guess at the real fps */
2243 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2244 && st->info->duration_count < fps_analyze_framecount
2245 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2247 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2249 if(st->first_dts == AV_NOPTS_VALUE)
2252 if (i == ic->nb_streams) {
2253 /* NOTE: if the format has no header, then we need to read
2254 some packets to get most of the streams, so we cannot
2256 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2257 /* if we found the info for all the codecs, we can stop */
2259 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2263 /* we did not get all the codec info, but we read too much data */
2264 if (read_size >= ic->probesize) {
2266 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2270 /* NOTE: a new stream can be added there if no header in file
2271 (AVFMTCTX_NOHEADER) */
2272 ret = av_read_frame_internal(ic, &pkt1);
2273 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2275 ret = -1; /* we could not have all the codec parameters before EOF */
2276 for(i=0;i<ic->nb_streams;i++) {
2277 st = ic->streams[i];
2278 if (!has_codec_parameters(st->codec)){
2280 avcodec_string(buf, sizeof(buf), st->codec, 0);
2281 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2289 if (ret == AVERROR(EAGAIN))
2292 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2293 if ((ret = av_dup_packet(pkt)) < 0)
2294 goto find_stream_info_err;
2296 read_size += pkt->size;
2298 st = ic->streams[pkt->stream_index];
2299 if (st->codec_info_nb_frames>1) {
2300 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2301 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2304 st->info->codec_info_duration += pkt->duration;
2307 int64_t last = st->info->last_dts;
2308 int64_t duration= pkt->dts - last;
2310 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2311 double dur= duration * av_q2d(st->time_base);
2313 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2314 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2315 if (st->info->duration_count < 2)
2316 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2317 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2318 int framerate= get_std_framerate(i);
2319 int ticks= lrintf(dur*framerate/(1001*12));
2320 double error= dur - ticks*1001*12/(double)framerate;
2321 st->info->duration_error[i] += error*error;
2323 st->info->duration_count++;
2324 // ignore the first 4 values, they might have some random jitter
2325 if (st->info->duration_count > 3)
2326 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2328 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2329 st->info->last_dts = pkt->dts;
2331 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2332 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2334 st->codec->extradata_size= i;
2335 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2336 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2337 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2341 /* if still no information, we try to open the codec and to
2342 decompress the frame. We try to avoid that in most cases as
2343 it takes longer and uses more memory. For MPEG-4, we need to
2344 decompress for QuickTime. */
2345 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2346 try_decode_frame(st, pkt);
2348 st->codec_info_nb_frames++;
2352 // close codecs which were opened in try_decode_frame()
2353 for(i=0;i<ic->nb_streams;i++) {
2354 st = ic->streams[i];
2355 if(st->codec->codec)
2356 avcodec_close(st->codec);
2358 for(i=0;i<ic->nb_streams;i++) {
2359 st = ic->streams[i];
2360 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2361 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2362 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2363 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2364 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2365 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2366 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2367 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2368 st->codec->codec_tag= tag;
2371 // the check for tb_unreliable() is not completely correct, since this is not about handling
2372 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2373 // ipmovie.c produces.
2374 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)
2375 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);
2376 if (st->info->duration_count && !st->r_frame_rate.num
2377 && tb_unreliable(st->codec) /*&&
2378 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2379 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2381 double best_error= 2*av_q2d(st->time_base);
2382 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2384 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2385 double error = st->info->duration_error[j] * get_std_framerate(j);
2386 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2387 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2388 if(error < best_error){
2390 num = get_std_framerate(j);
2393 // do not increase frame rate by more than 1 % in order to match a standard rate.
2394 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2395 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2398 if (!st->r_frame_rate.num){
2399 if( st->codec->time_base.den * (int64_t)st->time_base.num
2400 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2401 st->r_frame_rate.num = st->codec->time_base.den;
2402 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2404 st->r_frame_rate.num = st->time_base.den;
2405 st->r_frame_rate.den = st->time_base.num;
2408 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2409 if(!st->codec->bits_per_coded_sample)
2410 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2411 // set stream disposition based on audio service type
2412 switch (st->codec->audio_service_type) {
2413 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2414 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2415 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2416 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2417 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2418 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2419 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2420 st->disposition = AV_DISPOSITION_COMMENT; break;
2421 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2422 st->disposition = AV_DISPOSITION_KARAOKE; break;
2427 av_estimate_timings(ic, old_offset);
2429 compute_chapters_end(ic);
2432 /* correct DTS for B-frame streams with no timestamps */
2433 for(i=0;i<ic->nb_streams;i++) {
2434 st = ic->streams[i];
2435 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2437 ppktl = &ic->packet_buffer;
2439 if(ppkt1->stream_index != i)
2441 if(ppkt1->pkt->dts < 0)
2443 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2445 ppkt1->pkt->dts -= delta;
2450 st->cur_dts -= delta;
2456 find_stream_info_err:
2457 for (i=0; i < ic->nb_streams; i++)
2458 av_freep(&ic->streams[i]->info);
2462 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2466 for (i = 0; i < ic->nb_programs; i++)
2467 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2468 if (ic->programs[i]->stream_index[j] == s)
2469 return ic->programs[i];
2473 int av_find_best_stream(AVFormatContext *ic,
2474 enum AVMediaType type,
2475 int wanted_stream_nb,
2477 AVCodec **decoder_ret,
2480 int i, nb_streams = ic->nb_streams;
2481 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2482 unsigned *program = NULL;
2483 AVCodec *decoder = NULL, *best_decoder = NULL;
2485 if (related_stream >= 0 && wanted_stream_nb < 0) {
2486 AVProgram *p = find_program_from_stream(ic, related_stream);
2488 program = p->stream_index;
2489 nb_streams = p->nb_stream_indexes;
2492 for (i = 0; i < nb_streams; i++) {
2493 int real_stream_index = program ? program[i] : i;
2494 AVStream *st = ic->streams[real_stream_index];
2495 AVCodecContext *avctx = st->codec;
2496 if (avctx->codec_type != type)
2498 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2500 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2503 decoder = avcodec_find_decoder(st->codec->codec_id);
2506 ret = AVERROR_DECODER_NOT_FOUND;
2510 if (best_count >= st->codec_info_nb_frames)
2512 best_count = st->codec_info_nb_frames;
2513 ret = real_stream_index;
2514 best_decoder = decoder;
2515 if (program && i == nb_streams - 1 && ret < 0) {
2517 nb_streams = ic->nb_streams;
2518 i = 0; /* no related stream found, try again with everything */
2522 *decoder_ret = best_decoder;
2526 /*******************************************************/
2528 int av_read_play(AVFormatContext *s)
2530 if (s->iformat->read_play)
2531 return s->iformat->read_play(s);
2533 return avio_pause(s->pb, 0);
2534 return AVERROR(ENOSYS);
2537 int av_read_pause(AVFormatContext *s)
2539 if (s->iformat->read_pause)
2540 return s->iformat->read_pause(s);
2542 return avio_pause(s->pb, 1);
2543 return AVERROR(ENOSYS);
2546 void av_close_input_stream(AVFormatContext *s)
2548 flush_packet_queue(s);
2549 if (s->iformat->read_close)
2550 s->iformat->read_close(s);
2551 avformat_free_context(s);
2554 void avformat_free_context(AVFormatContext *s)
2559 for(i=0;i<s->nb_streams;i++) {
2560 /* free all data in a stream component */
2563 av_parser_close(st->parser);
2564 av_free_packet(&st->cur_pkt);
2566 av_metadata_free(&st->metadata);
2567 av_free(st->index_entries);
2568 av_free(st->codec->extradata);
2569 av_free(st->codec->subtitle_header);
2571 av_free(st->priv_data);
2575 for(i=s->nb_programs-1; i>=0; i--) {
2576 av_metadata_free(&s->programs[i]->metadata);
2577 av_freep(&s->programs[i]->stream_index);
2578 av_freep(&s->programs[i]);
2580 av_freep(&s->programs);
2581 av_freep(&s->priv_data);
2582 while(s->nb_chapters--) {
2583 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2584 av_free(s->chapters[s->nb_chapters]);
2586 av_freep(&s->chapters);
2587 av_metadata_free(&s->metadata);
2589 av_freep(&s->streams);
2593 void av_close_input_file(AVFormatContext *s)
2595 AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2596 av_close_input_stream(s);
2601 AVStream *av_new_stream(AVFormatContext *s, int id)
2607 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2609 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2612 s->streams = streams;
2614 st = av_mallocz(sizeof(AVStream));
2617 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2622 st->codec= avcodec_alloc_context();
2624 /* no default bitrate if decoding */
2625 st->codec->bit_rate = 0;
2627 st->index = s->nb_streams;
2629 st->start_time = AV_NOPTS_VALUE;
2630 st->duration = AV_NOPTS_VALUE;
2631 /* we set the current DTS to 0 so that formats without any timestamps
2632 but durations get some timestamps, formats with some unknown
2633 timestamps have their first few packets buffered and the
2634 timestamps corrected before they are returned to the user */
2636 st->first_dts = AV_NOPTS_VALUE;
2637 st->probe_packets = MAX_PROBE_PACKETS;
2639 /* default pts setting is MPEG-like */
2640 av_set_pts_info(st, 33, 1, 90000);
2641 st->last_IP_pts = AV_NOPTS_VALUE;
2642 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2643 st->pts_buffer[i]= AV_NOPTS_VALUE;
2644 st->reference_dts = AV_NOPTS_VALUE;
2646 st->sample_aspect_ratio = (AVRational){0,1};
2648 s->streams[s->nb_streams++] = st;
2652 AVProgram *av_new_program(AVFormatContext *ac, int id)
2654 AVProgram *program=NULL;
2658 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2661 for(i=0; i<ac->nb_programs; i++)
2662 if(ac->programs[i]->id == id)
2663 program = ac->programs[i];
2666 program = av_mallocz(sizeof(AVProgram));
2669 dynarray_add(&ac->programs, &ac->nb_programs, program);
2670 program->discard = AVDISCARD_NONE;
2677 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2679 AVChapter *chapter = NULL;
2682 for(i=0; i<s->nb_chapters; i++)
2683 if(s->chapters[i]->id == id)
2684 chapter = s->chapters[i];
2687 chapter= av_mallocz(sizeof(AVChapter));
2690 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2692 av_metadata_set2(&chapter->metadata, "title", title, 0);
2694 chapter->time_base= time_base;
2695 chapter->start = start;
2701 /************************************************************/
2702 /* output media file */
2704 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2708 if (s->oformat->priv_data_size > 0) {
2709 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2711 return AVERROR(ENOMEM);
2712 if (s->oformat->priv_class) {
2713 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2714 av_opt_set_defaults(s->priv_data);
2717 s->priv_data = NULL;
2719 if (s->oformat->set_parameters) {
2720 ret = s->oformat->set_parameters(s, ap);
2727 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2729 const AVCodecTag *avctag;
2731 enum CodecID id = CODEC_ID_NONE;
2732 unsigned int tag = 0;
2735 * Check that tag + id is in the table
2736 * If neither is in the table -> OK
2737 * If tag is in the table with another id -> FAIL
2738 * If id is in the table with another tag -> FAIL unless strict < normal
2740 for (n = 0; s->oformat->codec_tag[n]; n++) {
2741 avctag = s->oformat->codec_tag[n];
2742 while (avctag->id != CODEC_ID_NONE) {
2743 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2745 if (id == st->codec->codec_id)
2748 if (avctag->id == st->codec->codec_id)
2753 if (id != CODEC_ID_NONE)
2755 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2760 int av_write_header(AVFormatContext *s)
2765 // some sanity checks
2766 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2767 av_log(s, AV_LOG_ERROR, "no streams\n");
2768 return AVERROR(EINVAL);
2771 for(i=0;i<s->nb_streams;i++) {
2774 switch (st->codec->codec_type) {
2775 case AVMEDIA_TYPE_AUDIO:
2776 if(st->codec->sample_rate<=0){
2777 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2778 return AVERROR(EINVAL);
2780 if(!st->codec->block_align)
2781 st->codec->block_align = st->codec->channels *
2782 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2784 case AVMEDIA_TYPE_VIDEO:
2785 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2786 av_log(s, AV_LOG_ERROR, "time base not set\n");
2787 return AVERROR(EINVAL);
2789 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2790 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2791 return AVERROR(EINVAL);
2793 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2794 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2795 return AVERROR(EINVAL);
2800 if(s->oformat->codec_tag){
2801 if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2802 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2803 st->codec->codec_tag= 0;
2805 if(st->codec->codec_tag){
2806 if (!validate_codec_tag(s, st)) {
2808 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2809 av_log(s, AV_LOG_ERROR,
2810 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2811 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2812 return AVERROR_INVALIDDATA;
2815 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2818 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2819 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2820 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2823 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2824 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2826 return AVERROR(ENOMEM);
2829 /* set muxer identification string */
2830 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2831 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2834 if(s->oformat->write_header){
2835 ret = s->oformat->write_header(s);
2840 /* init PTS generation */
2841 for(i=0;i<s->nb_streams;i++) {
2842 int64_t den = AV_NOPTS_VALUE;
2845 switch (st->codec->codec_type) {
2846 case AVMEDIA_TYPE_AUDIO:
2847 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2849 case AVMEDIA_TYPE_VIDEO:
2850 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2855 if (den != AV_NOPTS_VALUE) {
2857 return AVERROR_INVALIDDATA;
2858 av_frac_init(&st->pts, 0, 0, den);
2864 //FIXME merge with compute_pkt_fields
2865 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2866 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2867 int num, den, frame_size, i;
2869 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2870 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2872 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2873 return AVERROR(EINVAL);*/
2875 /* duration field */
2876 if (pkt->duration == 0) {
2877 compute_frame_duration(&num, &den, st, NULL, pkt);
2879 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2883 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2886 //XXX/FIXME this is a temporary hack until all encoders output pts
2887 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2889 // pkt->pts= st->cur_dts;
2890 pkt->pts= st->pts.val;
2893 //calculate dts from pts
2894 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2895 st->pts_buffer[0]= pkt->pts;
2896 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2897 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2898 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2899 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2901 pkt->dts= st->pts_buffer[0];
2904 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2905 av_log(s, AV_LOG_ERROR,
2906 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2907 st->index, st->cur_dts, pkt->dts);
2908 return AVERROR(EINVAL);
2910 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2911 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2912 return AVERROR(EINVAL);
2915 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2916 st->cur_dts= pkt->dts;
2917 st->pts.val= pkt->dts;
2920 switch (st->codec->codec_type) {
2921 case AVMEDIA_TYPE_AUDIO:
2922 frame_size = get_audio_frame_size(st->codec, pkt->size);
2924 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2925 likely equal to the encoder delay, but it would be better if we
2926 had the real timestamps from the encoder */
2927 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2928 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2931 case AVMEDIA_TYPE_VIDEO:
2932 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2940 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2942 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2944 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2947 ret= s->oformat->write_packet(s, pkt);
2949 ret= url_ferror(s->pb);
2953 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2954 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2956 AVPacketList **next_point, *this_pktl;
2958 this_pktl = av_mallocz(sizeof(AVPacketList));
2959 this_pktl->pkt= *pkt;
2960 pkt->destruct= NULL; // do not free original but only the copy
2961 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2963 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2964 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2966 next_point = &s->packet_buffer;
2969 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2970 while(!compare(s, &(*next_point)->pkt, pkt)){
2971 next_point= &(*next_point)->next;
2975 next_point = &(s->packet_buffer_end->next);
2978 assert(!*next_point);
2980 s->packet_buffer_end= this_pktl;
2983 this_pktl->next= *next_point;
2985 s->streams[pkt->stream_index]->last_in_packet_buffer=
2986 *next_point= this_pktl;
2989 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2991 AVStream *st = s->streams[ pkt ->stream_index];
2992 AVStream *st2= s->streams[ next->stream_index];
2993 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2994 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2995 int64_t dts1 = av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN);
2996 if (dts1==next->dts && dts1==av_rescale_rnd(pkt->dts, b, a, AV_ROUND_UP))
2997 return pkt->stream_index < next->stream_index;
2998 return dts1 < next->dts;
3001 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3007 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3010 for(i=0; i < s->nb_streams; i++)
3011 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3013 if(stream_count && (s->nb_streams == stream_count || flush)){
3014 pktl= s->packet_buffer;
3017 s->packet_buffer= pktl->next;
3018 if(!s->packet_buffer)
3019 s->packet_buffer_end= NULL;
3021 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3022 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3026 av_init_packet(out);
3032 * Interleave an AVPacket correctly so it can be muxed.
3033 * @param out the interleaved packet will be output here
3034 * @param in the input packet
3035 * @param flush 1 if no further packets are available as input and all
3036 * remaining packets should be output
3037 * @return 1 if a packet was output, 0 if no packet could be output,
3038 * < 0 if an error occurred
3040 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3041 if(s->oformat->interleave_packet)
3042 return s->oformat->interleave_packet(s, out, in, flush);
3044 return av_interleave_packet_per_dts(s, out, in, flush);
3047 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3048 AVStream *st= s->streams[ pkt->stream_index];
3051 //FIXME/XXX/HACK drop zero sized packets
3052 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3055 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3056 pkt->size, pkt->dts, pkt->pts);
3057 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3060 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3061 return AVERROR(EINVAL);
3065 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3066 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3069 ret= s->oformat->write_packet(s, &opkt);
3071 av_free_packet(&opkt);
3076 if(url_ferror(s->pb))
3077 return url_ferror(s->pb);
3081 int av_write_trailer(AVFormatContext *s)
3087 ret= av_interleave_packet(s, &pkt, NULL, 1);
3088 if(ret<0) //FIXME cleanup needed for ret<0 ?
3093 ret= s->oformat->write_packet(s, &pkt);
3095 av_free_packet(&pkt);
3099 if(url_ferror(s->pb))
3103 if(s->oformat->write_trailer)
3104 ret = s->oformat->write_trailer(s);
3107 ret=url_ferror(s->pb);
3108 for(i=0;i<s->nb_streams;i++) {
3109 av_freep(&s->streams[i]->priv_data);
3110 av_freep(&s->streams[i]->index_entries);
3112 av_freep(&s->priv_data);
3116 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3119 AVProgram *program=NULL;
3122 if (idx >= ac->nb_streams) {
3123 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3127 for(i=0; i<ac->nb_programs; i++){
3128 if(ac->programs[i]->id != progid)
3130 program = ac->programs[i];
3131 for(j=0; j<program->nb_stream_indexes; j++)
3132 if(program->stream_index[j] == idx)
3135 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3138 program->stream_index = tmp;
3139 program->stream_index[program->nb_stream_indexes++] = idx;
3144 static void print_fps(double d, const char *postfix){
3145 uint64_t v= lrintf(d*100);
3146 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3147 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3148 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3151 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3153 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3154 AVMetadataTag *tag=NULL;
3156 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3157 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3158 if(strcmp("language", tag->key))
3159 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3164 /* "user interface" functions */
3165 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3168 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3169 AVStream *st = ic->streams[i];
3170 int g = av_gcd(st->time_base.num, st->time_base.den);
3171 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3172 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3173 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3174 /* the pid is an important information, so we display it */
3175 /* XXX: add a generic system */
3176 if (flags & AVFMT_SHOW_IDS)
3177 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3179 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3180 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3181 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3182 if (st->sample_aspect_ratio.num && // default
3183 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3184 AVRational display_aspect_ratio;
3185 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3186 st->codec->width*st->sample_aspect_ratio.num,
3187 st->codec->height*st->sample_aspect_ratio.den,
3189 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3190 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3191 display_aspect_ratio.num, display_aspect_ratio.den);
3193 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3194 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3195 print_fps(av_q2d(st->avg_frame_rate), "fps");
3196 if(st->r_frame_rate.den && st->r_frame_rate.num)
3197 print_fps(av_q2d(st->r_frame_rate), "tbr");
3198 if(st->time_base.den && st->time_base.num)
3199 print_fps(1/av_q2d(st->time_base), "tbn");
3200 if(st->codec->time_base.den && st->codec->time_base.num)
3201 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3203 if (st->disposition & AV_DISPOSITION_DEFAULT)
3204 av_log(NULL, AV_LOG_INFO, " (default)");
3205 if (st->disposition & AV_DISPOSITION_DUB)
3206 av_log(NULL, AV_LOG_INFO, " (dub)");
3207 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3208 av_log(NULL, AV_LOG_INFO, " (original)");
3209 if (st->disposition & AV_DISPOSITION_COMMENT)
3210 av_log(NULL, AV_LOG_INFO, " (comment)");
3211 if (st->disposition & AV_DISPOSITION_LYRICS)
3212 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3213 if (st->disposition & AV_DISPOSITION_KARAOKE)
3214 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3215 if (st->disposition & AV_DISPOSITION_FORCED)
3216 av_log(NULL, AV_LOG_INFO, " (forced)");
3217 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3218 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3219 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3220 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3221 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3222 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3223 av_log(NULL, AV_LOG_INFO, "\n");
3224 dump_metadata(NULL, st->metadata, " ");
3227 #if FF_API_DUMP_FORMAT
3228 void dump_format(AVFormatContext *ic,
3233 av_dump_format(ic, index, url, is_output);
3237 void av_dump_format(AVFormatContext *ic,
3243 uint8_t *printed = av_mallocz(ic->nb_streams);
3244 if (ic->nb_streams && !printed)
3247 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3248 is_output ? "Output" : "Input",
3250 is_output ? ic->oformat->name : ic->iformat->name,
3251 is_output ? "to" : "from", url);
3252 dump_metadata(NULL, ic->metadata, " ");
3254 av_log(NULL, AV_LOG_INFO, " Duration: ");
3255 if (ic->duration != AV_NOPTS_VALUE) {
3256 int hours, mins, secs, us;
3257 secs = ic->duration / AV_TIME_BASE;
3258 us = ic->duration % AV_TIME_BASE;
3263 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3264 (100 * us) / AV_TIME_BASE);
3266 av_log(NULL, AV_LOG_INFO, "N/A");
3268 if (ic->start_time != AV_NOPTS_VALUE) {
3270 av_log(NULL, AV_LOG_INFO, ", start: ");
3271 secs = ic->start_time / AV_TIME_BASE;
3272 us = abs(ic->start_time % AV_TIME_BASE);
3273 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3274 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3276 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3278 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3280 av_log(NULL, AV_LOG_INFO, "N/A");
3282 av_log(NULL, AV_LOG_INFO, "\n");
3284 for (i = 0; i < ic->nb_chapters; i++) {
3285 AVChapter *ch = ic->chapters[i];
3286 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3287 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3288 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3290 dump_metadata(NULL, ch->metadata, " ");
3292 if(ic->nb_programs) {
3293 int j, k, total = 0;
3294 for(j=0; j<ic->nb_programs; j++) {
3295 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3297 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3298 name ? name->value : "");
3299 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3300 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3301 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3302 printed[ic->programs[j]->stream_index[k]] = 1;
3304 total += ic->programs[j]->nb_stream_indexes;
3306 if (total < ic->nb_streams)
3307 av_log(NULL, AV_LOG_INFO, " No Program\n");
3309 for(i=0;i<ic->nb_streams;i++)
3311 dump_stream_format(ic, i, index, is_output);
3316 int64_t av_gettime(void)
3319 gettimeofday(&tv,NULL);
3320 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3323 uint64_t ff_ntp_time(void)
3325 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3328 #if FF_API_PARSE_DATE
3329 #include "libavutil/parseutils.h"
3331 int64_t parse_date(const char *timestr, int duration)
3334 av_parse_time(&timeval, timestr, duration);
3339 #if FF_API_FIND_INFO_TAG
3340 #include "libavutil/parseutils.h"
3342 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3344 return av_find_info_tag(arg, arg_size, tag1, info);
3348 int av_get_frame_filename(char *buf, int buf_size,
3349 const char *path, int number)
3352 char *q, buf1[20], c;
3353 int nd, len, percentd_found;
3365 while (isdigit(*p)) {
3366 nd = nd * 10 + *p++ - '0';
3369 } while (isdigit(c));
3378 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3380 if ((q - buf + len) > buf_size - 1)
3382 memcpy(q, buf1, len);
3390 if ((q - buf) < buf_size - 1)
3394 if (!percentd_found)
3403 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3407 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3409 for(i=0;i<size;i+=16) {
3416 PRINT(" %02x", buf[i+j]);
3421 for(j=0;j<len;j++) {
3423 if (c < ' ' || c > '~')
3432 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3434 hex_dump_internal(NULL, f, 0, buf, size);
3437 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3439 hex_dump_internal(avcl, NULL, level, buf, size);
3442 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3445 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3446 PRINT("stream #%d:\n", pkt->stream_index);
3447 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3448 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3449 /* DTS is _always_ valid after av_read_frame() */
3451 if (pkt->dts == AV_NOPTS_VALUE)
3454 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3455 /* PTS may not be known if B-frames are present. */
3457 if (pkt->pts == AV_NOPTS_VALUE)
3460 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3462 PRINT(" size=%d\n", pkt->size);
3465 av_hex_dump(f, pkt->data, pkt->size);
3469 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3471 AVRational tb = { 1, AV_TIME_BASE };
3472 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3476 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3478 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3482 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3484 AVRational tb = { 1, AV_TIME_BASE };
3485 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3489 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3492 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3495 void av_url_split(char *proto, int proto_size,
3496 char *authorization, int authorization_size,
3497 char *hostname, int hostname_size,
3499 char *path, int path_size,
3502 const char *p, *ls, *at, *col, *brk;
3504 if (port_ptr) *port_ptr = -1;
3505 if (proto_size > 0) proto[0] = 0;
3506 if (authorization_size > 0) authorization[0] = 0;
3507 if (hostname_size > 0) hostname[0] = 0;
3508 if (path_size > 0) path[0] = 0;
3510 /* parse protocol */
3511 if ((p = strchr(url, ':'))) {
3512 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3517 /* no protocol means plain filename */
3518 av_strlcpy(path, url, path_size);
3522 /* separate path from hostname */
3523 ls = strchr(p, '/');
3525 ls = strchr(p, '?');
3527 av_strlcpy(path, ls, path_size);
3529 ls = &p[strlen(p)]; // XXX
3531 /* the rest is hostname, use that to parse auth/port */
3533 /* authorization (user[:pass]@hostname) */
3534 if ((at = strchr(p, '@')) && at < ls) {
3535 av_strlcpy(authorization, p,
3536 FFMIN(authorization_size, at + 1 - p));
3537 p = at + 1; /* skip '@' */
3540 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3542 av_strlcpy(hostname, p + 1,
3543 FFMIN(hostname_size, brk - p));
3544 if (brk[1] == ':' && port_ptr)
3545 *port_ptr = atoi(brk + 2);
3546 } else if ((col = strchr(p, ':')) && col < ls) {
3547 av_strlcpy(hostname, p,
3548 FFMIN(col + 1 - p, hostname_size));
3549 if (port_ptr) *port_ptr = atoi(col + 1);
3551 av_strlcpy(hostname, p,
3552 FFMIN(ls + 1 - p, hostname_size));
3556 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3559 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3562 'C', 'D', 'E', 'F' };
3563 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3566 'c', 'd', 'e', 'f' };
3567 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3569 for(i = 0; i < s; i++) {
3570 buff[i * 2] = hex_table[src[i] >> 4];
3571 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3577 int ff_hex_to_data(uint8_t *data, const char *p)
3584 p += strspn(p, SPACE_CHARS);
3587 c = toupper((unsigned char) *p++);
3588 if (c >= '0' && c <= '9')
3590 else if (c >= 'A' && c <= 'F')
3605 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3606 unsigned int pts_num, unsigned int pts_den)
3609 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3610 if(new_tb.num != pts_num)
3611 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3613 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3615 if(new_tb.num <= 0 || new_tb.den <= 0) {
3616 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3619 s->time_base = new_tb;
3620 s->pts_wrap_bits = pts_wrap_bits;
3623 int ff_url_join(char *str, int size, const char *proto,
3624 const char *authorization, const char *hostname,
3625 int port, const char *fmt, ...)
3628 struct addrinfo hints, *ai;
3633 av_strlcatf(str, size, "%s://", proto);
3634 if (authorization && authorization[0])
3635 av_strlcatf(str, size, "%s@", authorization);
3636 #if CONFIG_NETWORK && defined(AF_INET6)
3637 /* Determine if hostname is a numerical IPv6 address,
3638 * properly escape it within [] in that case. */
3639 memset(&hints, 0, sizeof(hints));
3640 hints.ai_flags = AI_NUMERICHOST;
3641 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3642 if (ai->ai_family == AF_INET6) {
3643 av_strlcat(str, "[", size);
3644 av_strlcat(str, hostname, size);
3645 av_strlcat(str, "]", size);
3647 av_strlcat(str, hostname, size);
3652 /* Not an IPv6 address, just output the plain string. */
3653 av_strlcat(str, hostname, size);
3656 av_strlcatf(str, size, ":%d", port);
3659 int len = strlen(str);
3662 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3668 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3669 AVFormatContext *src)
3674 local_pkt.stream_index = dst_stream;
3675 if (pkt->pts != AV_NOPTS_VALUE)
3676 local_pkt.pts = av_rescale_q(pkt->pts,
3677 src->streams[pkt->stream_index]->time_base,
3678 dst->streams[dst_stream]->time_base);
3679 if (pkt->dts != AV_NOPTS_VALUE)
3680 local_pkt.dts = av_rescale_q(pkt->dts,
3681 src->streams[pkt->stream_index]->time_base,
3682 dst->streams[dst_stream]->time_base);
3683 return av_write_frame(dst, &local_pkt);
3686 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3689 const char *ptr = str;
3691 /* Parse key=value pairs. */
3694 char *dest = NULL, *dest_end;
3695 int key_len, dest_len = 0;
3697 /* Skip whitespace and potential commas. */
3698 while (*ptr && (isspace(*ptr) || *ptr == ','))
3705 if (!(ptr = strchr(key, '=')))
3708 key_len = ptr - key;
3710 callback_get_buf(context, key, key_len, &dest, &dest_len);
3711 dest_end = dest + dest_len - 1;
3715 while (*ptr && *ptr != '\"') {
3719 if (dest && dest < dest_end)
3723 if (dest && dest < dest_end)
3731 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3732 if (dest && dest < dest_end)
3740 int ff_find_stream_index(AVFormatContext *s, int id)
3743 for (i = 0; i < s->nb_streams; i++) {
3744 if (s->streams[i]->id == id)
3750 void ff_make_absolute_url(char *buf, int size, const char *base,
3754 /* Absolute path, relative to the current server */
3755 if (base && strstr(base, "://") && rel[0] == '/') {
3757 av_strlcpy(buf, base, size);
3758 sep = strstr(buf, "://");
3761 sep = strchr(sep, '/');
3765 av_strlcat(buf, rel, size);
3768 /* If rel actually is an absolute url, just copy it */
3769 if (!base || strstr(rel, "://") || rel[0] == '/') {
3770 av_strlcpy(buf, rel, size);
3774 av_strlcpy(buf, base, size);
3775 /* Remove the file name from the base url */
3776 sep = strrchr(buf, '/');
3781 while (av_strstart(rel, "../", NULL) && sep) {
3782 /* Remove the path delimiter at the end */
3784 sep = strrchr(buf, '/');
3785 /* If the next directory name to pop off is "..", break here */
3786 if (!strcmp(sep ? &sep[1] : buf, "..")) {
3787 /* Readd the slash we just removed */
3788 av_strlcat(buf, "/", size);
3791 /* Cut off the directory name */
3798 av_strlcat(buf, rel, size);