X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Futils.c;h=f55e1e6de55285931c6ac282a5be8a3a9d8c0997;hb=18b0c39f99eee508107c47345494e535b8757434;hp=70f8d46aae62a2e13531fb6d97d41c0a054ed125;hpb=a08efa2e3640ef0445032022c0b392376c58bd99;p=ffmpeg diff --git a/libavformat/utils.c b/libavformat/utils.c index 70f8d46aae6..f55e1e6de55 100644 --- a/libavformat/utils.c +++ b/libavformat/utils.c @@ -37,6 +37,7 @@ #include "libavutil/avstring.h" #include "libavutil/mathematics.h" #include "libavutil/parseutils.h" +#include "libavutil/time.h" #include "libavutil/timestamp.h" #include "riff.h" #include "audiointerleave.h" @@ -217,7 +218,7 @@ AVOutputFormat *av_guess_format(const char *short_name, const char *filename, #if CONFIG_IMAGE2_MUXER if (!short_name && filename && av_filename_number_test(filename) && - ff_guess_image2_codec(filename) != CODEC_ID_NONE) { + ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) { return av_guess_format("image2", NULL, NULL); } #endif @@ -242,17 +243,17 @@ AVOutputFormat *av_guess_format(const char *short_name, const char *filename, return fmt_found; } -enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, +enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, const char *filename, const char *mime_type, enum AVMediaType type){ if(type == AVMEDIA_TYPE_VIDEO){ - enum CodecID codec_id= CODEC_ID_NONE; + enum AVCodecID codec_id= AV_CODEC_ID_NONE; #if CONFIG_IMAGE2_MUXER if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){ codec_id= ff_guess_image2_codec(filename); } #endif - if(codec_id == CODEC_ID_NONE) + if(codec_id == AV_CODEC_ID_NONE) codec_id= fmt->video_codec; return codec_id; }else if(type == AVMEDIA_TYPE_AUDIO) @@ -260,7 +261,7 @@ enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name, else if (type == AVMEDIA_TYPE_SUBTITLE) return fmt->subtitle_codec; else - return CODEC_ID_NONE; + return AV_CODEC_ID_NONE; } AVInputFormat *av_find_input_format(const char *short_name) @@ -398,17 +399,17 @@ AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){ static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd) { static const struct { - const char *name; enum CodecID id; enum AVMediaType type; + const char *name; enum AVCodecID id; enum AVMediaType type; } fmt_id_type[] = { - { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO }, - { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO }, - { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO }, - { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO }, - { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO }, - { "loas" , CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO }, - { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO }, - { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO }, - { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO }, + { "aac" , AV_CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO }, + { "ac3" , AV_CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO }, + { "dts" , AV_CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO }, + { "eac3" , AV_CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO }, + { "h264" , AV_CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO }, + { "loas" , AV_CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO }, + { "m4v" , AV_CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO }, + { "mp3" , AV_CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO }, + { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO }, { 0 } }; int score; @@ -680,11 +681,15 @@ static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt) --st->probe_packets; if (pkt) { - pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE); + uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE); + if(!new_buf) + goto no_packet; + pd->buf = new_buf; memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size); pd->buf_size += pkt->size; memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE); } else { +no_packet: st->probe_packets = 0; } @@ -693,12 +698,12 @@ static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt) if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){ int score= set_codec_from_probe_data(s, st, pd); - if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4) + if( (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4) || end){ pd->buf_size=0; av_freep(&pd->buf); st->request_probe= -1; - if(st->codec->codec_id != CODEC_ID_NONE){ + if(st->codec->codec_id != AV_CODEC_ID_NONE){ av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index); }else av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index); @@ -794,11 +799,11 @@ int av_read_packet(AVFormatContext *s, AVPacket *pkt) static int determinable_frame_size(AVCodecContext *avctx) { - if (/*avctx->codec_id == CODEC_ID_AAC ||*/ - avctx->codec_id == CODEC_ID_MP1 || - avctx->codec_id == CODEC_ID_MP2 || - avctx->codec_id == CODEC_ID_MP3/* || - avctx->codec_id == CODEC_ID_CELT*/) + if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/ + avctx->codec_id == AV_CODEC_ID_MP1 || + avctx->codec_id == AV_CODEC_ID_MP2 || + avctx->codec_id == AV_CODEC_ID_MP3/* || + avctx->codec_id == AV_CODEC_ID_CELT*/) return 1; return 0; } @@ -873,22 +878,22 @@ static int is_intra_only(AVCodecContext *enc){ return 1; }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){ switch(enc->codec_id){ - case CODEC_ID_MJPEG: - case CODEC_ID_MJPEGB: - case CODEC_ID_LJPEG: - case CODEC_ID_PRORES: - case CODEC_ID_RAWVIDEO: - case CODEC_ID_V210: - case CODEC_ID_DVVIDEO: - case CODEC_ID_HUFFYUV: - case CODEC_ID_FFVHUFF: - case CODEC_ID_ASV1: - case CODEC_ID_ASV2: - case CODEC_ID_VCR1: - case CODEC_ID_DNXHD: - case CODEC_ID_JPEG2000: - case CODEC_ID_MDEC: - case CODEC_ID_UTVIDEO: + case AV_CODEC_ID_MJPEG: + case AV_CODEC_ID_MJPEGB: + case AV_CODEC_ID_LJPEG: + case AV_CODEC_ID_PRORES: + case AV_CODEC_ID_RAWVIDEO: + case AV_CODEC_ID_V210: + case AV_CODEC_ID_DVVIDEO: + case AV_CODEC_ID_HUFFYUV: + case AV_CODEC_ID_FFVHUFF: + case AV_CODEC_ID_ASV1: + case AV_CODEC_ID_ASV2: + case AV_CODEC_ID_VCR1: + case AV_CODEC_ID_DNXHD: + case AV_CODEC_ID_JPEG2000: + case AV_CODEC_ID_MDEC: + case AV_CODEC_ID_UTVIDEO: return 1; default: break; } @@ -896,6 +901,22 @@ static int is_intra_only(AVCodecContext *enc){ return 0; } +static int has_decode_delay_been_guessed(AVStream *st) +{ + if(st->codec->codec_id != AV_CODEC_ID_H264) return 1; +#if CONFIG_H264_DECODER + if(st->codec->has_b_frames && + avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames) + return 1; +#endif + if(st->codec->has_b_frames<3) + return st->nb_decoded_frames >= 7; + else if(st->codec->has_b_frames<4) + return st->nb_decoded_frames >= 18; + else + return st->nb_decoded_frames >= 20; +} + static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl) { if (pktl->next) @@ -994,7 +1015,7 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st, if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE) pkt->dts= AV_NOPTS_VALUE; - if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B) + if (st->codec->codec_id != AV_CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B) //FIXME Set low_delay = 0 when has_b_frames = 1 st->codec->has_b_frames = 1; @@ -1067,7 +1088,7 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st, // presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration); /* interpolate PTS and DTS if they are not present */ //We skip H264 currently because delay and has_b_frames are not reliably set - if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){ + if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){ if (presentation_delayed) { /* DTS = decompression timestamp */ /* PTS = presentation timestamp */ @@ -1096,6 +1117,7 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st, int64_t old_diff= FFABS(st->cur_dts - duration - pkt->pts); int64_t new_diff= FFABS(st->cur_dts - pkt->pts); if( old_diff < new_diff && old_diff < (duration>>3) + && st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (!strcmp(s->iformat->name, "mpeg") || !strcmp(s->iformat->name, "mpegts"))){ pkt->pts += duration; @@ -1118,13 +1140,13 @@ static void compute_pkt_fields(AVFormatContext *s, AVStream *st, } } - if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){ + if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){ st->pts_buffer[0]= pkt->pts; for(i=0; ipts_buffer[i] > st->pts_buffer[i+1]; i++) FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]); if(pkt->dts == AV_NOPTS_VALUE) pkt->dts= st->pts_buffer[0]; - if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here + if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet } if(pkt->dts > st->cur_dts) @@ -1183,6 +1205,7 @@ static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index) pkt->pts, pkt->dts, pkt->pos); pkt->pts = pkt->dts = AV_NOPTS_VALUE; + pkt->pos = -1; /* increment read pointer */ data += len; size -= len; @@ -1214,6 +1237,9 @@ static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index) out_pkt.dts = st->parser->dts; out_pkt.pos = st->parser->pos; + if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) + out_pkt.pos = st->parser->frame_offset; + if (st->parser->key_frame == 1 || (st->parser->key_frame == -1 && st->parser->pict_type == AV_PICTURE_TYPE_I)) @@ -1224,14 +1250,6 @@ static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index) compute_pkt_fields(s, st, st->parser, &out_pkt); - if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && - out_pkt.flags & AV_PKT_FLAG_KEY) { - int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? out_pkt.pos : st->parser->frame_offset; - ff_reduce_index(s, st->index); - av_add_index_entry(st, pos, out_pkt.dts, - 0, 0, AVINDEX_KEYFRAME); - } - if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) { out_pkt.destruct = pkt->destruct; pkt->destruct = NULL; @@ -1381,6 +1399,7 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt) const int genpts = s->flags & AVFMT_FLAG_GENPTS; int eof = 0; int ret; + AVStream *st; if (!genpts) { ret = s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer, @@ -1449,10 +1468,25 @@ int av_read_frame(AVFormatContext *s, AVPacket *pkt) } return_packet: + + st = s->streams[pkt->stream_index]; + if (st->skip_samples) { + uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10); + AV_WL32(p, st->skip_samples); + av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples); + st->skip_samples = 0; + } + + if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) { + ff_reduce_index(s, st->index); + av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME); + } + if (is_relative(pkt->dts)) pkt->dts -= RELATIVE_TS_BASE; if (is_relative(pkt->pts)) pkt->pts -= RELATIVE_TS_BASE; + return ret; } @@ -1556,6 +1590,9 @@ int ff_add_index_entry(AVIndexEntry **index_entries, if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry)) return -1; + if(timestamp == AV_NOPTS_VALUE) + return AVERROR(EINVAL); + if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known timestamp -= RELATIVE_TS_BASE; @@ -1882,7 +1919,7 @@ static int seek_frame_generic(AVFormatContext *s, if(stream_index == pkt.stream_index && pkt.dts > timestamp){ if(pkt.flags & AV_PKT_FLAG_KEY) break; - if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){ + if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){ av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey); break; } @@ -2256,46 +2293,40 @@ static void estimate_timings(AVFormatContext *ic, int64_t old_offset) } } -static int has_codec_parameters(AVStream *st) +static int has_codec_parameters(AVStream *st, const char **errmsg_ptr) { AVCodecContext *avctx = st->codec; - int val; + +#define FAIL(errmsg) do { \ + if (errmsg_ptr) \ + *errmsg_ptr = errmsg; \ + return 0; \ + } while (0) + switch (avctx->codec_type) { case AVMEDIA_TYPE_AUDIO: - val = avctx->sample_rate && avctx->channels; if (!avctx->frame_size && determinable_frame_size(avctx)) - return 0; + FAIL("unspecified sample size"); if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE) - return 0; + FAIL("unspecified sample format"); + if (!avctx->sample_rate) + FAIL("unspecified sample rate"); + if (!avctx->channels) + FAIL("unspecified number of channels"); break; case AVMEDIA_TYPE_VIDEO: - val = avctx->width; + if (!avctx->width) + FAIL("unspecified size"); if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE) - return 0; + FAIL("unspecified pixel format"); break; case AVMEDIA_TYPE_DATA: - if(avctx->codec_id == CODEC_ID_NONE) return 1; - default: - val = 1; - break; + if(avctx->codec_id == AV_CODEC_ID_NONE) return 1; } - return avctx->codec_id != CODEC_ID_NONE && val != 0; -} -static int has_decode_delay_been_guessed(AVStream *st) -{ - if(st->codec->codec_id != CODEC_ID_H264) return 1; -#if CONFIG_H264_DECODER - if(st->codec->has_b_frames && - avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames) - return 1; -#endif - if(st->codec->has_b_frames<3) - return st->info->nb_decoded_frames >= 6; - else if(st->codec->has_b_frames<4) - return st->info->nb_decoded_frames >= 18; - else - return st->info->nb_decoded_frames >= 20; + if (avctx->codec_id == AV_CODEC_ID_NONE) + FAIL("unknown codec"); + return 1; } /* returns 1 or 0 if or if not decoded data was returned, or a negative error */ @@ -2336,7 +2367,7 @@ static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **option while ((pkt.size > 0 || (!pkt.data && got_picture)) && ret >= 0 && - (!has_codec_parameters(st) || + (!has_codec_parameters(st, NULL) || !has_decode_delay_been_guessed(st) || (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) { got_picture = 0; @@ -2354,7 +2385,7 @@ static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **option } if (ret >= 0) { if (got_picture) - st->info->nb_decoded_frames++; + st->nb_decoded_frames++; pkt.data += ret; pkt.size -= ret; ret = got_picture; @@ -2365,9 +2396,9 @@ static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **option return ret; } -unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id) +unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id) { - while (tags->id != CODEC_ID_NONE) { + while (tags->id != AV_CODEC_ID_NONE) { if (tags->id == id) return tags->tag; tags++; @@ -2375,21 +2406,21 @@ unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id) return 0; } -enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag) +enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag) { int i; - for(i=0; tags[i].id != CODEC_ID_NONE;i++) { + for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) { if(tag == tags[i].tag) return tags[i].id; } - for(i=0; tags[i].id != CODEC_ID_NONE; i++) { + for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) { if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag)) return tags[i].id; } - return CODEC_ID_NONE; + return AV_CODEC_ID_NONE; } -unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id) +unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id) { int i; for(i=0; tags && tags[i]; i++){ @@ -2399,14 +2430,14 @@ unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id) return 0; } -enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag) +enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag) { int i; for(i=0; tags && tags[i]; i++){ - enum CodecID id= ff_codec_get_id(tags[i], tag); - if(id!=CODEC_ID_NONE) return id; + enum AVCodecID id= ff_codec_get_id(tags[i], tag); + if(id!=AV_CODEC_ID_NONE) return id; } - return CODEC_ID_NONE; + return AV_CODEC_ID_NONE; } static void compute_chapters_end(AVFormatContext *s) @@ -2448,8 +2479,8 @@ static int tb_unreliable(AVCodecContext *c){ || c->time_base.den < 5L*c->time_base.num /* || c->codec_tag == AV_RL32("DIVX") || c->codec_tag == AV_RL32("XVID")*/ - || c->codec_id == CODEC_ID_MPEG2VIDEO - || c->codec_id == CODEC_ID_H264 + || c->codec_id == AV_CODEC_ID_MPEG2VIDEO + || c->codec_id == AV_CODEC_ID_H264 ) return 1; return 0; @@ -2469,7 +2500,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) AVPacket pkt1, *pkt; int64_t old_offset = avio_tell(ic->pb); int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those - int flush_codecs = 1; + int flush_codecs = ic->probesize > 0; if(ic->pb) av_log(ic, AV_LOG_DEBUG, "File position before avformat_find_stream_info() is %"PRId64"\n", avio_tell(ic->pb)); @@ -2515,7 +2546,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) : &thread_opt); //try to just open decoders, in case this is enough to get parameters - if (!has_codec_parameters(st)) { + if (!has_codec_parameters(st, NULL)) { if (codec && !st->codec->codec) avcodec_open2(st->codec, codec, options ? &options[i] : &thread_opt); @@ -2525,7 +2556,11 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) } for (i=0; inb_streams; i++) { +#if FF_API_R_FRAME_RATE ic->streams[i]->info->last_dts = AV_NOPTS_VALUE; +#endif + ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE; + ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE; } count = 0; @@ -2542,7 +2577,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) int fps_analyze_framecount = 20; st = ic->streams[i]; - if (!has_codec_parameters(st)) + if (!has_codec_parameters(st, NULL)) break; /* if the timebase is coarse (like the usual millisecond precision of mkv), we need to analyze more frames to reliably arrive at @@ -2599,19 +2634,43 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) break; } - pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end); - if ((ret = av_dup_packet(pkt)) < 0) - goto find_stream_info_err; + if (ic->flags & AVFMT_FLAG_NOBUFFER) { + pkt = &pkt1; + } else { + pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1, + &ic->packet_buffer_end); + if ((ret = av_dup_packet(pkt)) < 0) + goto find_stream_info_err; + } read_size += pkt->size; st = ic->streams[pkt->stream_index]; + if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) { + /* check for non-increasing dts */ + if (st->info->fps_last_dts != AV_NOPTS_VALUE && + st->info->fps_last_dts >= pkt->dts) { + av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: " + "packet %d with DTS %"PRId64", packet %d with DTS " + "%"PRId64"\n", st->index, st->info->fps_last_dts_idx, + st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts); + st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE; + } + + /* update stored dts values */ + if (st->info->fps_first_dts == AV_NOPTS_VALUE) { + st->info->fps_first_dts = pkt->dts; + st->info->fps_first_dts_idx = st->codec_info_nb_frames; + } + st->info->fps_last_dts = pkt->dts; + st->info->fps_last_dts_idx = st->codec_info_nb_frames; + } if (st->codec_info_nb_frames>1) { int64_t t=0; if (st->time_base.den > 0) t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q); if (st->avg_frame_rate.num > 0) - t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, (AVRational){st->avg_frame_rate.den, st->avg_frame_rate.num}, AV_TIME_BASE_Q)); + t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q)); if (t >= ic->max_analyze_duration) { av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t); @@ -2619,6 +2678,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) } st->info->codec_info_duration += pkt->duration; } +#if FF_API_R_FRAME_RATE { int64_t last = st->info->last_dts; @@ -2646,6 +2706,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1) st->info->last_dts = pkt->dts; } +#endif if(st->parser && st->parser->parser->split && !st->codec->extradata){ int i= st->parser->parser->split(st->codec, pkt->data, pkt->size); if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) { @@ -2680,6 +2741,8 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) ret = -1; /* we could not have all the codec parameters before EOF */ for(i=0;inb_streams;i++) { + const char *errmsg; + st = ic->streams[i]; /* flush the decoders */ @@ -2688,7 +2751,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) err = try_decode_frame(st, &empty_pkt, (options && i < orig_nb_streams) ? &options[i] : NULL); - } while (err > 0 && !has_codec_parameters(st)); + } while (err > 0 && !has_codec_parameters(st, NULL)); if (err < 0) { av_log(ic, AV_LOG_INFO, @@ -2696,11 +2759,13 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) } } - if (!has_codec_parameters(st)){ + if (!has_codec_parameters(st, &errmsg)) { char buf[256]; avcodec_string(buf, sizeof(buf), st->codec, 0); av_log(ic, AV_LOG_WARNING, - "Could not find codec parameters (%s)\n", buf); + "Could not find codec parameters for stream %d (%s): %s\n" + "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n", + i, buf, errmsg); } else { ret = 0; } @@ -2715,25 +2780,44 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) for(i=0;inb_streams;i++) { st = ic->streams[i]; if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { - if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){ + if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){ uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt); if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt) st->codec->codec_tag= tag; } - if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration) + /* estimate average framerate if not set by demuxer */ + if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration) { + int best_fps = 0; + double best_error = 0.01; + av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den, (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den, st->info->codec_info_duration*(int64_t)st->time_base.num, 60000); + + /* round guessed framerate to a "standard" framerate if it's + * within 1% of the original estimate*/ + for (j = 1; j < MAX_STD_TIMEBASES; j++) { + AVRational std_fps = { get_std_framerate(j), 12*1001 }; + double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1); + + if (error < best_error) { + best_error = error; + best_fps = std_fps.num; + } + } + if (best_fps) { + av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den, + best_fps, 12*1001, INT_MAX); + } + } // the check for tb_unreliable() is not completely correct, since this is not about handling // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g. // ipmovie.c produces. 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) 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); if (st->info->duration_count && !st->r_frame_rate.num - && tb_unreliable(st->codec) /*&& - //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ... - st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){ + && tb_unreliable(st->codec)) { int num = 0; double best_error= 0.01; @@ -2791,6 +2875,7 @@ int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options) } } + if(ic->probesize) estimate_timings(ic, old_offset); compute_chapters_end(ic); @@ -3138,7 +3223,7 @@ static int validate_codec_tag(AVFormatContext *s, AVStream *st) { const AVCodecTag *avctag; int n; - enum CodecID id = CODEC_ID_NONE; + enum AVCodecID id = AV_CODEC_ID_NONE; unsigned int tag = 0; /** @@ -3149,7 +3234,7 @@ static int validate_codec_tag(AVFormatContext *s, AVStream *st) */ for (n = 0; s->oformat->codec_tag[n]; n++) { avctag = s->oformat->codec_tag[n]; - while (avctag->id != CODEC_ID_NONE) { + while (avctag->id != AV_CODEC_ID_NONE) { if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) { id = avctag->id; if (id == st->codec->codec_id) @@ -3160,7 +3245,7 @@ static int validate_codec_tag(AVFormatContext *s, AVStream *st) avctag++; } } - if (id != CODEC_ID_NONE) + if (id != AV_CODEC_ID_NONE) return 0; if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL)) return 0; @@ -3229,7 +3314,7 @@ int avformat_write_header(AVFormatContext *s, AVDictionary **options) if(s->oformat->codec_tag){ if( st->codec->codec_tag - && st->codec->codec_id == CODEC_ID_RAWVIDEO + && st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && (av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 || av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) ==MKTAG('r', 'a', 'w', ' ')) && !validate_codec_tag(s, st)){ //the current rawvideo encoding system ends up setting the wrong codec_tag for avi/mov, we override it here @@ -3727,7 +3812,7 @@ static void dump_metadata(void *ctx, AVDictionary *m, const char *indent) av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key); while(*p) { char tmp[256]; - size_t len = strcspn(p, "\xd\xa"); + size_t len = strcspn(p, "\x8\xa\xb\xc\xd"); av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1)); av_log(ctx, AV_LOG_INFO, "%s", tmp); p += len; @@ -3773,8 +3858,10 @@ static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_out if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){ if(st->avg_frame_rate.den && st->avg_frame_rate.num) print_fps(av_q2d(st->avg_frame_rate), "fps"); +#if FF_API_R_FRAME_RATE if(st->r_frame_rate.den && st->r_frame_rate.num) print_fps(av_q2d(st->r_frame_rate), "tbr"); +#endif if(st->time_base.den && st->time_base.num) print_fps(1/av_q2d(st->time_base), "tbn"); if(st->codec->time_base.den && st->codec->time_base.num) @@ -4049,7 +4136,7 @@ void av_url_split(char *proto, int proto_size, char *path, int path_size, const char *url) { - const char *p, *ls, *at, *col, *brk; + const char *p, *ls, *ls2, *at, *col, *brk; if (port_ptr) *port_ptr = -1; if (proto_size > 0) proto[0] = 0; @@ -4071,8 +4158,11 @@ void av_url_split(char *proto, int proto_size, /* separate path from hostname */ ls = strchr(p, '/'); + ls2 = strchr(p, '?'); if(!ls) - ls = strchr(p, '?'); + ls = ls2; + else if (ls && ls2) + ls = FFMIN(ls, ls2); if(ls) av_strlcpy(path, ls, path_size); else @@ -4175,6 +4265,7 @@ void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, return; } s->time_base = new_tb; + av_codec_set_pkt_timebase(s->codec, new_tb); s->pts_wrap_bits = pts_wrap_bits; } @@ -4373,7 +4464,7 @@ int64_t ff_iso8601_to_unix_time(const char *datestr) #endif } -int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance) +int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance) { if (ofmt) { if (ofmt->query_codec) @@ -4481,3 +4572,64 @@ AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *strea else return frame_sample_aspect_ratio; } + +int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, + const char *spec) +{ + if (*spec <= '9' && *spec >= '0') /* opt:index */ + return strtol(spec, NULL, 0) == st->index; + else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' || + *spec == 't') { /* opt:[vasdt] */ + enum AVMediaType type; + + switch (*spec++) { + case 'v': type = AVMEDIA_TYPE_VIDEO; break; + case 'a': type = AVMEDIA_TYPE_AUDIO; break; + case 's': type = AVMEDIA_TYPE_SUBTITLE; break; + case 'd': type = AVMEDIA_TYPE_DATA; break; + case 't': type = AVMEDIA_TYPE_ATTACHMENT; break; + default: av_assert0(0); + } + if (type != st->codec->codec_type) + return 0; + if (*spec++ == ':') { /* possibly followed by :index */ + int i, index = strtol(spec, NULL, 0); + for (i = 0; i < s->nb_streams; i++) + if (s->streams[i]->codec->codec_type == type && index-- == 0) + return i == st->index; + return 0; + } + return 1; + } else if (*spec == 'p' && *(spec + 1) == ':') { + int prog_id, i, j; + char *endptr; + spec += 2; + prog_id = strtol(spec, &endptr, 0); + for (i = 0; i < s->nb_programs; i++) { + if (s->programs[i]->id != prog_id) + continue; + + if (*endptr++ == ':') { + int stream_idx = strtol(endptr, NULL, 0); + return stream_idx >= 0 && + stream_idx < s->programs[i]->nb_stream_indexes && + st->index == s->programs[i]->stream_index[stream_idx]; + } + + for (j = 0; j < s->programs[i]->nb_stream_indexes; j++) + if (st->index == s->programs[i]->stream_index[j]) + return 1; + } + return 0; + } else if (*spec == '#') { + int sid; + char *endptr; + sid = strtol(spec + 1, &endptr, 0); + if (!*endptr) + return st->id == sid; + } else if (!*spec) /* empty specifier, matches everything */ + return 1; + + av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec); + return AVERROR(EINVAL); +}