diff options
Diffstat (limited to 'ffmpeg.c')
-rw-r--r-- | ffmpeg.c | 925 |
1 files changed, 386 insertions, 539 deletions
@@ -96,6 +96,9 @@ #define VSYNC_VFR 2 #define VSYNC_DROP 0xff +// #define SRCA +#define SINKA + const char program_name[] = "ffmpeg"; const int program_birth_year = 2000; @@ -167,11 +170,6 @@ static int print_stats = 1; static int debug_ts = 0; static int current_time; -static uint8_t *audio_buf; -static unsigned int allocated_audio_buf_size; -static uint8_t *async_buf; -static unsigned int allocated_async_buf_size; - #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass" typedef struct InputFilter { @@ -241,6 +239,11 @@ typedef struct InputStream { int resample_width; int resample_pix_fmt; + int resample_sample_fmt; + int resample_sample_rate; + int resample_channels; + uint64_t resample_channel_layout; + /* a pool of free buffers for decoded data */ FrameBuffer *buffer_pool; int dr1; @@ -276,7 +279,6 @@ typedef struct OutputStream { AVBitStreamFilterContext *bitstream_filters; AVCodec *enc; int64_t max_frames; - AVFrame *output_frame; AVFrame *filtered_frame; /* video only */ @@ -292,20 +294,8 @@ typedef struct OutputStream { int forced_kf_count; int forced_kf_index; - /* audio only */ - int audio_resample; - int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream - int audio_channels_mapped; ///< number of channels in audio_channels_map - int resample_sample_fmt; - int resample_channels; - uint64_t resample_channel_layout; - int resample_sample_rate; - float rematrix_volume; - AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */ FILE *logfile; - SwrContext *swr; - OutputFilter *filter; char *avfilter; @@ -363,8 +353,6 @@ typedef struct OptionsContext { int nb_audio_channels; SpecifierOpt *audio_sample_rate; int nb_audio_sample_rate; - SpecifierOpt *rematrix_volume; - int nb_rematrix_volume; SpecifierOpt *frame_rates; int nb_frame_rates; SpecifierOpt *frame_sizes; @@ -705,9 +693,9 @@ static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum Pixe return target; } -static char *choose_pixel_fmts(OutputStream *ost) +static char *choose_pix_fmts(OutputStream *ost) { - if (ost->keep_pix_fmt) { + if (ost->keep_pix_fmt) { if (ost->filter) avfilter_graph_set_auto_convert(ost->filter->graph->graph, AVFILTER_AUTO_CONVERT_NONE); @@ -737,8 +725,10 @@ static char *choose_pixel_fmts(OutputStream *ost) } } - for (; *p != PIX_FMT_NONE; p++) - avio_printf(s, "%s:", av_get_pix_fmt_name(*p)); + for (; *p != PIX_FMT_NONE; p++) { + const char *name = av_get_pix_fmt_name(*p); + avio_printf(s, "%s:", name); + } len = avio_close_dyn_buf(s, &ret); ret[len - 1] = 0; return ret; @@ -746,11 +736,149 @@ static char *choose_pixel_fmts(OutputStream *ost) return NULL; } -static int configure_video_filters(FilterGraph *fg) +/** + * Define a function for building a string containing a list of + * allowed formats, + */ +#define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \ +static char *choose_ ## var ## s(OutputStream *ost) \ +{ \ + if (ost->st->codec->var != none) { \ + get_name(ost->st->codec->var); \ + return av_strdup(name); \ + } else if (ost->enc->supported_list) { \ + const type *p; \ + AVIOContext *s = NULL; \ + uint8_t *ret; \ + int len; \ + \ + if (avio_open_dyn_buf(&s) < 0) \ + exit_program(1); \ + \ + for (p = ost->enc->supported_list; *p != none; p++) { \ + get_name(*p); \ + avio_printf(s, "%s" separator, name); \ + } \ + len = avio_close_dyn_buf(s, &ret); \ + ret[len - 1] = 0; \ + return ret; \ + } else \ + return NULL; \ +} + +#define GET_PIX_FMT_NAME(pix_fmt)\ + const char *name = av_get_pix_fmt_name(pix_fmt); + +// DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE, +// GET_PIX_FMT_NAME, ":") + +#define GET_SAMPLE_FMT_NAME(sample_fmt)\ + const char *name = av_get_sample_fmt_name(sample_fmt) + +DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts, + AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",") + +#define GET_SAMPLE_RATE_NAME(rate)\ + char name[16];\ + snprintf(name, sizeof(name), "%d", rate); + +DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0, + GET_SAMPLE_RATE_NAME, ",") + +#define GET_CH_LAYOUT_NAME(ch_layout)\ + char name[16];\ + snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout); + +DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0, + GET_CH_LAYOUT_NAME, ",") + +static int configure_audio_filters(FilterGraph *fg, AVFilterContext **in_filter, + AVFilterContext **out_filter) +{ + InputStream *ist = fg->inputs[0]->ist; + OutputStream *ost = fg->outputs[0]->ost; + AVCodecContext *codec = ost->st->codec; + AVCodecContext *icodec = ist->st->codec; + char *sample_fmts, *sample_rates, *channel_layouts; + char args[256]; + int ret; + + avfilter_graph_free(&fg->graph); + if (!(fg->graph = avfilter_graph_alloc())) + return AVERROR(ENOMEM); + +#ifdef SRCA + snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:" + "channel_layout=0x%"PRIx64, ist->st->time_base.num, +#else + snprintf(args, sizeof(args), "%d/%d:%d:%s:" + "0x%"PRIx64, ist->st->time_base.num, +#endif + ist->st->time_base.den, icodec->sample_rate, + av_get_sample_fmt_name(icodec->sample_fmt), icodec->channel_layout); + ret = avfilter_graph_create_filter(&fg->inputs[0]->filter, + avfilter_get_by_name("abuffer"), + "src", args, NULL, fg->graph); + if (ret < 0) + return ret; + + ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, + avfilter_get_by_name("abuffersink_old"), + "out", NULL, NULL, fg->graph); + if (ret < 0) + return ret; + + *in_filter = fg->inputs[0]->filter; + *out_filter = fg->outputs[0]->filter; + + if (codec->channels && !codec->channel_layout) + codec->channel_layout = av_get_default_channel_layout(codec->channels); + + sample_fmts = choose_sample_fmts(ost); + sample_rates = choose_sample_rates(ost); + channel_layouts = choose_channel_layouts(ost); + if (sample_fmts || sample_rates || channel_layouts) { + AVFilterContext *format; + char args[256]; + int len = 0; + + if (sample_fmts) + len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:", + sample_fmts); + if (sample_rates) + len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:", + sample_rates); + if (channel_layouts) + len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:", + channel_layouts); + args[len - 1] = 0; + + av_freep(&sample_fmts); + av_freep(&sample_rates); + av_freep(&channel_layouts); + + ret = avfilter_graph_create_filter(&format, + avfilter_get_by_name("aformat"), + "aformat", args, NULL, fg->graph); + if (ret < 0) + return ret; + + ret = avfilter_link(format, 0, fg->outputs[0]->filter, 0); + if (ret < 0) + return ret; + + *out_filter = format; + } + + return 0; +} + +static int configure_video_filters(FilterGraph *fg, AVFilterContext **in_filter, + AVFilterContext **out_filter) { InputStream *ist = fg->inputs[0]->ist; OutputStream *ost = fg->outputs[0]->ost; - AVFilterContext *in_filter, *out_filter, *filter; + AVFilterContext *filter; AVCodecContext *codec = ost->st->codec; AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc(); char *pix_fmts; @@ -758,11 +886,6 @@ static int configure_video_filters(FilterGraph *fg) char args[255]; int ret; - avfilter_graph_free(&fg->graph); - fg->graph = avfilter_graph_alloc(); - if (!fg->graph) - return AVERROR(ENOMEM); - if (ist->st->sample_aspect_ratio.num) { sample_aspect_ratio = ist->st->sample_aspect_ratio; } else @@ -791,8 +914,8 @@ static int configure_video_filters(FilterGraph *fg) if (ret < 0) return ret; - in_filter = fg->inputs[0]->filter; - out_filter = fg->outputs[0]->filter; + *in_filter = fg->inputs[0]->filter; + *out_filter = fg->outputs[0]->filter; if (codec->width || codec->height) { snprintf(args, 255, "%d:%d:flags=0x%X", @@ -802,27 +925,53 @@ static int configure_video_filters(FilterGraph *fg) if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"), NULL, args, NULL, fg->graph)) < 0) return ret; - if ((ret = avfilter_link(in_filter, 0, filter, 0)) < 0) + if ((ret = avfilter_link(*in_filter, 0, filter, 0)) < 0) return ret; - in_filter = filter; + *in_filter = filter; } - if ((pix_fmts = choose_pixel_fmts(ost))) { + if ((pix_fmts = choose_pix_fmts(ost))) { if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("format"), "format", pix_fmts, NULL, fg->graph)) < 0) return ret; - if ((ret = avfilter_link(filter, 0, out_filter, 0)) < 0) + if ((ret = avfilter_link(filter, 0, *out_filter, 0)) < 0) return ret; - out_filter = filter; + *out_filter = filter; av_freep(&pix_fmts); } snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags); fg->graph->scale_sws_opts = av_strdup(args); + return 0; +} + +static int configure_simple_filtergraph(FilterGraph *fg) +{ + OutputStream *ost = fg->outputs[0]->ost; + AVFilterContext *in_filter, *out_filter; + int ret; + + avfilter_graph_free(&fg->graph); + fg->graph = avfilter_graph_alloc(); + if (!fg->graph) + return AVERROR(ENOMEM); + + switch (ost->st->codec->codec_type) { + case AVMEDIA_TYPE_VIDEO: + ret = configure_video_filters(fg, &in_filter, &out_filter); + break; + case AVMEDIA_TYPE_AUDIO: + ret = configure_audio_filters(fg, &in_filter, &out_filter); + break; + default: av_assert0(0); + } + if (ret < 0) + return ret; + if (ost->avfilter) { AVFilterInOut *outputs = avfilter_inout_alloc(); AVFilterInOut *inputs = avfilter_inout_alloc(); @@ -1000,7 +1149,7 @@ static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFil pad_idx = 0; } - if ((pix_fmts = choose_pixel_fmts(ofilter->ost))) { + if ((pix_fmts = choose_pix_fmts(ofilter->ost))) { AVFilterContext *filter; if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("format"), @@ -1097,7 +1246,8 @@ static int configure_complex_filters(void) static int configure_filtergraph(FilterGraph *fg) { - return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg); + return fg->graph_desc ? configure_complex_filter(fg) : + configure_simple_filtergraph(fg); } static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist) @@ -1258,12 +1408,6 @@ void av_noreturn exit_program(int ret) } output_streams[i]->bitstream_filters = NULL; - if (output_streams[i]->output_frame) { - AVFrame *frame = output_streams[i]->output_frame; - if (frame->extended_data != frame->data) - av_freep(&frame->extended_data); - av_freep(&frame); - } av_freep(&output_streams[i]->filtered_frame); av_freep(&output_streams[i]); } @@ -1289,10 +1433,6 @@ void av_noreturn exit_program(int ret) av_freep(&output_files); uninit_opts(); - av_freep(&audio_buf); - allocated_audio_buf_size = 0; - av_freep(&async_buf); - allocated_async_buf_size = 0; avfilter_uninit(); avformat_network_deinit(); @@ -1354,37 +1494,6 @@ static void choose_sample_fmt(AVStream *st, AVCodec *codec) } } -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) { - int i; - const int *sample_rates = codec->supported_samplerates; - av_log(st->codec, AV_LOG_WARNING, - "Requested sampling rate (%dHz) unsupported, using %dHz instead\n" - "Available sampling rates for %s:", - st->codec->sample_rate, best, codec->name); - for (i = 0; sample_rates[i]; i++) { - if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and"); - else if (i) av_log(st->codec, AV_LOG_WARNING, ","); - av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]); - } - av_log(st->codec, AV_LOG_WARNING, ".\n"); - } - st->codec->sample_rate = best; - } -} - static double get_sync_ipts(const OutputStream *ost, int64_t pts) { @@ -1447,104 +1556,38 @@ static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost) } } -static void get_default_channel_layouts(OutputStream *ost, InputStream *ist) -{ - char layout_name[256]; - AVCodecContext *enc = ost->st->codec; - AVCodecContext *dec = ist->st->codec; - - if (dec->channel_layout && - av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) { - av_get_channel_layout_string(layout_name, sizeof(layout_name), - dec->channels, dec->channel_layout); - av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n", - layout_name); - dec->channel_layout = 0; - } - if (!dec->channel_layout) { - if (enc->channel_layout && dec->channels == enc->channels) { - dec->channel_layout = enc->channel_layout; - } else { - dec->channel_layout = av_get_default_channel_layout(dec->channels); - - if (!dec->channel_layout) { - av_log(NULL, AV_LOG_FATAL, "Unable to find default channel " - "layout for Input Stream #%d.%d\n", ist->file_index, - ist->st->index); - exit_program(1); - } - } - av_get_channel_layout_string(layout_name, sizeof(layout_name), - dec->channels, dec->channel_layout); - av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream " - "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name); - } - if (!enc->channel_layout) { - if (dec->channels == enc->channels) { - enc->channel_layout = dec->channel_layout; - return; - } else { - enc->channel_layout = av_get_default_channel_layout(enc->channels); - } - if (!enc->channel_layout) { - av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout " - "for Output Stream #%d.%d\n", ost->file_index, - ost->st->index); - exit_program(1); - } - av_get_channel_layout_string(layout_name, sizeof(layout_name), - enc->channels, enc->channel_layout); - av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream " - "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name); - } -} - -static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size) -{ - int fill_char = 0x00; - if (sample_fmt == AV_SAMPLE_FMT_U8) - fill_char = 0x80; - memset(buf, fill_char, size); -} +// static int check_recording_time(OutputStream *ost) +// { +// OutputFile *of = output_files[ost->file_index]; +// +// if (of->recording_time != INT64_MAX && +// av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time, +// AV_TIME_BASE_Q) >= 0) { +// ost->is_past_recording_time = 1; +// return 0; +// } +// return 1; +// } -static int encode_audio_frame(AVFormatContext *s, OutputStream *ost, - const uint8_t *buf, int buf_size) +static void do_audio_out(AVFormatContext *s, OutputStream *ost, + AVFrame *frame) { AVCodecContext *enc = ost->st->codec; - AVFrame *frame = NULL; AVPacket pkt; - int ret, got_packet; + int got_packet = 0; av_init_packet(&pkt); pkt.data = NULL; pkt.size = 0; - - if (buf && buf_size) { - if (!ost->output_frame) { - ost->output_frame = avcodec_alloc_frame(); - if (!ost->output_frame) { - av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n"); - exit_program(1); - } - } - frame = ost->output_frame; - if (frame->extended_data != frame->data) - av_freep(&frame->extended_data); - avcodec_get_frame_defaults(frame); - - frame->nb_samples = buf_size / - (enc->channels * av_get_bytes_per_sample(enc->sample_fmt)); - if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt, - buf, buf_size, 1)) < 0) { - av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n"); - exit_program(1); - } - +#if 0 + if (!check_recording_time(ost)) + return; +#endif + if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0) frame->pts = ost->sync_opts; - ost->sync_opts += frame->nb_samples; - } + ost->sync_opts = frame->pts + frame->nb_samples; - got_packet = 0; + av_assert0(pkt.size || !pkt.data); update_benchmark(NULL); if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) { av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n"); @@ -1552,8 +1595,6 @@ static int encode_audio_frame(AVFormatContext *s, OutputStream *ost, } update_benchmark("encode_audio %d.%d", ost->file_index, ost->index); - ret = pkt.size; - if (got_packet) { if (pkt.pts != AV_NOPTS_VALUE) pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base); @@ -1568,244 +1609,18 @@ static int encode_audio_frame(AVFormatContext *s, OutputStream *ost, if (pkt.duration > 0) pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base); + if (debug_ts) { + av_log(NULL, AV_LOG_INFO, "encoder -> type:audio " + "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n", + av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base), + av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base)); + } + write_frame(s, &pkt, ost); audio_size += pkt.size; - av_free_packet(&pkt); } - - if (debug_ts) { - av_log(NULL, AV_LOG_INFO, "encoder -> type:audio " - "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n", - av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base), - av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base)); - } - - return ret; -} - -static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc, - int nb_samples, int *buf_linesize) -{ - int64_t audio_buf_samples; - int audio_buf_size; - - /* calculate required number of samples to allocate */ - audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) / - dec->sample_rate; - audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling - audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size); - if (audio_buf_samples > INT_MAX) - return AVERROR(EINVAL); - - audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels, - audio_buf_samples, - enc->sample_fmt, 0); - if (audio_buf_size < 0) - return audio_buf_size; - - av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size); - if (!audio_buf) - return AVERROR(ENOMEM); - - return 0; -} - -static void do_audio_out(AVFormatContext *s, OutputStream *ost, - InputStream *ist, AVFrame *decoded_frame) -{ - uint8_t *buftmp; - int64_t size_out; - - int frame_bytes, resample_changed; - AVCodecContext *enc = ost->st->codec; - AVCodecContext *dec = ist->st->codec; - int osize = av_get_bytes_per_sample(enc->sample_fmt); - int isize = av_get_bytes_per_sample(dec->sample_fmt); - uint8_t *buf[AV_NUM_DATA_POINTERS]; - int size = decoded_frame->nb_samples * dec->channels * isize; - int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1; - int i; - int out_linesize = 0; - - av_assert0(planes <= AV_NUM_DATA_POINTERS); - - for(i=0; i<planes; i++) - buf[i]= decoded_frame->data[i]; - - - get_default_channel_layouts(ost, ist); - - if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) { - av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n"); - exit_program(1); - } - - if (audio_sync_method > 1 || - enc->channels != dec->channels || - enc->channel_layout != dec->channel_layout || - enc->sample_rate != dec->sample_rate || - dec->sample_fmt != enc->sample_fmt) - ost->audio_resample = 1; - - resample_changed = ost->resample_sample_fmt != dec->sample_fmt || - ost->resample_channels != dec->channels || - ost->resample_channel_layout != dec->channel_layout || - ost->resample_sample_rate != dec->sample_rate; - - if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) { - - if (resample_changed) { - av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:0x%"PRIx64" to rate:%d fmt:%s ch:%d chl:0x%"PRIx64"\n", - ist->file_index, ist->st->index, - ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), - ost->resample_channels, ost->resample_channel_layout, - dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), - dec->channels, dec->channel_layout); - ost->resample_sample_fmt = dec->sample_fmt; - ost->resample_channels = dec->channels; - ost->resample_channel_layout = dec->channel_layout; - ost->resample_sample_rate = dec->sample_rate; - swr_free(&ost->swr); - } - /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */ - if (audio_sync_method <= 1 && !ost->audio_channels_mapped && - ost->resample_sample_fmt == enc->sample_fmt && - ost->resample_channels == enc->channels && - ost->resample_channel_layout == enc->channel_layout && - ost->resample_sample_rate == enc->sample_rate) { - //ost->swr = NULL; - ost->audio_resample = 0; - } else { - ost->swr = swr_alloc_set_opts(ost->swr, - enc->channel_layout, enc->sample_fmt, enc->sample_rate, - dec->channel_layout, dec->sample_fmt, dec->sample_rate, - 0, NULL); - av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0); - av_opt_set_double(ost->swr, "dither_scale", ost->swr_dither_scale,0); - if (ost->audio_channels_mapped) - swr_set_channel_mapping(ost->swr, ost->audio_channels_map); - av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0); - if (ost->audio_channels_mapped) { - av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0); - av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0); - } - if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) { - av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n"); - exit_program(1); - } - if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) { - av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n"); - exit_program(1); - } - if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0); - if(ost->swr && swr_init(ost->swr) < 0){ - av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n"); - swr_free(&ost->swr); - } - - if (!ost->swr) { - av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n", - dec->channels, dec->sample_rate, - enc->channels, enc->sample_rate); - exit_program(1); - } - } - } - - av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt); - - if (audio_sync_method > 0) { - double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts - - av_fifo_size(ost->fifo) / (enc->channels * osize); - int idelta = delta * dec->sample_rate / enc->sample_rate; - int byte_delta = idelta * isize * dec->channels; - - // FIXME resample delay - if (fabs(delta) > 50) { - if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) { - if (byte_delta < 0) { - byte_delta = FFMAX(byte_delta, -size); - size += byte_delta; - for (i=0; i<planes; i++) - buf[i] -= byte_delta/planes; - av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", - -byte_delta / (isize * dec->channels)); - if (!size) - return; - ist->is_start = 0; - } else { - av_fast_malloc(&async_buf, &allocated_async_buf_size, - byte_delta + size); - if (!async_buf) { - av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n"); - exit_program(1); - } - - if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) { - av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n"); - exit_program(1); - } - ist->is_start = 0; - - for (i=0; i<planes; i++) { - uint8_t *t = async_buf + i*((byte_delta + size)/planes); - generate_silence(t, dec->sample_fmt, byte_delta/planes); - memcpy(t + byte_delta/planes, buf[i], size/planes); - buf[i] = t; - } - size += byte_delta; - av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta); - } - } else if (audio_sync_method > 1) { - int comp = av_clip(delta, -audio_sync_method, audio_sync_method); - av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", - delta, comp, enc->sample_rate); -// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2)); - swr_set_compensation(ost->swr, comp, enc->sample_rate); - } - } - } else if (audio_sync_method == 0) - ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) - - av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong - - if (ost->audio_resample || ost->audio_channels_mapped) { - buftmp = audio_buf; - size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, - allocated_audio_buf_size / (enc->channels * osize), - (const uint8_t **)buf, - size / (dec->channels * isize)); - if (size_out < 0) { - av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n"); - exit_program(1); - } - size_out = size_out * enc->channels * osize; - } else { - buftmp = buf[0]; - size_out = size; - } - - av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt); - - /* now encode as many frames as possible */ - if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) { - /* output resampled raw samples */ - if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) { - av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n"); - exit_program(1); - } - av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL); - - frame_bytes = enc->frame_size * osize * enc->channels; - - while (av_fifo_size(ost->fifo) >= frame_bytes) { - av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL); - encode_audio_frame(s, ost, audio_buf, frame_bytes); - } - } else { - encode_audio_frame(s, ost, buftmp, size_out); - } } static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp) @@ -2121,6 +1936,7 @@ static int poll_filters(void) for (i = 0; i < nb_output_streams; i++) { OutputStream *ost = output_streams[i]; OutputFile *of = output_files[ost->file_index]; + int ret = 0; if (!ost->filter || ost->is_past_recording_time) continue; @@ -2133,8 +1949,17 @@ static int poll_filters(void) while (1) { AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base; - ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref, - AV_BUFFERSINK_FLAG_NO_REQUEST); + if (ost->enc->type == AVMEDIA_TYPE_AUDIO && + !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) + ret = av_buffersink_read_samples(ost->filter->filter, &picref, + ost->st->codec->frame_size); + else +#ifdef SINKA + ret = av_buffersink_read(ost->filter->filter, &picref); +#else + ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref, + AV_BUFFERSINK_FLAG_NO_REQUEST); +#endif if (ret < 0) { if (ret != AVERROR(EAGAIN)) { char buf[256]; @@ -2144,7 +1969,15 @@ static int poll_filters(void) } break; } - filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q); + if (ost->enc->type == AVMEDIA_TYPE_VIDEO) + filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q); + else if (picref->pts != AV_NOPTS_VALUE) + filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, + ost->filter->filter->inputs[0]->time_base, + ost->st->codec->time_base) - + av_rescale_q(of->start_time, + AV_TIME_BASE_Q, + ost->st->codec->time_base); //if (ost->source_index >= 0) // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold @@ -2162,8 +1995,13 @@ static int poll_filters(void) same_quant ? ost->last_quality : ost->st->codec->global_quality); break; + case AVMEDIA_TYPE_AUDIO: + avfilter_copy_buf_props(filtered_frame, picref); + filtered_frame->pts = frame_pts; + do_audio_out(of->ctx, ost, filtered_frame); + break; default: - // TODO support audio/subtitle filters + // TODO support subtitle filters av_assert0(0); } @@ -2346,40 +2184,40 @@ static void flush_encoders(void) continue; for (;;) { - AVPacket pkt; - int fifo_bytes, got_packet; - av_init_packet(&pkt); - pkt.data = NULL; - pkt.size = 0; + int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL; + const char *desc; + int64_t *size; switch (ost->st->codec->codec_type) { case AVMEDIA_TYPE_AUDIO: - fifo_bytes = av_fifo_size(ost->fifo); - if (fifo_bytes > 0) { - /* encode any samples remaining in fifo */ - int frame_bytes = fifo_bytes; - - av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL); - - encode_audio_frame(os, ost, audio_buf, frame_bytes); - } else { - /* flush encoder with NULL frames until it is done - returning packets */ - if (encode_audio_frame(os, ost, NULL, 0) == 0) { - stop_encoding = 1; - break; - } - } + encode = avcodec_encode_audio2; + desc = "Audio"; + size = &audio_size; break; case AVMEDIA_TYPE_VIDEO: + encode = avcodec_encode_video2; + desc = "Video"; + size = &video_size; + break; + default: + stop_encoding = 1; + } + + if (encode) { + AVPacket pkt; + int got_packet; + av_init_packet(&pkt); + pkt.data = NULL; + pkt.size = 0; + update_benchmark(NULL); - ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet); - update_benchmark("encode_video %d.%d", ost->file_index, ost->index); + ret = encode(enc, &pkt, NULL, &got_packet); + update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index); if (ret < 0) { - av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n"); + av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc); exit_program(1); } - video_size += pkt.size; + *size += pkt.size; if (ost->logfile && enc->stats_out) { fprintf(ost->logfile, "%s", enc->stats_out); } @@ -2392,10 +2230,8 @@ static void flush_encoders(void) if (pkt.dts != AV_NOPTS_VALUE) pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base); write_frame(os, &pkt, ost); - break; - default: - stop_encoding = 1; } + if (stop_encoding) break; } @@ -2496,12 +2332,30 @@ static void rate_emu_sleep(InputStream *ist) } } +static int guess_input_channel_layout(InputStream *ist) +{ + AVCodecContext *dec = ist->st->codec; + + if (!dec->channel_layout) { + char layout_name[256]; + + dec->channel_layout = av_get_default_channel_layout(dec->channels); + if (!dec->channel_layout) + return 0; + av_get_channel_layout_string(layout_name, sizeof(layout_name), + dec->channels, dec->channel_layout); + av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream " + "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name); + } + return 1; +} + static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output) { AVFrame *decoded_frame; AVCodecContext *avctx = ist->st->codec; int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt); - int i, ret; + int i, ret, resample_changed; if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame())) return AVERROR(ENOMEM); @@ -2522,6 +2376,13 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output) if (!*got_output) { /* no audio frame */ + if (!pkt->size) + for (i = 0; i < ist->nb_filters; i++) +#ifdef SRCA + av_buffersrc_buffer(ist->filters[i]->filter, NULL); +#else + av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0); +#endif return ret; } @@ -2529,14 +2390,21 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output) the decoder could be delaying output by a packet or more. */ if (decoded_frame->pts != AV_NOPTS_VALUE) ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts; + else if (pkt->pts != AV_NOPTS_VALUE) { + decoded_frame->pts = pkt->pts; + pkt->pts = AV_NOPTS_VALUE; + }else + decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base); + +#if 1 /* increment next_dts to use for the case where the input stream does not have timestamps or there are multiple frames in the packet */ ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) / avctx->sample_rate; ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) / avctx->sample_rate; - +#endif // preprocess audio (volume) if (audio_volume != 256) { @@ -2598,12 +2466,54 @@ static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output) rate_emu_sleep(ist); - for (i = 0; i < nb_output_streams; i++) { - OutputStream *ost = output_streams[i]; + resample_changed = ist->resample_sample_fmt != decoded_frame->format || + ist->resample_channels != avctx->channels || + ist->resample_channel_layout != decoded_frame->channel_layout || + ist->resample_sample_rate != decoded_frame->sample_rate; + if (resample_changed) { + char layout1[64], layout2[64]; - if (!check_output_constraints(ist, ost) || !ost->encoding_needed) - continue; - do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame); + if (!guess_input_channel_layout(ist)) { + av_log(NULL, AV_LOG_FATAL, "Unable to find default channel " + "layout for Input Stream #%d.%d\n", ist->file_index, + ist->st->index); + exit_program(1); + } + decoded_frame->channel_layout = avctx->channel_layout; + + av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels, + ist->resample_channel_layout); + av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels, + decoded_frame->channel_layout); + + av_log(NULL, AV_LOG_INFO, + "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n", + ist->file_index, ist->st->index, + ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt), + ist->resample_channels, layout1, + decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format), + avctx->channels, layout2); + + ist->resample_sample_fmt = decoded_frame->format; + ist->resample_sample_rate = decoded_frame->sample_rate; + ist->resample_channel_layout = decoded_frame->channel_layout; + ist->resample_channels = avctx->channels; + + for (i = 0; i < nb_filtergraphs; i++) + if (ist_in_filtergraph(filtergraphs[i], ist) && + configure_filtergraph(filtergraphs[i]) < 0) { + av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n"); + exit_program(1); + } + } + + for (i = 0; i < ist->nb_filters; i++) { +#ifdef SRCA + av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame); +#else + AVFilterBufferRef *fb= avfilter_get_audio_buffer_ref_from_frame(decoded_frame, AV_PERM_WRITE); + av_buffersrc_add_ref(ist->filters[i]->filter, fb, 0*AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT); +#endif } return ret; @@ -2938,17 +2848,6 @@ static int init_input_stream(int ist_index, char *error, int error_len) } assert_codec_experimental(ist->st->codec, 0); assert_avoptions(ist->opts); - - if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { - for (i = 0; i < nb_output_streams; i++) { - OutputStream *ost = output_streams[i]; - if (ost->source_index == ist_index) { - if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout) - get_default_channel_layouts(ost, ist); - break; - } - } - } } ist->next_pts = AV_NOPTS_VALUE; @@ -3146,67 +3045,28 @@ static int transcode_init(void) ist->decoding_needed = 1; ost->encoding_needed = 1; - switch (codec->codec_type) { - case AVMEDIA_TYPE_AUDIO: - ost->fifo = av_fifo_alloc(1024); - if (!ost->fifo) { - return AVERROR(ENOMEM); - } - - if (!codec->sample_rate) - codec->sample_rate = icodec->sample_rate; - choose_sample_rate(ost->st, ost->enc); - codec->time_base = (AVRational){ 1, codec->sample_rate }; - - if (codec->sample_fmt == AV_SAMPLE_FMT_NONE) - codec->sample_fmt = icodec->sample_fmt; - choose_sample_fmt(ost->st, ost->enc); - - if (ost->audio_channels_mapped) { - /* the requested output channel is set to the number of - * -map_channel only if no -ac are specified */ - if (!codec->channels) { - codec->channels = ost->audio_channels_mapped; - codec->channel_layout = av_get_default_channel_layout(codec->channels); - if (!codec->channel_layout) { - av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n"); - exit_program(1); - } - } - /* fill unused channel mapping with -1 (which means a muted - * channel in case the number of output channels is bigger - * than the number of mapped channel) */ - for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++) - ost->audio_channels_map[j] = -1; - } else if (!codec->channels) { - codec->channels = icodec->channels; - codec->channel_layout = icodec->channel_layout; - } - if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels) - codec->channel_layout = 0; - - -// ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1; -// ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt -// || codec->channel_layout != icodec->channel_layout; - icodec->request_channels = codec-> channels; - ost->resample_sample_fmt = icodec->sample_fmt; - ost->resample_sample_rate = icodec->sample_rate; - ost->resample_channels = icodec->channels; - ost->resample_channel_layout = icodec->channel_layout; - break; - case AVMEDIA_TYPE_VIDEO: - if (!ost->filter) { + if (!ost->filter && + (codec->codec_type == AVMEDIA_TYPE_VIDEO || + codec->codec_type == AVMEDIA_TYPE_AUDIO)) { FilterGraph *fg; fg = init_simple_filtergraph(ist, ost); - if (configure_video_filters(fg)) { + if (configure_simple_filtergraph(fg)) { av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n"); exit(1); } - } + } + switch (codec->codec_type) { + case AVMEDIA_TYPE_AUDIO: + codec->sample_fmt = ost->filter->filter->inputs[0]->format; + codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate; + codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout; + codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout); + codec->time_base = (AVRational){ 1, codec->sample_rate }; + break; + case AVMEDIA_TYPE_VIDEO: if (ist && !ost->frame_rate.num) - ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 }; + ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1}; if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) { int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates); ost->frame_rate = ost->enc->supported_framerates[idx]; @@ -3409,15 +3269,6 @@ static int transcode_init(void) input_streams[ost->source_index]->st->index, ost->file_index, ost->index); - if (ost->audio_channels_mapped) { - av_log(NULL, AV_LOG_INFO, " [ch:"); - for (j = 0; j < ost->audio_channels_mapped; j++) - if (ost->audio_channels_map[j] == -1) - av_log(NULL, AV_LOG_INFO, " M"); - else - av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]); - av_log(NULL, AV_LOG_INFO, "]"); - } if (ost->sync_ist != input_streams[ost->source_index]) av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]", ost->sync_ist->file_index, @@ -3783,11 +3634,8 @@ static int transcode(void) fclose(ost->logfile); ost->logfile = NULL; } - av_fifo_free(ost->fifo); /* works even if fifo is not - initialized but set to zero */ av_freep(&ost->st->codec->subtitle_header); av_free(ost->forced_kf_pts); - swr_free(&ost->swr); av_dict_free(&ost->opts); } } @@ -4220,6 +4068,14 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic) break; case AVMEDIA_TYPE_AUDIO: + guess_input_channel_layout(ist); + + ist->resample_sample_fmt = dec->sample_fmt; + ist->resample_sample_rate = dec->sample_rate; + ist->resample_channels = dec->channels; + ist->resample_channel_layout = dec->channel_layout; + + break; case AVMEDIA_TYPE_DATA: case AVMEDIA_TYPE_SUBTITLE: if(!ist->dec) @@ -4793,7 +4649,7 @@ static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, in audio_enc->codec_type = AVMEDIA_TYPE_AUDIO; if (!ost->stream_copy) { - char *sample_fmt = NULL; + char *sample_fmt = NULL, *filters = NULL;; MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st); @@ -4806,23 +4662,9 @@ static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, in MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st); - ost->rematrix_volume=1.0; - MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st); - } - - /* check for channel mapping for this audio stream */ - for (n = 0; n < o->nb_audio_channel_maps; n++) { - AudioChannelMap *map = &o->audio_channel_maps[n]; - InputStream *ist = input_streams[ost->source_index]; - if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) && - (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) && - (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) { - if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map)) - ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx; - else - av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n", - ost->file_index, ost->st->index); - } + MATCH_PER_STREAM_OPT(filters, str, filters, oc, st); + if (filters) + ost->avfilter = av_strdup(filters); } return ost; @@ -5697,6 +5539,11 @@ static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg return parse_option(o, "filter:v", arg, options); } +static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg) +{ + return parse_option(o, "filter:a", arg, options); +} + static int opt_vsync(const char *opt, const char *arg) { if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR; @@ -5879,8 +5726,8 @@ static const OptionDef options[] = { { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" }, { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, // { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" }, - { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" }, { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" }, + { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" }, /* subtitle options */ { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" }, |