X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=ffmpeg.c;h=de15898138cb32a9315aaa194316d60b951d13fa;hb=961e4a3389e348033312662c0581a0fb34eaa14b;hp=5c5aa4725cf4dae6b57dcd967465dd99439fb42e;hpb=06a3c9c45a89bb599e433312bf6dc6678edbd3e0;p=ffmpeg diff --git a/ffmpeg.c b/ffmpeg.c index 5c5aa4725cf..de15898138c 100644 --- a/ffmpeg.c +++ b/ffmpeg.c @@ -36,17 +36,31 @@ #include "libswscale/swscale.h" #include "libavcodec/opt.h" #include "libavcodec/audioconvert.h" -#include "libavcodec/colorspace.h" +#include "libavutil/colorspace.h" #include "libavutil/fifo.h" +#include "libavutil/pixdesc.h" #include "libavutil/avstring.h" +#include "libavutil/libm.h" #include "libavformat/os_support.h" +#if CONFIG_AVFILTER +# include "libavfilter/avfilter.h" +# include "libavfilter/avfiltergraph.h" +# include "libavfilter/graphparser.h" +# include "libavfilter/vsrc_buffer.h" +#endif + #if HAVE_SYS_RESOURCE_H #include +#include #include #elif HAVE_GETPROCESSTIMES #include #endif +#if HAVE_GETPROCESSMEMORYINFO +#include +#include +#endif #if HAVE_SYS_SELECT_H #include @@ -60,7 +74,6 @@ #elif HAVE_CONIO_H #include #endif -#undef time //needed because HAVE_AV_CONFIG_H is defined on top #include #include "cmdutils.h" @@ -68,8 +81,6 @@ #undef NDEBUG #include -#undef exit - const char program_name[] = "FFmpeg"; const int program_birth_year = 2000; @@ -89,7 +100,7 @@ typedef struct AVMetaDataMap { static const OptionDef options[]; -#define MAX_FILES 20 +#define MAX_FILES 100 static const char *last_asked_format = NULL; static AVFormatContext *input_files[MAX_FILES]; @@ -110,16 +121,14 @@ static int nb_stream_maps; static AVMetaDataMap meta_data_maps[MAX_FILES]; static int nb_meta_data_maps; +/* indexed by output file stream index */ +static int streamid_map[MAX_STREAMS]; + static int frame_width = 0; static int frame_height = 0; static float frame_aspect_ratio = 0; static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE; static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE; -static int frame_padtop = 0; -static int frame_padbottom = 0; -static int frame_padleft = 0; -static int frame_padright = 0; -static int padcolor[3] = {16,128,128}; /* default to black */ static int frame_topBand = 0; static int frame_bottomBand = 0; static int frame_leftBand = 0; @@ -133,7 +142,8 @@ static const char *video_rc_override_string=NULL; static int video_disable = 0; static int video_discard = 0; static char *video_codec_name = NULL; -static int video_codec_tag = 0; +static unsigned int video_codec_tag = 0; +static char *video_language = NULL; static int same_quality = 0; static int do_deinterlace = 0; static int top_field_first = -1; @@ -142,6 +152,10 @@ static int intra_dc_precision = 8; static int loop_input = 0; static int loop_output = AVFMT_NOOUTPUTLOOP; static int qp_hist = 0; +#if CONFIG_AVFILTER +static char *vfilters = NULL; +AVFilterGraph *graph = NULL; +#endif static int intra_only = 0; static int audio_sample_rate = 44100; @@ -151,20 +165,20 @@ static float audio_qscale = QSCALE_NONE; static int audio_disable = 0; static int audio_channels = 1; static char *audio_codec_name = NULL; -static int audio_codec_tag = 0; +static unsigned int audio_codec_tag = 0; static char *audio_language = NULL; static int subtitle_disable = 0; static char *subtitle_codec_name = NULL; static char *subtitle_language = NULL; -static int subtitle_codec_tag = 0; +static unsigned int subtitle_codec_tag = 0; static float mux_preload= 0.5; static float mux_max_delay= 0.7; static int64_t recording_time = INT64_MAX; static int64_t start_time = 0; -static int64_t rec_timestamp = 0; +static int64_t recording_timestamp = 0; static int64_t input_ts_offset = 0; static int file_overwrite = 0; static int metadata_count; @@ -269,13 +283,6 @@ typedef struct AVOutputStream { int original_leftBand; int original_rightBand; - /* padding area sizes */ - int video_pad; - int padtop; - int padbottom; - int padleft; - int padright; - /* audio only */ int audio_resample; ReSampleContext *resample; /* for audio resampling */ @@ -298,6 +305,15 @@ typedef struct AVInputStream { is not defined */ int64_t pts; /* current pts */ int is_start; /* is 1 at the start and after a discontinuity */ + int showed_multi_packet_warning; + int is_past_recording_time; +#if CONFIG_AVFILTER + AVFilterContext *out_video_filter; + AVFilterContext *input_video_filter; + AVFrame *filter_frame; + int has_filter_frame; + AVFilterPicRef *picref; +#endif } AVInputStream; typedef struct AVInputFile { @@ -313,6 +329,177 @@ typedef struct AVInputFile { static struct termios oldtty; #endif +#if CONFIG_AVFILTER +typedef struct { + int pix_fmt; +} FilterOutPriv; + + +static int output_init(AVFilterContext *ctx, const char *args, void *opaque) +{ + FilterOutPriv *priv = ctx->priv; + + if(!opaque) return -1; + + priv->pix_fmt = *((int *)opaque); + + return 0; +} + +static void output_end_frame(AVFilterLink *link) +{ +} + +static int output_query_formats(AVFilterContext *ctx) +{ + FilterOutPriv *priv = ctx->priv; + enum PixelFormat pix_fmts[] = { priv->pix_fmt, PIX_FMT_NONE }; + + avfilter_set_common_formats(ctx, avfilter_make_format_list(pix_fmts)); + return 0; +} + +static int get_filtered_video_pic(AVFilterContext *ctx, + AVFilterPicRef **picref, AVFrame *pic2, + uint64_t *pts) +{ + AVFilterPicRef *pic; + + if(avfilter_request_frame(ctx->inputs[0])) + return -1; + if(!(pic = ctx->inputs[0]->cur_pic)) + return -1; + *picref = pic; + ctx->inputs[0]->cur_pic = NULL; + + *pts = pic->pts; + + memcpy(pic2->data, pic->data, sizeof(pic->data)); + memcpy(pic2->linesize, pic->linesize, sizeof(pic->linesize)); + pic2->interlaced_frame = pic->interlaced; + pic2->top_field_first = pic->top_field_first; + + return 1; +} + +static AVFilter output_filter = +{ + .name = "ffmpeg_output", + + .priv_size = sizeof(FilterOutPriv), + .init = output_init, + + .query_formats = output_query_formats, + + .inputs = (AVFilterPad[]) {{ .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .end_frame = output_end_frame, + .min_perms = AV_PERM_READ, }, + { .name = NULL }}, + .outputs = (AVFilterPad[]) {{ .name = NULL }}, +}; + +static int configure_filters(AVInputStream *ist, AVOutputStream *ost) +{ + AVFilterContext *last_filter, *filter; + /** filter graph containing all filters including input & output */ + AVCodecContext *codec = ost->st->codec; + AVCodecContext *icodec = ist->st->codec; + char args[255]; + + graph = av_mallocz(sizeof(AVFilterGraph)); + + if (!(ist->input_video_filter = avfilter_open(avfilter_get_by_name("buffer"), "src"))) + return -1; + if (!(ist->out_video_filter = avfilter_open(&output_filter, "out"))) + return -1; + + snprintf(args, 255, "%d:%d:%d", ist->st->codec->width, + ist->st->codec->height, ist->st->codec->pix_fmt); + if (avfilter_init_filter(ist->input_video_filter, args, NULL)) + return -1; + if (avfilter_init_filter(ist->out_video_filter, NULL, &codec->pix_fmt)) + return -1; + + /* add input and output filters to the overall graph */ + avfilter_graph_add_filter(graph, ist->input_video_filter); + avfilter_graph_add_filter(graph, ist->out_video_filter); + + last_filter = ist->input_video_filter; + + if (ost->video_crop) { + snprintf(args, 255, "%d:%d:%d:%d", ost->leftBand, ost->topBand, + codec->width, + codec->height); + filter = avfilter_open(avfilter_get_by_name("crop"), NULL); + if (!filter) + return -1; + if (avfilter_init_filter(filter, args, NULL)) + return -1; + if (avfilter_link(last_filter, 0, filter, 0)) + return -1; + last_filter = filter; + avfilter_graph_add_filter(graph, last_filter); + } + + if((codec->width != + icodec->width - (frame_leftBand + frame_rightBand)) || + (codec->height != icodec->height - (frame_topBand + frame_bottomBand))) { + snprintf(args, 255, "%d:%d:flags=0x%X", + codec->width, + codec->height, + (int)av_get_int(sws_opts, "sws_flags", NULL)); + filter = avfilter_open(avfilter_get_by_name("scale"), NULL); + if (!filter) + return -1; + if (avfilter_init_filter(filter, args, NULL)) + return -1; + if (avfilter_link(last_filter, 0, filter, 0)) + return -1; + last_filter = filter; + avfilter_graph_add_filter(graph, last_filter); + } + + snprintf(args, sizeof(args), "flags=0x%X", (int)av_get_int(sws_opts, "sws_flags", NULL)); + graph->scale_sws_opts = av_strdup(args); + + if (vfilters) { + AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut)); + AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut)); + + outputs->name = av_strdup("in"); + outputs->filter = last_filter; + outputs->pad_idx = 0; + outputs->next = NULL; + + inputs->name = av_strdup("out"); + inputs->filter = ist->out_video_filter; + inputs->pad_idx = 0; + inputs->next = NULL; + + if (avfilter_graph_parse(graph, vfilters, inputs, outputs, NULL) < 0) + return -1; + av_freep(&vfilters); + } else { + if (avfilter_link(last_filter, 0, ist->out_video_filter, 0) < 0) + return -1; + } + + /* configure all the filter links */ + if (avfilter_graph_check_validity(graph, NULL)) + return -1; + if (avfilter_graph_config_formats(graph, NULL)) + return -1; + if (avfilter_graph_config_links(graph, NULL)) + return -1; + + codec->width = ist->out_video_filter->inputs[0]->w; + codec->height = ist->out_video_filter->inputs[0]->h; + + return 0; +} +#endif /* CONFIG_AVFILTER */ + static void term_exit(void) { #if HAVE_TERMIOS_H @@ -336,6 +523,7 @@ static void term_init(void) tcgetattr (0, &tty); oldtty = tty; + atexit(term_exit); tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP |INLCR|IGNCR|ICRNL|IXON); @@ -352,12 +540,8 @@ static void term_init(void) signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */ signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */ - /* - register a function to be called at normal program termination - */ - atexit(term_exit); -#if CONFIG_BEOS_NETSERVER - fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK); +#ifdef SIGXCPU + signal(SIGXCPU, sigterm_handler); #endif } @@ -367,7 +551,6 @@ static int read_key(void) #if HAVE_TERMIOS_H int n = 1; unsigned char ch; -#if !CONFIG_BEOS_NETSERVER struct timeval tv; fd_set rfds; @@ -376,7 +559,6 @@ static int read_key(void) tv.tv_sec = 0; tv.tv_usec = 0; n = select(1, &rfds, NULL, NULL, &tv); -#endif if (n > 0) { n = read(0, &ch, 1); if (n == 1) @@ -439,12 +621,7 @@ static int av_exit(int ret) av_free(video_standard); -#if CONFIG_POWERPC_PERF - void powerpc_display_perf_report(void); - powerpc_display_perf_report(); -#endif /* CONFIG_POWERPC_PERF */ - - for (i=0;isample_fmts){ + const enum SampleFormat *p= codec->sample_fmts; + for(; *p!=-1; p++){ + if(*p == st->codec->sample_fmt) + break; + } + if(*p == -1) + st->codec->sample_fmt = codec->sample_fmts[0]; + } +} + +static void choose_sample_rate(AVStream *st, AVCodec *codec) +{ + if(codec && codec->supported_samplerates){ + const int *p= codec->supported_samplerates; + int best=0; + int best_dist=INT_MAX; + for(; *p; p++){ + int dist= abs(st->codec->sample_rate - *p); + if(dist < best_dist){ + best_dist= dist; + best= *p; + } + } + if(best_dist){ + av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best); + } + st->codec->sample_rate= best; + } +} + +static void choose_pixel_fmt(AVStream *st, AVCodec *codec) +{ + if(codec && codec->pix_fmts){ + const enum PixelFormat *p= codec->pix_fmts; + for(; *p!=-1; p++){ + if(*p == st->codec->pix_fmt) + break; + } + if(*p == -1 + && !( st->codec->codec_id==CODEC_ID_MJPEG + && st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL + && ( st->codec->pix_fmt == PIX_FMT_YUV420P + || st->codec->pix_fmt == PIX_FMT_YUV422P))) + st->codec->pix_fmt = codec->pix_fmts[0]; + } +} + static int read_ffserver_streams(AVFormatContext *s, const char *filename) { int i, err; @@ -477,6 +708,7 @@ static int read_ffserver_streams(AVFormatContext *s, const char *filename) s->nb_streams = ic->nb_streams; for(i=0;inb_streams;i++) { AVStream *st; + AVCodec *codec; // FIXME: a more elegant solution is needed st = av_mallocz(sizeof(AVStream)); @@ -486,13 +718,21 @@ static int read_ffserver_streams(AVFormatContext *s, const char *filename) print_error(filename, AVERROR(ENOMEM)); av_exit(1); } - memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext)); + avcodec_copy_context(st->codec, ic->streams[i]->codec); s->streams[i] = st; - if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy) - st->stream_copy = 1; - else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy) - st->stream_copy = 1; + codec = avcodec_find_encoder(st->codec->codec_id); + if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { + if (audio_stream_copy) { + st->stream_copy = 1; + } else + choose_sample_fmt(st, codec); + } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { + if (video_stream_copy) { + st->stream_copy = 1; + } else + choose_pixel_fmt(st, codec); + } if(!st->codec->thread_count) st->codec->thread_count = 1; @@ -525,7 +765,7 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx int a= av_bitstream_filter_filter(bsfc, avctx, NULL, &new_pkt.data, &new_pkt.size, pkt->data, pkt->size, - pkt->flags & PKT_FLAG_KEY); + pkt->flags & AV_PKT_FLAG_KEY); if(a>0){ av_free_packet(pkt); new_pkt.destruct= av_destruct_packet; @@ -558,6 +798,7 @@ static void do_audio_out(AVFormatContext *s, { uint8_t *buftmp; int64_t audio_out_size, audio_buf_size; + int64_t allocated_for_size= size; int size_out, frame_bytes, ret; AVCodecContext *enc= ost->st->codec; @@ -566,9 +807,11 @@ static void do_audio_out(AVFormatContext *s, int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8; const int coded_bps = av_get_bits_per_sample(enc->codec->id); - audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels); +need_realloc: + audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels); audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate; audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API + audio_buf_size= FFMAX(audio_buf_size, enc->frame_size); audio_buf_size*= osize*enc->channels; audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels); @@ -644,10 +887,11 @@ static void do_audio_out(AVFormatContext *s, static uint8_t *input_tmp= NULL; input_tmp= av_realloc(input_tmp, byte_delta + size); - if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE) - ist->is_start=0; - else - byte_delta= MAX_AUDIO_PACKET_SIZE - size; + if(byte_delta > allocated_for_size - size){ + allocated_for_size= byte_delta + (int64_t)size; + goto need_realloc; + } + ist->is_start=0; memset(input_tmp, 0, byte_delta); memcpy(input_tmp + byte_delta, buf, size); @@ -727,7 +971,7 @@ static void do_audio_out(AVFormatContext *s, pkt.size= ret; if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); ost->sync_opts += enc->frame_size; @@ -762,7 +1006,7 @@ static void do_audio_out(AVFormatContext *s, pkt.size= ret; if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE) pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base); - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); } } @@ -882,10 +1126,13 @@ static void do_video_out(AVFormatContext *s, int *frame_size) { int nb_frames, i, ret; +#if !CONFIG_AVFILTER int64_t topBand, bottomBand, leftBand, rightBand; +#endif AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src; AVFrame picture_crop_temp, picture_pad_temp; AVCodecContext *enc, *dec; + double sync_ipts; avcodec_get_frame_defaults(&picture_crop_temp); avcodec_get_frame_defaults(&picture_pad_temp); @@ -893,14 +1140,15 @@ static void do_video_out(AVFormatContext *s, enc = ost->st->codec; dec = ist->st->codec; + sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base); + /* by default, we output a single frame */ nb_frames = 1; *frame_size = 0; if(video_sync_method){ - double vdelta; - vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts; + double vdelta = sync_ipts - ost->sync_opts; //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c if (vdelta < -1.1) nb_frames = 0; @@ -908,7 +1156,7 @@ static void do_video_out(AVFormatContext *s, if(vdelta<=-0.6){ nb_frames=0; }else if(vdelta>0.6) - ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base)); + ost->sync_opts= lrintf(sync_ipts); }else if (vdelta > 1.1) nb_frames = lrintf(vdelta); //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames); @@ -922,12 +1170,15 @@ static void do_video_out(AVFormatContext *s, fprintf(stderr, "*** %d dup!\n", nb_frames-1); } }else - ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base)); + ost->sync_opts= lrintf(sync_ipts); - nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number); + nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number); if (nb_frames <= 0) return; +#if CONFIG_AVFILTER + formatted_picture = in_picture; +#else if (ost->video_crop) { if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) { fprintf(stderr, "error cropping picture\n"); @@ -939,22 +1190,11 @@ static void do_video_out(AVFormatContext *s, } else { formatted_picture = in_picture; } +#endif final_picture = formatted_picture; padding_src = formatted_picture; resampling_dst = &ost->pict_tmp; - if (ost->video_pad) { - final_picture = &ost->pict_tmp; - if (ost->video_resample) { - if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) { - fprintf(stderr, "error padding picture\n"); - if (exit_on_error) - av_exit(1); - return; - } - resampling_dst = &picture_pad_temp; - } - } if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand))) || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand))) @@ -965,6 +1205,7 @@ static void do_video_out(AVFormatContext *s, av_exit(1); } +#if !CONFIG_AVFILTER if (ost->video_resample) { padding_src = NULL; final_picture = &ost->pict_tmp; @@ -1000,8 +1241,8 @@ static void do_video_out(AVFormatContext *s, ist->st->codec->width - (ost->leftBand + ost->rightBand), ist->st->codec->height - (ost->topBand + ost->bottomBand), ist->st->codec->pix_fmt, - ost->st->codec->width - (ost->padleft + ost->padright), - ost->st->codec->height - (ost->padtop + ost->padbottom), + ost->st->codec->width, + ost->st->codec->height, ost->st->codec->pix_fmt, sws_flags, NULL, NULL, NULL); if (ost->img_resample_ctx == NULL) { @@ -1012,12 +1253,7 @@ static void do_video_out(AVFormatContext *s, sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize, 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize); } - - if (ost->video_pad) { - av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src, - enc->height, enc->width, enc->pix_fmt, - ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor); - } +#endif /* duplicates frame if needed */ for(i=0;isync_opts, enc->time_base, ost->st->time_base); - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); enc->coded_frame = old_frame; @@ -1045,7 +1281,7 @@ static void do_video_out(AVFormatContext *s, /* better than nothing: use input picture interlaced settings */ big_picture.interlaced_frame = in_picture->interlaced_frame; - if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){ + if(avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){ if(top_field_first == -1) big_picture.top_field_first = in_picture->top_field_first; else @@ -1082,7 +1318,7 @@ static void do_video_out(AVFormatContext *s, pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/ if(enc->coded_frame->key_frame) - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]); *frame_size = ret; video_size += ret; @@ -1120,7 +1356,7 @@ static void do_video_stats(AVFormatContext *os, AVOutputStream *ost, } enc = ost->st->codec; - if (enc->codec_type == CODEC_TYPE_VIDEO) { + if (enc->codec_type == AVMEDIA_TYPE_VIDEO) { frame_number = ost->frame_number; fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA); if (enc->flags&CODEC_FLAG_PSNR) @@ -1180,12 +1416,12 @@ static void print_report(AVFormatContext **output_files, for(i=0;ist->codec; - if (vid && enc->codec_type == CODEC_TYPE_VIDEO) { + if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", !ost->st->stream_copy ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1); } - if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) { + if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) { float t = (av_gettime()-timer_start) / 1000000.0; frame_number = ost->frame_number; @@ -1271,13 +1507,15 @@ static int output_packet(AVInputStream *ist, int ist_index, AVFormatContext *os; AVOutputStream *ost; int ret, i; - uint8_t *data_buf; - int data_size, got_picture; + int got_picture; AVFrame picture; void *buffer_to_free; static unsigned int samples_size= 0; AVSubtitle subtitle, *subtitle_to_free; - int got_subtitle; +#if CONFIG_AVFILTER + int frame_available; +#endif + AVPacket avpkt; int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3; @@ -1299,46 +1537,53 @@ static int output_packet(AVInputStream *ist, int ist_index, //while we have more to decode or while the decoder did output something on EOF while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) { + uint8_t *data_buf, *decoded_data_buf; + int data_size, decoded_data_size; handle_eof: ist->pts= ist->next_pts; if(avpkt.size && avpkt.size != pkt->size && - !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0) + ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){ fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index); + ist->showed_multi_packet_warning=1; + } /* decode the packet if needed */ - data_buf = NULL; /* fail safe */ - data_size = 0; + decoded_data_buf = NULL; /* fail safe */ + decoded_data_size= 0; + data_buf = avpkt.data; + data_size = avpkt.size; subtitle_to_free = NULL; if (ist->decoding_needed) { switch(ist->st->codec->codec_type) { - case CODEC_TYPE_AUDIO:{ + case AVMEDIA_TYPE_AUDIO:{ if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) { samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE); av_free(samples); samples= av_malloc(samples_size); } - data_size= samples_size; + decoded_data_size= samples_size; /* XXX: could avoid copy if PCM 16 bits with same endianness as CPU */ - ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size, + ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size, &avpkt); if (ret < 0) goto fail_decode; avpkt.data += ret; avpkt.size -= ret; + data_size = ret; /* Some bug in mpeg audio decoder gives */ - /* data_size < 0, it seems they are overflows */ - if (data_size <= 0) { + /* decoded_data_size < 0, it seems they are overflows */ + if (decoded_data_size <= 0) { /* no audio frame */ continue; } - data_buf = (uint8_t *)samples; - ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) / + decoded_data_buf = (uint8_t *)samples; + ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) / (ist->st->codec->sample_rate * ist->st->codec->channels); break;} - case CODEC_TYPE_VIDEO: - data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2; + case AVMEDIA_TYPE_VIDEO: + decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2; /* XXX: allocate picture correctly */ avcodec_get_frame_defaults(&picture); @@ -1359,12 +1604,12 @@ static int output_packet(AVInputStream *ist, int ist_index, } avpkt.size = 0; break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: ret = avcodec_decode_subtitle2(ist->st->codec, - &subtitle, &got_subtitle, &avpkt); + &subtitle, &got_picture, &avpkt); if (ret < 0) goto fail_decode; - if (!got_subtitle) { + if (!got_picture) { goto discard_packet; } subtitle_to_free = &subtitle; @@ -1375,11 +1620,11 @@ static int output_packet(AVInputStream *ist, int ist_index, } } else { switch(ist->st->codec->codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) / ist->st->codec->sample_rate; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: if (ist->st->codec->time_base.num != 0) { int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame; ist->next_pts += ((int64_t)AV_TIME_BASE * @@ -1388,24 +1633,31 @@ static int output_packet(AVInputStream *ist, int ist_index, } break; } - data_buf = avpkt.data; - data_size = avpkt.size; ret = avpkt.size; avpkt.size = 0; } buffer_to_free = NULL; - if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) { + if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free); } +#if CONFIG_AVFILTER + if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->input_video_filter) { + // add it to be filtered + av_vsrc_buffer_add_frame(ist->input_video_filter, &picture, + ist->pts, + ist->st->codec->sample_aspect_ratio); + } +#endif + // preprocess audio (volume) - if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) { + if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (audio_volume != 256) { short *volp; volp = samples; - for(i=0;i<(data_size / sizeof(short));i++) { + for(i=0;i<(decoded_data_size / sizeof(short));i++) { int v = ((*volp) * audio_volume + 128) >> 8; if (v < -32768) v = -32768; if (v > 32767) v = 32767; @@ -1421,10 +1673,18 @@ static int output_packet(AVInputStream *ist, int ist_index, if (pts > now) usleep(pts - now); } - +#if CONFIG_AVFILTER + frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || + !ist->out_video_filter || avfilter_poll_frame(ist->out_video_filter->inputs[0]); +#endif /* if output time reached then transcode raw format, encode packets and output them */ if (start_time == 0 || ist->pts >= start_time) +#if CONFIG_AVFILTER + while (frame_available) { + if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ist->out_video_filter) + get_filtered_video_pic(ist->out_video_filter, &ist->picref, &picture, &ist->pts); +#endif for(i=0;isync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE; if (ost->encoding_needed) { + assert(ist->decoding_needed); switch(ost->st->codec->codec_type) { - case CODEC_TYPE_AUDIO: - do_audio_out(os, ost, ist, data_buf, data_size); + case AVMEDIA_TYPE_AUDIO: + do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size); break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: +#if CONFIG_AVFILTER + ost->st->codec->sample_aspect_ratio = ist->picref->pixel_aspect; +#endif do_video_out(os, ost, ist, &picture, &frame_size); if (vstats_filename && frame_size) do_video_stats(os, ost, frame_size); break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: do_subtitle_out(os, ost, ist, &subtitle, pkt->pts); break; @@ -1459,7 +1723,7 @@ static int output_packet(AVInputStream *ist, int ist_index, av_init_packet(&opkt); - if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes) + if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes) continue; /* no reencoding needed : output the packet directly */ @@ -1467,11 +1731,11 @@ static int output_packet(AVInputStream *ist, int ist_index, avcodec_get_frame_defaults(&avframe); ost->st->codec->coded_frame= &avframe; - avframe.key_frame = pkt->flags & PKT_FLAG_KEY; + avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY; - if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO) + if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) audio_size += data_size; - else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) { + else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { video_size += data_size; ost->sync_opts++; } @@ -1492,9 +1756,12 @@ static int output_packet(AVInputStream *ist, int ist_index, opkt.flags= pkt->flags; //FIXME remove the following 2 lines they shall be replaced by the bitstream filters - if(ost->st->codec->codec_id != CODEC_ID_H264) { - if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY)) - opkt.destruct= av_destruct_packet; + if( ost->st->codec->codec_id != CODEC_ID_H264 + && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO + && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO + ) { + if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY)) + opkt.destruct= av_destruct_packet; } else { opkt.data = data_buf; opkt.size = data_size; @@ -1507,6 +1774,14 @@ static int output_packet(AVInputStream *ist, int ist_index, } } } + +#if CONFIG_AVFILTER + frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) && + ist->out_video_filter && avfilter_poll_frame(ist->out_video_filter->inputs[0]); + if(ist->picref) + avfilter_unref_pic(ist->picref); + } +#endif av_free(buffer_to_free); /* XXX: allocate the subtitles in the codec ? */ if (subtitle_to_free) { @@ -1532,9 +1807,9 @@ static int output_packet(AVInputStream *ist, int ist_index, AVCodecContext *enc= ost->st->codec; os = output_files[ost->file_index]; - if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1) + if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1) continue; - if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE)) + if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE)) continue; if (ost->encoding_needed) { @@ -1545,7 +1820,7 @@ static int output_packet(AVInputStream *ist, int ist_index, pkt.stream_index= ost->index; switch(ost->st->codec->codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: fifo_bytes = av_fifo_size(ost->fifo); ret = 0; /* encode any samples remaining in fifo */ @@ -1553,17 +1828,17 @@ static int output_packet(AVInputStream *ist, int ist_index, int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3; int fs_tmp = enc->frame_size; - av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL); + av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL); if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) { enc->frame_size = fifo_bytes / (osize * enc->channels); } else { /* pad */ int frame_bytes = enc->frame_size*osize*enc->channels; - if (samples_size < frame_bytes) + if (allocated_audio_buf_size < frame_bytes) av_exit(1); - memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes); + memset(audio_buf+fifo_bytes, 0, frame_bytes - fifo_bytes); } - ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples); + ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf); pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den, ost->st->time_base.num, enc->sample_rate); enc->frame_size = fs_tmp; @@ -1576,9 +1851,9 @@ static int output_packet(AVInputStream *ist, int ist_index, av_exit(1); } audio_size += ret; - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL); if (ret < 0) { fprintf(stderr, "Video encoding failed\n"); @@ -1586,7 +1861,7 @@ static int output_packet(AVInputStream *ist, int ist_index, } video_size += ret; if(enc->coded_frame && enc->coded_frame->key_frame) - pkt.flags |= PKT_FLAG_KEY; + pkt.flags |= AV_PKT_FLAG_KEY; if (ost->logfile && enc->stats_out) { fprintf(ost->logfile, "%s", enc->stats_out); } @@ -1622,40 +1897,55 @@ static void print_sdp(AVFormatContext **avc, int n) fflush(stdout); } -static int stream_index_from_inputs(AVFormatContext **input_files, - int nb_input_files, - AVInputFile *file_table, - AVInputStream **ist_table, - enum CodecType type, - int programid) +static int copy_chapters(int infile, int outfile) { - int p, q, z; - for(z=0; znb_programs; p++) { - AVProgram *program = ic->programs[p]; - if(program->id != programid) - continue; - for(q=0; qnb_stream_indexes; q++) { - int sidx = program->stream_index[q]; - int ris = file_table[z].ist_index + sidx; - if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type) - return ris; - } - } - } + AVFormatContext *is = input_files[infile]; + AVFormatContext *os = output_files[outfile]; + int i; - return -1; + for (i = 0; i < is->nb_chapters; i++) { + AVChapter *in_ch = is->chapters[i], *out_ch; + AVMetadataTag *t = NULL; + int64_t ts_off = av_rescale_q(start_time - input_files_ts_offset[infile], + AV_TIME_BASE_Q, in_ch->time_base); + int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX : + av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base); + + + if (in_ch->end < ts_off) + continue; + if (rt != INT64_MAX && in_ch->start > rt + ts_off) + break; + + out_ch = av_mallocz(sizeof(AVChapter)); + if (!out_ch) + return AVERROR(ENOMEM); + + out_ch->id = in_ch->id; + out_ch->time_base = in_ch->time_base; + out_ch->start = FFMAX(0, in_ch->start - ts_off); + out_ch->end = FFMIN(rt, in_ch->end - ts_off); + + while ((t = av_metadata_get(in_ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) + av_metadata_set2(&out_ch->metadata, t->key, t->value, 0); + + os->nb_chapters++; + os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters); + if (!os->chapters) + return AVERROR(ENOMEM); + os->chapters[os->nb_chapters - 1] = out_ch; + } + return 0; } /* * The following code is the main loop of the file converter */ -static int av_encode(AVFormatContext **output_files, - int nb_output_files, - AVFormatContext **input_files, - int nb_input_files, - AVStreamMap *stream_maps, int nb_stream_maps) +static int av_transcode(AVFormatContext **output_files, + int nb_output_files, + AVFormatContext **input_files, + int nb_input_files, + AVStreamMap *stream_maps, int nb_stream_maps) { int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0; AVFormatContext *is, *os; @@ -1779,33 +2069,42 @@ static int av_encode(AVFormatContext **output_files, } } else { - if(opt_programid) { - found = 0; - j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid); - if(j != -1) { - ost->source_index = j; - found = 1; - } - } else { + int best_nb_frames=-1; /* get corresponding input stream index : we select the first one with the right type */ found = 0; for(j=0;jdiscard && + if(opt_programid){ + int pi,si; + AVFormatContext *f= input_files[ ist->file_index ]; + skip=1; + for(pi=0; pinb_programs; pi++){ + AVProgram *p= f->programs[pi]; + if(p->id == opt_programid) + for(si=0; sinb_stream_indexes; si++){ + if(f->streams[ p->stream_index[si] ] == ist->st) + skip=0; + } + } + } + if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip && ist->st->codec->codec_type == ost->st->codec->codec_type) { - ost->source_index = j; - found = 1; - break; + if(best_nb_frames < ist->st->codec_info_nb_frames){ + best_nb_frames= ist->st->codec_info_nb_frames; + ost->source_index = j; + found = 1; + } } } - } if (!found) { if(! opt_programid) { /* try again and reuse existing stream */ for(j=0;jst->codec->codec_type == ost->st->codec->codec_type) { + if ( ist->st->codec->codec_type == ost->st->codec->codec_type + && ist->st->discard != AVDISCARD_ALL) { ost->source_index = j; found = 1; } @@ -1830,7 +2129,7 @@ static int av_encode(AVFormatContext **output_files, /* for each output stream, we compute the right encoding parameters */ for(i=0;ifile_index]; ist = ist_table[ost->source_index]; @@ -1838,36 +2137,46 @@ static int av_encode(AVFormatContext **output_files, codec = ost->st->codec; icodec = ist->st->codec; - if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0)) - && !av_metadata_get(ost->st->metadata, "language", NULL, 0)) - av_metadata_set(&ost->st->metadata, "language", lang->value); + while ((t = av_metadata_get(ist->st->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) { + av_metadata_set2(&ost->st->metadata, t->key, t->value, AV_METADATA_DONT_OVERWRITE); + } ost->st->disposition = ist->st->disposition; codec->bits_per_raw_sample= icodec->bits_per_raw_sample; codec->chroma_sample_location = icodec->chroma_sample_location; if (ost->st->stream_copy) { + uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE; + + if (extra_size > INT_MAX) + goto fail; + /* if stream_copy is selected, no need to decode or encode */ codec->codec_id = icodec->codec_id; codec->codec_type = icodec->codec_type; if(!codec->codec_tag){ if( !os->oformat->codec_tag - || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0 + || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0) codec->codec_tag = icodec->codec_tag; } codec->bit_rate = icodec->bit_rate; - codec->extradata= icodec->extradata; + codec->extradata= av_mallocz(extra_size); + if (!codec->extradata) + goto fail; + memcpy(codec->extradata, icodec->extradata, icodec->extradata_size); codec->extradata_size= icodec->extradata_size; if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){ codec->time_base = icodec->time_base; codec->time_base.num *= icodec->ticks_per_frame; + av_reduce(&codec->time_base.num, &codec->time_base.den, + codec->time_base.num, codec->time_base.den, INT_MAX); }else codec->time_base = ist->st->time_base; switch(codec->codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: if(audio_volume != 256) { fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n"); av_exit(1); @@ -1882,13 +2191,13 @@ static int av_encode(AVFormatContext **output_files, if(codec->codec_id == CODEC_ID_AC3) codec->block_align= 0; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: codec->pix_fmt = icodec->pix_fmt; codec->width = icodec->width; codec->height = icodec->height; codec->has_b_frames = icodec->has_b_frames; break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: codec->width = icodec->width; codec->height = icodec->height; break; @@ -1897,7 +2206,7 @@ static int av_encode(AVFormatContext **output_files, } } else { switch(codec->codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: ost->fifo= av_fifo_alloc(1024); if(!ost->fifo) goto fail; @@ -1907,19 +2216,16 @@ static int av_encode(AVFormatContext **output_files, ist->decoding_needed = 1; ost->encoding_needed = 1; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: if (ost->st->codec->pix_fmt == PIX_FMT_NONE) { - fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n"); + fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n"); av_exit(1); } ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0); - ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0); ost->video_resample = ((codec->width != icodec->width - - (frame_leftBand + frame_rightBand) + - (frame_padleft + frame_padright)) || + (frame_leftBand + frame_rightBand)) || (codec->height != icodec->height - - (frame_topBand + frame_bottomBand) + - (frame_padtop + frame_padbottom)) || + (frame_topBand + frame_bottomBand)) || (codec->pix_fmt != icodec->pix_fmt)); if (ost->video_crop) { ost->topBand = ost->original_topBand = frame_topBand; @@ -1927,18 +2233,6 @@ static int av_encode(AVFormatContext **output_files, ost->leftBand = ost->original_leftBand = frame_leftBand; ost->rightBand = ost->original_rightBand = frame_rightBand; } - if (ost->video_pad) { - ost->padtop = frame_padtop; - ost->padleft = frame_padleft; - ost->padbottom = frame_padbottom; - ost->padright = frame_padright; - if (!ost->video_resample) { - avcodec_get_frame_defaults(&ost->pict_tmp); - if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, - codec->width, codec->height)) - goto fail; - } - } if (ost->video_resample) { avcodec_get_frame_defaults(&ost->pict_tmp); if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt, @@ -1951,8 +2245,8 @@ static int av_encode(AVFormatContext **output_files, icodec->width - (frame_leftBand + frame_rightBand), icodec->height - (frame_topBand + frame_bottomBand), icodec->pix_fmt, - codec->width - (frame_padleft + frame_padright), - codec->height - (frame_padtop + frame_padbottom), + codec->width, + codec->height, codec->pix_fmt, sws_flags, NULL, NULL, NULL); if (ost->img_resample_ctx == NULL) { @@ -1960,9 +2254,10 @@ static int av_encode(AVFormatContext **output_files, av_exit(1); } +#if !CONFIG_AVFILTER ost->original_height = icodec->height; ost->original_width = icodec->width; - +#endif codec->bits_per_raw_sample= 0; } ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand); @@ -1970,8 +2265,15 @@ static int av_encode(AVFormatContext **output_files, ost->resample_pix_fmt= icodec->pix_fmt; ost->encoding_needed = 1; ist->decoding_needed = 1; + +#if CONFIG_AVFILTER + if (configure_filters(ist, ost)) { + fprintf(stderr, "Error opening filters!\n"); + exit(1); + } +#endif break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: ost->encoding_needed = 1; ist->decoding_needed = 1; break; @@ -1984,42 +2286,29 @@ static int av_encode(AVFormatContext **output_files, (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) { char logfilename[1024]; FILE *f; - int size; - char *logbuffer; snprintf(logfilename, sizeof(logfilename), "%s-%d.log", pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX, i); if (codec->flags & CODEC_FLAG_PASS1) { - f = fopen(logfilename, "w"); + f = fopen(logfilename, "wb"); if (!f) { fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno)); av_exit(1); } ost->logfile = f; } else { - /* read the log file */ - f = fopen(logfilename, "r"); - if (!f) { - fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno)); - av_exit(1); - } - fseek(f, 0, SEEK_END); - size = ftell(f); - fseek(f, 0, SEEK_SET); - logbuffer = av_malloc(size + 1); - if (!logbuffer) { - fprintf(stderr, "Could not allocate log buffer\n"); + char *logbuffer; + size_t logbuffer_size; + if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) { + fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename); av_exit(1); } - size = fread(logbuffer, 1, size, f); - fclose(f); - logbuffer[size] = '\0'; codec->stats_in = logbuffer; } } } - if(codec->codec_type == CODEC_TYPE_VIDEO){ + if(codec->codec_type == AVMEDIA_TYPE_VIDEO){ int size= codec->width * codec->height; bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200); } @@ -2076,15 +2365,17 @@ static int av_encode(AVFormatContext **output_files, ret = AVERROR(EINVAL); goto dump_format; } - //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) + //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD; } } /* init pts */ for(i=0;ipts = 0; + st= ist->st; + ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0; ist->next_pts = AV_NOPTS_VALUE; ist->is_start = 1; } @@ -2116,11 +2407,21 @@ static int av_encode(AVFormatContext **output_files, mtag=NULL; while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX))) - av_metadata_set(&out_file->metadata, mtag->key, mtag->value); + av_metadata_set2(&out_file->metadata, mtag->key, mtag->value, AV_METADATA_DONT_OVERWRITE); av_metadata_conv(out_file, out_file->oformat->metadata_conv, in_file->iformat->metadata_conv); } + /* copy chapters from the first input file that has them*/ + for (i = 0; i < nb_input_files; i++) { + if (!input_files[i]->nb_chapters) + continue; + + for (j = 0; j < nb_output_files; j++) + if ((ret = copy_chapters(i, j)) < 0) + goto dump_format; + } + /* open files and write file headers */ for(i=0;ifile_index]; ist = ist_table[ost->source_index]; - if(no_packet[ist->file_index]) + if(ist->is_past_recording_time || no_packet[ist->file_index]) continue; - if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO) - opts = ost->sync_opts * av_q2d(ost->st->codec->time_base); - else opts = ost->st->pts.val * av_q2d(ost->st->time_base); ipts = (double)ist->pts; if (!file_table[ist->file_index].eof_reached){ @@ -2236,10 +2534,6 @@ static int av_encode(AVFormatContext **output_files, break; } - /* finish if recording time exhausted */ - if (opts_min >= (recording_time / 1000000.0)) - break; - /* finish if limit size exhausted */ if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb)) break; @@ -2302,6 +2596,13 @@ static int av_encode(AVFormatContext **output_files, } } + /* finish if recording time exhausted */ + if (recording_time != INT64_MAX && + av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) { + ist->is_past_recording_time = 1; + goto discard_packet; + } + //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size); if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) { @@ -2356,6 +2657,12 @@ static int av_encode(AVFormatContext **output_files, avcodec_close(ist->st->codec); } } +#if CONFIG_AVFILTER + if (graph) { + avfilter_graph_destroy(graph); + av_freep(&graph); + } +#endif /* finished ! */ ret = 0; @@ -2375,6 +2682,8 @@ static int av_encode(AVFormatContext **output_files, for(i=0;ist->stream_copy) + av_freep(&ost->st->codec->extradata); if (ost->logfile) { fclose(ost->logfile); ost->logfile = NULL; @@ -2437,7 +2746,7 @@ static int opt_frame_rate(const char *opt, const char *arg) static int opt_bitrate(const char *opt, const char *arg) { - int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO; + int codec_type = opt[0]=='a' ? AVMEDIA_TYPE_AUDIO : AVMEDIA_TYPE_VIDEO; opt_default(opt, arg); @@ -2458,6 +2767,7 @@ static void opt_frame_crop_top(const char *arg) fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); av_exit(1); } + fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n"); frame_height -= frame_topBand; } @@ -2472,6 +2782,7 @@ static void opt_frame_crop_bottom(const char *arg) fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); av_exit(1); } + fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n"); frame_height -= frame_bottomBand; } @@ -2486,6 +2797,7 @@ static void opt_frame_crop_left(const char *arg) fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); av_exit(1); } + fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n"); frame_width -= frame_leftBand; } @@ -2500,6 +2812,7 @@ static void opt_frame_crop_right(const char *arg) fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n"); av_exit(1); } + fprintf(stderr, "-crop* is deprecated in favor of the crop avfilter\n"); frame_width -= frame_rightBand; } @@ -2511,69 +2824,21 @@ static void opt_frame_size(const char *arg) } } -static void opt_pad_color(const char *arg) { - /* Input is expected to be six hex digits similar to - how colors are expressed in html tags (but without the #) */ - int rgb = strtol(arg, NULL, 16); - int r,g,b; - - r = (rgb >> 16); - g = ((rgb >> 8) & 255); - b = (rgb & 255); - - padcolor[0] = RGB_TO_Y(r,g,b); - padcolor[1] = RGB_TO_U(r,g,b,0); - padcolor[2] = RGB_TO_V(r,g,b,0); -} - -static void opt_frame_pad_top(const char *arg) -{ - frame_padtop = atoi(arg); - if (frame_padtop < 0) { - fprintf(stderr, "Incorrect top pad size\n"); - av_exit(1); - } -} - -static void opt_frame_pad_bottom(const char *arg) -{ - frame_padbottom = atoi(arg); - if (frame_padbottom < 0) { - fprintf(stderr, "Incorrect bottom pad size\n"); - av_exit(1); - } -} - - -static void opt_frame_pad_left(const char *arg) -{ - frame_padleft = atoi(arg); - if (frame_padleft < 0) { - fprintf(stderr, "Incorrect left pad size\n"); - av_exit(1); - } -} - - -static void opt_frame_pad_right(const char *arg) -{ - frame_padright = atoi(arg); - if (frame_padright < 0) { - fprintf(stderr, "Incorrect right pad size\n"); - av_exit(1); - } +static int opt_pad(const char *opt, const char *arg) { + fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt); + return -1; } static void opt_frame_pix_fmt(const char *arg) { if (strcmp(arg, "list")) { - frame_pix_fmt = avcodec_get_pix_fmt(arg); + frame_pix_fmt = av_get_pix_fmt(arg); if (frame_pix_fmt == PIX_FMT_NONE) { fprintf(stderr, "Unknown pixel format requested: %s\n", arg); av_exit(1); } } else { - list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB); + show_pix_fmts(); av_exit(0); } } @@ -2690,7 +2955,7 @@ static void opt_codec(int *pstream_copy, char **pcodec_name, static void opt_audio_codec(const char *arg) { - opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg); + opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg); } static void opt_audio_tag(const char *arg) @@ -2713,12 +2978,12 @@ static void opt_video_tag(const char *arg) static void opt_video_codec(const char *arg) { - opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg); + opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg); } static void opt_subtitle_codec(const char *arg) { - opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg); + opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg); } static void opt_subtitle_tag(const char *arg) @@ -2797,9 +3062,9 @@ static int opt_start_time(const char *opt, const char *arg) return 0; } -static int opt_rec_timestamp(const char *opt, const char *arg) +static int opt_recording_timestamp(const char *opt, const char *arg) { - rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000; + recording_timestamp = parse_time_or_die(opt, arg, 0) / 1000000; return 0; } @@ -2809,7 +3074,7 @@ static int opt_input_ts_offset(const char *opt, const char *arg) return 0; } -static enum CodecID find_codec_or_die(const char *name, int type, int encoder) +static enum CodecID find_codec_or_die(const char *name, int type, int encoder, int strict) { const char *codec_string = encoder ? "encoder" : "decoder"; AVCodec *codec; @@ -2827,6 +3092,19 @@ static enum CodecID find_codec_or_die(const char *name, int type, int encoder) fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name); av_exit(1); } + if(codec->capabilities & CODEC_CAP_EXPERIMENTAL && + strict > FF_COMPLIANCE_EXPERIMENTAL) { + fprintf(stderr, "%s '%s' is experimental and might produce bad " + "results.\nAdd '-strict experimental' if you want to use it.\n", + codec_string, codec->name); + codec = encoder ? + avcodec_find_encoder(codec->id) : + avcodec_find_decoder(codec->id); + if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL)) + fprintf(stderr, "Or use the non experimental %s '%s'.\n", + codec_string, codec->name); + av_exit(1); + } return codec->id; } @@ -2839,7 +3117,10 @@ static void opt_input_file(const char *filename) int64_t timestamp; if (last_asked_format) { - file_iformat = av_find_input_format(last_asked_format); + if (!(file_iformat = av_find_input_format(last_asked_format))) { + fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format); + av_exit(1); + } last_asked_format = NULL; } @@ -2862,24 +3143,29 @@ static void opt_input_file(const char *filename) ap->channels = audio_channels; ap->time_base.den = frame_rate.num; ap->time_base.num = frame_rate.den; - ap->width = frame_width + frame_padleft + frame_padright; - ap->height = frame_height + frame_padtop + frame_padbottom; + ap->width = frame_width; + ap->height = frame_height; ap->pix_fmt = frame_pix_fmt; // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat ap->channel = video_channel; ap->standard = video_standard; - ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0); - ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0); - if(pgmyuv_compatibility_hack) - ap->video_codec_id= CODEC_ID_PGMYUV; set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM); - ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0); - ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0); - ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0); + ic->video_codec_id = + find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0, + avcodec_opts[AVMEDIA_TYPE_VIDEO ]->strict_std_compliance); + ic->audio_codec_id = + find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0, + avcodec_opts[AVMEDIA_TYPE_AUDIO ]->strict_std_compliance); + ic->subtitle_codec_id= + find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0, + avcodec_opts[AVMEDIA_TYPE_SUBTITLE]->strict_std_compliance); ic->flags |= AVFMT_FLAG_NONBLOCK; + if(pgmyuv_compatibility_hack) + ic->video_codec_id= CODEC_ID_PGMYUV; + /* open the input file with generic libav function */ err = av_open_input_file(&ic, filename, file_iformat, 0, ap); if (err < 0) { @@ -2887,10 +3173,27 @@ static void opt_input_file(const char *filename) av_exit(1); } if(opt_programid) { - int i; - for(i=0; inb_programs; i++) - if(ic->programs[i]->id != opt_programid) - ic->programs[i]->discard = AVDISCARD_ALL; + int i, j; + int found=0; + for(i=0; inb_streams; i++){ + ic->streams[i]->discard= AVDISCARD_ALL; + } + for(i=0; inb_programs; i++){ + AVProgram *p= ic->programs[i]; + if(p->id != opt_programid){ + p->discard = AVDISCARD_ALL; + }else{ + found=1; + for(j=0; jnb_stream_indexes; j++){ + ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT; + } + } + } + if(!found){ + fprintf(stderr, "Specified program id not found\n"); + av_exit(1); + } + opt_programid=0; } ic->loop_input = loop_input; @@ -2900,6 +3203,7 @@ static void opt_input_file(const char *filename) ret = av_find_stream_info(ic); if (ret < 0 && verbose >= 0) { fprintf(stderr, "%s: could not find codec parameters\n", filename); + av_close_input_file(ic); av_exit(1); } @@ -2923,12 +3227,10 @@ static void opt_input_file(const char *filename) for(i=0;inb_streams;i++) { AVStream *st = ic->streams[i]; AVCodecContext *enc = st->codec; - if(thread_count>1) - avcodec_thread_init(enc, thread_count); - enc->thread_count= thread_count; + avcodec_thread_init(enc, thread_count); switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: - set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM); + case AVMEDIA_TYPE_AUDIO: + set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM); //fprintf(stderr, "\nInput Audio channels: %d", enc->channels); channel_layout = enc->channel_layout; audio_channels = enc->channels; @@ -2938,8 +3240,8 @@ static void opt_input_file(const char *filename) if(audio_disable) st->discard= AVDISCARD_ALL; break; - case CODEC_TYPE_VIDEO: - set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM); + case AVMEDIA_TYPE_VIDEO: + set_context_opts(enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM); frame_height = enc->height; frame_width = enc->width; if(ic->streams[i]->sample_aspect_ratio.num) @@ -2958,7 +3260,7 @@ static void opt_input_file(const char *filename) if(me_threshold) enc->debug |= FF_DEBUG_MV; - if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) { + if (enc->time_base.den != rfps*enc->ticks_per_frame || enc->time_base.num != rfps_base) { if (verbose >= 0) fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n", @@ -2976,15 +3278,15 @@ static void opt_input_file(const char *filename) else if(video_discard) st->discard= video_discard; break; - case CODEC_TYPE_DATA: + case AVMEDIA_TYPE_DATA: break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name); if(subtitle_disable) st->discard = AVDISCARD_ALL; break; - case CODEC_TYPE_ATTACHMENT: - case CODEC_TYPE_UNKNOWN: + case AVMEDIA_TYPE_ATTACHMENT: + case AVMEDIA_TYPE_UNKNOWN: nb_icodecs++; break; default: @@ -3021,18 +3323,18 @@ static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr, for(i=0;inb_streams;i++) { AVCodecContext *enc = ic->streams[i]->codec; switch(enc->codec_type) { - case CODEC_TYPE_AUDIO: + case AVMEDIA_TYPE_AUDIO: has_audio = 1; break; - case CODEC_TYPE_VIDEO: + case AVMEDIA_TYPE_VIDEO: has_video = 1; break; - case CODEC_TYPE_SUBTITLE: + case AVMEDIA_TYPE_SUBTITLE: has_subtitle = 1; break; - case CODEC_TYPE_DATA: - case CODEC_TYPE_ATTACHMENT: - case CODEC_TYPE_UNKNOWN: + case AVMEDIA_TYPE_DATA: + case AVMEDIA_TYPE_ATTACHMENT: + case AVMEDIA_TYPE_UNKNOWN: break; default: abort(); @@ -3050,17 +3352,16 @@ static void new_video_stream(AVFormatContext *oc) AVCodecContext *video_enc; enum CodecID codec_id; - st = av_new_stream(oc, oc->nb_streams); + st = av_new_stream(oc, streamid_map[oc->nb_streams]); if (!st) { fprintf(stderr, "Could not alloc stream\n"); av_exit(1); } - avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO); + avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_VIDEO); bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters; video_bitstream_filters= NULL; - if(thread_count>1) - avcodec_thread_init(st->codec, thread_count); + avcodec_thread_init(st->codec, thread_count); video_enc = st->codec; @@ -3070,16 +3371,16 @@ static void new_video_stream(AVFormatContext *oc) if( (video_global_header&1) || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){ video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; - avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER; + avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER; } if(video_global_header&2){ video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER; - avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER; + avcodec_opts[AVMEDIA_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER; } if (video_stream_copy) { st->stream_copy = 1; - video_enc->codec_type = CODEC_TYPE_VIDEO; + video_enc->codec_type = AVMEDIA_TYPE_VIDEO; video_enc->sample_aspect_ratio = st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255); } else { @@ -3089,38 +3390,31 @@ static void new_video_stream(AVFormatContext *oc) AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1}; if (video_codec_name) { - codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1); + codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1, + video_enc->strict_std_compliance); codec = avcodec_find_encoder_by_name(video_codec_name); output_codecs[nb_ocodecs] = codec; } else { - codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO); + codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO); codec = avcodec_find_encoder(codec_id); } video_enc->codec_id = codec_id; - set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); + set_context_opts(video_enc, avcodec_opts[AVMEDIA_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); if (codec && codec->supported_framerates && !force_fps) fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)]; video_enc->time_base.den = fps.num; video_enc->time_base.num = fps.den; - video_enc->width = frame_width + frame_padright + frame_padleft; - video_enc->height = frame_height + frame_padtop + frame_padbottom; + video_enc->width = frame_width; + video_enc->height = frame_height; video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255); video_enc->pix_fmt = frame_pix_fmt; st->sample_aspect_ratio = video_enc->sample_aspect_ratio; - if(codec && codec->pix_fmts){ - const enum PixelFormat *p= codec->pix_fmts; - for(; *p!=-1; p++){ - if(*p == video_enc->pix_fmt) - break; - } - if(*p == -1) - video_enc->pix_fmt = codec->pix_fmts[0]; - } + choose_pixel_fmt(st, codec); if (intra_only) video_enc->gop_size = 0; @@ -3135,7 +3429,6 @@ static void new_video_stream(AVFormatContext *oc) if(inter_matrix) video_enc->inter_matrix = inter_matrix; - video_enc->thread_count = thread_count; p= video_rc_override_string; for(i=0; p; i++){ int start, end, q; @@ -3179,11 +3472,16 @@ static void new_video_stream(AVFormatContext *oc) } } nb_ocodecs++; + if (video_language) { + av_metadata_set2(&st->metadata, "language", video_language, 0); + av_freep(&video_language); + } /* reset some key parameters */ video_disable = 0; av_freep(&video_codec_name); video_stream_copy = 0; + frame_pix_fmt = PIX_FMT_NONE; } static void new_audio_stream(AVFormatContext *oc) @@ -3192,43 +3490,44 @@ static void new_audio_stream(AVFormatContext *oc) AVCodecContext *audio_enc; enum CodecID codec_id; - st = av_new_stream(oc, oc->nb_streams); + st = av_new_stream(oc, streamid_map[oc->nb_streams]); if (!st) { fprintf(stderr, "Could not alloc stream\n"); av_exit(1); } - avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO); + avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_AUDIO); bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters; audio_bitstream_filters= NULL; - if(thread_count>1) - avcodec_thread_init(st->codec, thread_count); + avcodec_thread_init(st->codec, thread_count); audio_enc = st->codec; - audio_enc->codec_type = CODEC_TYPE_AUDIO; + audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; if(audio_codec_tag) audio_enc->codec_tag= audio_codec_tag; if (oc->oformat->flags & AVFMT_GLOBALHEADER) { audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER; - avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER; + avcodec_opts[AVMEDIA_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER; } if (audio_stream_copy) { st->stream_copy = 1; audio_enc->channels = audio_channels; + audio_enc->sample_rate = audio_sample_rate; } else { AVCodec *codec; - set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); + set_context_opts(audio_enc, avcodec_opts[AVMEDIA_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM); if (audio_codec_name) { - codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1); + codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1, + audio_enc->strict_std_compliance); codec = avcodec_find_encoder_by_name(audio_codec_name); output_codecs[nb_ocodecs] = codec; } else { - codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO); + codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO); codec = avcodec_find_encoder(codec_id); } audio_enc->codec_id = codec_id; @@ -3237,28 +3536,19 @@ static void new_audio_stream(AVFormatContext *oc) audio_enc->flags |= CODEC_FLAG_QSCALE; audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale; } - audio_enc->thread_count = thread_count; audio_enc->channels = audio_channels; audio_enc->sample_fmt = audio_sample_fmt; + audio_enc->sample_rate = audio_sample_rate; audio_enc->channel_layout = channel_layout; if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels) audio_enc->channel_layout = 0; - - if(codec && codec->sample_fmts){ - const enum SampleFormat *p= codec->sample_fmts; - for(; *p!=-1; p++){ - if(*p == audio_enc->sample_fmt) - break; - } - if(*p == -1) - audio_enc->sample_fmt = codec->sample_fmts[0]; - } + choose_sample_fmt(st, codec); + choose_sample_rate(st, codec); } nb_ocodecs++; - audio_enc->sample_rate = audio_sample_rate; audio_enc->time_base= (AVRational){1, audio_sample_rate}; if (audio_language) { - av_metadata_set(&st->metadata, "language", audio_language); + av_metadata_set2(&st->metadata, "language", audio_language, 0); av_freep(&audio_language); } @@ -3273,18 +3563,18 @@ static void new_subtitle_stream(AVFormatContext *oc) AVStream *st; AVCodecContext *subtitle_enc; - st = av_new_stream(oc, oc->nb_streams); + st = av_new_stream(oc, streamid_map[oc->nb_streams]); if (!st) { fprintf(stderr, "Could not alloc stream\n"); av_exit(1); } - avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE); + avcodec_get_context_defaults2(st->codec, AVMEDIA_TYPE_SUBTITLE); bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters; subtitle_bitstream_filters= NULL; subtitle_enc = st->codec; - subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE; + subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE; if(subtitle_codec_tag) subtitle_enc->codec_tag= subtitle_codec_tag; @@ -3292,14 +3582,15 @@ static void new_subtitle_stream(AVFormatContext *oc) if (subtitle_stream_copy) { st->stream_copy = 1; } else { - set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM); - subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1); + set_context_opts(avcodec_opts[AVMEDIA_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM); + subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1, + subtitle_enc->strict_std_compliance); output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name); } nb_ocodecs++; if (subtitle_language) { - av_metadata_set(&st->metadata, "language", subtitle_language); + av_metadata_set2(&st->metadata, "language", subtitle_language, 0); av_freep(&subtitle_language); } @@ -3341,10 +3632,31 @@ static void opt_new_subtitle_stream(void) new_subtitle_stream(oc); } +/* arg format is "output-stream-index:streamid-value". */ +static void opt_streamid(const char *opt, const char *arg) +{ + int idx; + char *p; + char idx_str[16]; + + strncpy(idx_str, arg, sizeof(idx_str)); + idx_str[sizeof(idx_str)-1] = '\0'; + p = strchr(idx_str, ':'); + if (!p) { + fprintf(stderr, + "Invalid value '%s' for option '%s', required syntax is 'index:value'\n", + arg, opt); + av_exit(1); + } + *p++ = '\0'; + idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1); + streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX); +} + static void opt_output_file(const char *filename) { AVFormatContext *oc; - int use_video, use_audio, use_subtitle; + int err, use_video, use_audio, use_subtitle; int input_has_video, input_has_audio, input_has_subtitle; AVFormatParameters params, *ap = ¶ms; AVOutputFormat *file_oformat; @@ -3359,14 +3671,14 @@ static void opt_output_file(const char *filename) } if (last_asked_format) { - file_oformat = guess_format(last_asked_format, NULL, NULL); + file_oformat = av_guess_format(last_asked_format, NULL, NULL); if (!file_oformat) { fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format); av_exit(1); } last_asked_format = NULL; } else { - file_oformat = guess_format(NULL, filename, NULL); + file_oformat = av_guess_format(NULL, filename, NULL); if (!file_oformat) { fprintf(stderr, "Unable to find a suitable output format for '%s'\n", filename); @@ -3427,11 +3739,11 @@ static void opt_output_file(const char *filename) new_subtitle_stream(oc); } - oc->timestamp = rec_timestamp; + oc->timestamp = recording_timestamp; for(; metadata_count>0; metadata_count--){ - av_metadata_set(&oc->metadata, metadata[metadata_count-1].key, - metadata[metadata_count-1].value); + av_metadata_set2(&oc->metadata, metadata[metadata_count-1].key, + metadata[metadata_count-1].value, 0); } av_metadata_conv(oc, oc->oformat->metadata_conv, NULL); } @@ -3469,8 +3781,8 @@ static void opt_output_file(const char *filename) } /* open the file */ - if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) { - fprintf(stderr, "Could not open '%s'\n", filename); + if ((err = url_fopen(&oc->pb, filename, URL_WRONLY)) < 0) { + print_error(filename, err); av_exit(1); } } @@ -3488,6 +3800,8 @@ static void opt_output_file(const char *filename) oc->flags |= AVFMT_FLAG_NONBLOCK; set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM); + + memset(streamid_map, 0, sizeof(streamid_map)); } /* same option as mencoder */ @@ -3520,6 +3834,24 @@ static int64_t getutime(void) #endif } +static int64_t getmaxrss(void) +{ +#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS + struct rusage rusage; + getrusage(RUSAGE_SELF, &rusage); + return (int64_t)rusage.ru_maxrss * 1024; +#elif HAVE_GETPROCESSMEMORYINFO + HANDLE proc; + PROCESS_MEMORY_COUNTERS memcounters; + proc = GetCurrentProcess(); + memcounters.cb = sizeof(memcounters); + GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters)); + return memcounters.PeakPagefileUsage; +#else + return 0; +#endif +} + static void parse_matrix_coeffs(uint16_t *dest, const char *str) { int i; @@ -3558,12 +3890,17 @@ static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl) vfprintf(stdout, fmt, vl); } +static void show_usage(void) +{ + printf("Hyper fast Audio and Video encoder\n"); + printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n"); + printf("\n"); +} + static void show_help(void) { av_log_set_callback(log_callback_help); - printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n" - "Hyper fast Audio and Video encoder\n"); - printf("\n"); + show_usage(); show_help_options(options, "Main options:\n", OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0); show_help_options(options, "\nAdvanced options:\n", @@ -3624,7 +3961,7 @@ static void opt_target(const char *arg) for(j = 0; j < nb_input_files; j++) { for(i = 0; i < input_files[j]->nb_streams; i++) { AVCodecContext *c = input_files[j]->streams[i]->codec; - if(c->codec_type != CODEC_TYPE_VIDEO) + if(c->codec_type != AVMEDIA_TYPE_VIDEO) continue; fr = c->time_base.den * 1000 / c->time_base.num; if(fr == 25000) { @@ -3726,7 +4063,7 @@ static void opt_target(const char *arg) opt_format("dv"); - opt_frame_size(norm != PAL ? "720x480" : "720x576"); + opt_frame_size(norm == PAL ? "720x576" : "720x480"); opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" : (norm == PAL ? "yuv420p" : "yuv411p")); opt_frame_rate(NULL, frame_rates[norm]); @@ -3783,19 +4120,22 @@ static int opt_preset(const char *opt, const char *arg) FILE *f=NULL; char filename[1000], tmp[1000], tmp2[1000], line[1000]; int i; - const char *base[2]= { getenv("HOME"), + const char *base[3]= { getenv("FFMPEG_DATADIR"), + getenv("HOME"), FFMPEG_DATADIR, }; if (*opt != 'f') { - for(i=!base[0]; i<2 && !f; i++){ - snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg); + for(i=0; i<3 && !f; i++){ + if(!base[i]) + continue; + snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", arg); f= fopen(filename, "r"); if(!f){ char *codec_name= *opt == 'v' ? video_codec_name : *opt == 'a' ? audio_codec_name : subtitle_codec_name; - snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg); + snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i != 1 ? "" : "/.ffmpeg", codec_name, arg); f= fopen(filename, "r"); } } @@ -3848,11 +4188,12 @@ static const OptionDef options[] = { { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" }, { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" }, { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" }, - { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" }, + { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" }, { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" }, - { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" }, + { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" }, { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark}, "add timings for benchmarking" }, + { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" }, { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump}, "dump each input packet" }, { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump}, @@ -3877,20 +4218,20 @@ static const OptionDef options[] = { /* video options */ { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, - { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" }, + { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" }, { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" }, { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" }, { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" }, { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" }, - { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" }, - { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" }, - { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" }, - { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" }, - { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" }, - { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" }, - { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" }, - { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" }, - { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" }, + { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "Deprecated, please use the crop avfilter", "size" }, + { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "Deprecated, please use the crop avfilter", "size" }, + { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "Deprecated, please use the crop avfilter", "size" }, + { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "Deprecated, please use the crop avfilter", "size" }, + { "padtop", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, + { "padbottom", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, + { "padleft", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, + { "padright", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" }, + { "padcolor", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" }, { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"}, { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" }, { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" }, @@ -3907,18 +4248,23 @@ static const OptionDef options[] = { { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" }, { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" }, { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" }, +#if CONFIG_AVFILTER + { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" }, +#endif { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" }, { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" }, { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" }, { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" }, { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" }, { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" }, + { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" }, { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" }, { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" }, + { "streamid", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" }, /* audio options */ { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" }, - { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" }, + { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" }, { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", }, { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" }, { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" }, @@ -3965,7 +4311,12 @@ int main(int argc, char **argv) int64_t ti; avcodec_register_all(); +#if CONFIG_AVDEVICE avdevice_register_all(); +#endif +#if CONFIG_AVFILTER + avfilter_register_all(); +#endif av_register_all(); #if HAVE_ISATTY @@ -3973,7 +4324,7 @@ int main(int argc, char **argv) url_set_interrupt_cb(decode_interrupt_cb); #endif - for(i=0; i