diff options
| -rw-r--r-- | Changelog | 1 | ||||
| -rw-r--r-- | doc/filters.texi | 53 | ||||
| -rw-r--r-- | libavfilter/Makefile | 1 | ||||
| -rw-r--r-- | libavfilter/af_volume.c | 314 | ||||
| -rw-r--r-- | libavfilter/af_volume.h | 53 | ||||
| -rw-r--r-- | libavfilter/allfilters.c | 1 | ||||
| -rw-r--r-- | libavfilter/version.h | 2 |
7 files changed, 424 insertions, 1 deletions
@@ -4,6 +4,7 @@ releases are sorted from youngest to oldest. version <next>: - ashowinfo audio filter - 24-bit FLAC encoding +- audio volume filter version 9_beta2: diff --git a/doc/filters.texi b/doc/filters.texi index f092f3c8a8..55e4468fd6 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -359,6 +359,59 @@ not meant to be used directly, it is inserted automatically by libavfilter whenever conversion is needed. Use the @var{aformat} filter to force a specific conversion. +@section volume + +Adjust the input audio volume. + +The filter accepts the following named parameters: +@table @option + +@item volume +Expresses how the audio volume will be increased or decreased. + +Output values are clipped to the maximum value. + +The output audio volume is given by the relation: +@example +@var{output_volume} = @var{volume} * @var{input_volume} +@end example + +Default value for @var{volume} is 1.0. + +@item precision +Mathematical precision. + +This determines which input sample formats will be allowed, which affects the +precision of the volume scaling. + +@table @option +@item fixed +8-bit fixed-point; limits input sample format to U8, S16, and S32. +@item float +32-bit floating-point; limits input sample format to FLT. (default) +@item double +64-bit floating-point; limits input sample format to DBL. +@end table +@end table + +@subsection Examples + +@itemize +@item +Halve the input audio volume: +@example +volume=volume=0.5 +volume=volume=1/2 +volume=volume=-6.0206dB +@end example + +@item +Increase input audio power by 6 decibels using fixed-point precision: +@example +volume=volume=6dB:precision=fixed +@end example +@end itemize + @c man end AUDIO FILTERS @chapter Audio Sources diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 752ff40ff1..2559e8a4b7 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -35,6 +35,7 @@ OBJS-$(CONFIG_CHANNELMAP_FILTER) += af_channelmap.o OBJS-$(CONFIG_CHANNELSPLIT_FILTER) += af_channelsplit.o OBJS-$(CONFIG_JOIN_FILTER) += af_join.o OBJS-$(CONFIG_RESAMPLE_FILTER) += af_resample.o +OBJS-$(CONFIG_VOLUME_FILTER) += af_volume.o OBJS-$(CONFIG_ANULLSRC_FILTER) += asrc_anullsrc.o diff --git a/libavfilter/af_volume.c b/libavfilter/af_volume.c new file mode 100644 index 0000000000..4a4e29ff46 --- /dev/null +++ b/libavfilter/af_volume.c @@ -0,0 +1,314 @@ +/* + * Copyright (c) 2011 Stefano Sabatini + * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com> + * + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * audio volume filter + */ + +#include "libavutil/audioconvert.h" +#include "libavutil/common.h" +#include "libavutil/eval.h" +#include "libavutil/float_dsp.h" +#include "libavutil/opt.h" +#include "audio.h" +#include "avfilter.h" +#include "formats.h" +#include "internal.h" +#include "af_volume.h" + +static const char *precision_str[] = { + "fixed", "float", "double" +}; + +#define OFFSET(x) offsetof(VolumeContext, x) +#define A AV_OPT_FLAG_AUDIO_PARAM + +static const AVOption options[] = { + { "volume", "Volume adjustment.", + OFFSET(volume), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 }, 0, 0x7fffff, A }, + { "precision", "Mathematical precision.", + OFFSET(precision), AV_OPT_TYPE_INT, { .i64 = PRECISION_FLOAT }, PRECISION_FIXED, PRECISION_DOUBLE, A, "precision" }, + { "fixed", "8-bit fixed-point.", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FIXED }, INT_MIN, INT_MAX, A, "precision" }, + { "float", "32-bit floating-point.", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FLOAT }, INT_MIN, INT_MAX, A, "precision" }, + { "double", "64-bit floating-point.", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_DOUBLE }, INT_MIN, INT_MAX, A, "precision" }, + { NULL }, +}; + +static const AVClass volume_class = { + .class_name = "volume filter", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +static av_cold int init(AVFilterContext *ctx, const char *args) +{ + VolumeContext *vol = ctx->priv; + int ret; + + vol->class = &volume_class; + av_opt_set_defaults(vol); + + if ((ret = av_set_options_string(vol, args, "=", ":")) < 0) { + av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args); + return ret; + } + + if (vol->precision == PRECISION_FIXED) { + vol->volume_i = (int)(vol->volume * 256 + 0.5); + vol->volume = vol->volume_i / 256.0; + av_log(ctx, AV_LOG_VERBOSE, "volume:(%d/256)(%f)(%1.2fdB) precision:fixed\n", + vol->volume_i, vol->volume, 20.0*log(vol->volume)/M_LN10); + } else { + av_log(ctx, AV_LOG_VERBOSE, "volume:(%f)(%1.2fdB) precision:%s\n", + vol->volume, 20.0*log(vol->volume)/M_LN10, + precision_str[vol->precision]); + } + + av_opt_free(vol); + return ret; +} + +static int query_formats(AVFilterContext *ctx) +{ + VolumeContext *vol = ctx->priv; + AVFilterFormats *formats = NULL; + AVFilterChannelLayouts *layouts; + static const enum AVSampleFormat sample_fmts[][7] = { + /* PRECISION_FIXED */ + { + AV_SAMPLE_FMT_U8, + AV_SAMPLE_FMT_U8P, + AV_SAMPLE_FMT_S16, + AV_SAMPLE_FMT_S16P, + AV_SAMPLE_FMT_S32, + AV_SAMPLE_FMT_S32P, + AV_SAMPLE_FMT_NONE + }, + /* PRECISION_FLOAT */ + { + AV_SAMPLE_FMT_FLT, + AV_SAMPLE_FMT_FLTP, + AV_SAMPLE_FMT_NONE + }, + /* PRECISION_DOUBLE */ + { + AV_SAMPLE_FMT_DBL, + AV_SAMPLE_FMT_DBLP, + AV_SAMPLE_FMT_NONE + } + }; + + layouts = ff_all_channel_layouts(); + if (!layouts) + return AVERROR(ENOMEM); + ff_set_common_channel_layouts(ctx, layouts); + + formats = ff_make_format_list(sample_fmts[vol->precision]); + if (!formats) + return AVERROR(ENOMEM); + ff_set_common_formats(ctx, formats); + + formats = ff_all_samplerates(); + if (!formats) + return AVERROR(ENOMEM); + ff_set_common_samplerates(ctx, formats); + + return 0; +} + +static inline void scale_samples_u8(uint8_t *dst, const uint8_t *src, + int nb_samples, int volume) +{ + int i; + for (i = 0; i < nb_samples; i++) + dst[i] = av_clip_uint8(((((int64_t)src[i] - 128) * volume + 128) >> 8) + 128); +} + +static inline void scale_samples_u8_small(uint8_t *dst, const uint8_t *src, + int nb_samples, int volume) +{ + int i; + for (i = 0; i < nb_samples; i++) + dst[i] = av_clip_uint8((((src[i] - 128) * volume + 128) >> 8) + 128); +} + +static inline void scale_samples_s16(uint8_t *dst, const uint8_t *src, + int nb_samples, int volume) +{ + int i; + int16_t *smp_dst = (int16_t *)dst; + const int16_t *smp_src = (const int16_t *)src; + for (i = 0; i < nb_samples; i++) + smp_dst[i] = av_clip_int16(((int64_t)smp_src[i] * volume + 128) >> 8); +} + +static inline void scale_samples_s16_small(uint8_t *dst, const uint8_t *src, + int nb_samples, int volume) +{ + int i; + int16_t *smp_dst = (int16_t *)dst; + const int16_t *smp_src = (const int16_t *)src; + for (i = 0; i < nb_samples; i++) + smp_dst[i] = av_clip_int16((smp_src[i] * volume + 128) >> 8); +} + +static inline void scale_samples_s32(uint8_t *dst, const uint8_t *src, + int nb_samples, int volume) +{ + int i; + int32_t *smp_dst = (int32_t *)dst; + const int32_t *smp_src = (const int32_t *)src; + for (i = 0; i < nb_samples; i++) + smp_dst[i] = av_clipl_int32((((int64_t)smp_src[i] * volume + 128) >> 8)); +} + + + +static void volume_init(VolumeContext *vol) +{ + vol->samples_align = 1; + + switch (av_get_packed_sample_fmt(vol->sample_fmt)) { + case AV_SAMPLE_FMT_U8: + if (vol->volume_i < 0x1000000) + vol->scale_samples = scale_samples_u8_small; + else + vol->scale_samples = scale_samples_u8; + break; + case AV_SAMPLE_FMT_S16: + if (vol->volume_i < 0x10000) + vol->scale_samples = scale_samples_s16_small; + else + vol->scale_samples = scale_samples_s16; + break; + case AV_SAMPLE_FMT_S32: + vol->scale_samples = scale_samples_s32; + break; + case AV_SAMPLE_FMT_FLT: + avpriv_float_dsp_init(&vol->fdsp, 0); + vol->samples_align = 4; + break; + case AV_SAMPLE_FMT_DBL: + avpriv_float_dsp_init(&vol->fdsp, 0); + vol->samples_align = 8; + break; + } +} + +static int config_output(AVFilterLink *outlink) +{ + AVFilterContext *ctx = outlink->src; + VolumeContext *vol = ctx->priv; + AVFilterLink *inlink = ctx->inputs[0]; + + vol->sample_fmt = inlink->format; + vol->channels = av_get_channel_layout_nb_channels(inlink->channel_layout); + vol->planes = av_sample_fmt_is_planar(inlink->format) ? vol->channels : 1; + + volume_init(vol); + + return 0; +} + +static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf) +{ + VolumeContext *vol = inlink->dst->priv; + AVFilterLink *outlink = inlink->dst->outputs[0]; + int nb_samples = buf->audio->nb_samples; + AVFilterBufferRef *out_buf; + + if (vol->volume == 1.0 || vol->volume_i == 256) + return ff_filter_frame(outlink, buf); + + /* do volume scaling in-place if input buffer is writable */ + if (buf->perms & AV_PERM_WRITE) { + out_buf = buf; + } else { + out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples); + if (!out_buf) + return AVERROR(ENOMEM); + out_buf->pts = buf->pts; + } + + if (vol->precision != PRECISION_FIXED || vol->volume_i > 0) { + int p, plane_samples; + + if (av_sample_fmt_is_planar(buf->format)) + plane_samples = FFALIGN(nb_samples, vol->samples_align); + else + plane_samples = FFALIGN(nb_samples * vol->channels, vol->samples_align); + + if (vol->precision == PRECISION_FIXED) { + for (p = 0; p < vol->planes; p++) { + vol->scale_samples(out_buf->extended_data[p], + buf->extended_data[p], plane_samples, + vol->volume_i); + } + } else if (av_get_packed_sample_fmt(vol->sample_fmt) == AV_SAMPLE_FMT_FLT) { + for (p = 0; p < vol->planes; p++) { + vol->fdsp.vector_fmul_scalar((float *)out_buf->extended_data[p], + (const float *)buf->extended_data[p], + vol->volume, plane_samples); + } + } else { + for (p = 0; p < vol->planes; p++) { + vol->fdsp.vector_dmul_scalar((double *)out_buf->extended_data[p], + (const double *)buf->extended_data[p], + vol->volume, plane_samples); + } + } + } + + if (buf != out_buf) + avfilter_unref_buffer(buf); + + return ff_filter_frame(outlink, out_buf); +} + +static const AVFilterPad avfilter_af_volume_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + .filter_frame = filter_frame, + }, + { NULL } +}; + +static const AVFilterPad avfilter_af_volume_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_AUDIO, + .config_props = config_output, + }, + { NULL } +}; + +AVFilter avfilter_af_volume = { + .name = "volume", + .description = NULL_IF_CONFIG_SMALL("Change input volume."), + .query_formats = query_formats, + .priv_size = sizeof(VolumeContext), + .init = init, + .inputs = avfilter_af_volume_inputs, + .outputs = avfilter_af_volume_outputs, +}; diff --git a/libavfilter/af_volume.h b/libavfilter/af_volume.h new file mode 100644 index 0000000000..dec8767f88 --- /dev/null +++ b/libavfilter/af_volume.h @@ -0,0 +1,53 @@ +/* + * This file is part of Libav. + * + * Libav is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * Libav is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with Libav; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * audio volume filter + */ + +#ifndef AVFILTER_AF_VOLUME_H +#define AVFILTER_AF_VOLUME_H + +#include "libavutil/common.h" +#include "libavutil/float_dsp.h" +#include "libavutil/opt.h" +#include "libavutil/samplefmt.h" + +enum PrecisionType { + PRECISION_FIXED = 0, + PRECISION_FLOAT, + PRECISION_DOUBLE, +}; + +typedef struct VolumeContext { + const AVClass *class; + AVFloatDSPContext fdsp; + enum PrecisionType precision; + double volume; + int volume_i; + int channels; + int planes; + enum AVSampleFormat sample_fmt; + + void (*scale_samples)(uint8_t *dst, const uint8_t *src, int nb_samples, + int volume); + int samples_align; +} VolumeContext; + +#endif /* AVFILTER_AF_VOLUME_H */ diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index d7a7b07faf..0d7cbc2d09 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -46,6 +46,7 @@ void avfilter_register_all(void) REGISTER_FILTER (CHANNELSPLIT,channelsplit,af); REGISTER_FILTER (JOIN, join, af); REGISTER_FILTER (RESAMPLE, resample, af); + REGISTER_FILTER (VOLUME, volume, af); REGISTER_FILTER (ANULLSRC, anullsrc, asrc); diff --git a/libavfilter/version.h b/libavfilter/version.h index eb5326bda8..c09d44bb0e 100644 --- a/libavfilter/version.h +++ b/libavfilter/version.h @@ -29,7 +29,7 @@ #include "libavutil/avutil.h" #define LIBAVFILTER_VERSION_MAJOR 3 -#define LIBAVFILTER_VERSION_MINOR 2 +#define LIBAVFILTER_VERSION_MINOR 3 #define LIBAVFILTER_VERSION_MICRO 0 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \ |