lavfi: rename af_volume to af_volume_stefano
[ffmpeg.git] / libavfilter / af_volume_justin.c
1 /*
2  * Copyright (c) 2011 Stefano Sabatini
3  * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * audio volume filter
25  */
26
27 #include "libavutil/audioconvert.h"
28 #include "libavutil/common.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/float_dsp.h"
31 #include "libavutil/opt.h"
32 #include "audio.h"
33 #include "avfilter.h"
34 #include "formats.h"
35 #include "internal.h"
36 #include "af_volume.h"
37
38 static const char *precision_str[] = {
39     "fixed", "float", "double"
40 };
41
42 #define OFFSET(x) offsetof(VolumeContext, x)
43 #define A AV_OPT_FLAG_AUDIO_PARAM
44
45 static const AVOption options[] = {
46     { "volume", "Volume adjustment.",
47             OFFSET(volume), AV_OPT_TYPE_DOUBLE, { .dbl = 1.0 }, 0, 0x7fffff, A },
48     { "precision", "Mathematical precision.",
49             OFFSET(precision), AV_OPT_TYPE_INT, { .i64 = PRECISION_FLOAT }, PRECISION_FIXED, PRECISION_DOUBLE, A, "precision" },
50         { "fixed",  "8-bit fixed-point.",     0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FIXED  }, INT_MIN, INT_MAX, A, "precision" },
51         { "float",  "32-bit floating-point.", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_FLOAT  }, INT_MIN, INT_MAX, A, "precision" },
52         { "double", "64-bit floating-point.", 0, AV_OPT_TYPE_CONST, { .i64 = PRECISION_DOUBLE }, INT_MIN, INT_MAX, A, "precision" },
53     { NULL },
54 };
55
56 static const AVClass volume_class = {
57     .class_name = "volume filter",
58     .item_name  = av_default_item_name,
59     .option     = options,
60     .version    = LIBAVUTIL_VERSION_INT,
61 };
62
63 static av_cold int init(AVFilterContext *ctx, const char *args)
64 {
65     VolumeContext *vol = ctx->priv;
66     int ret;
67
68     vol->class = &volume_class;
69     av_opt_set_defaults(vol);
70
71     if ((ret = av_set_options_string(vol, args, "=", ":")) < 0) {
72         av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);
73         return ret;
74     }
75
76     if (vol->precision == PRECISION_FIXED) {
77         vol->volume_i = (int)(vol->volume * 256 + 0.5);
78         vol->volume   = vol->volume_i / 256.0;
79         av_log(ctx, AV_LOG_VERBOSE, "volume:(%d/256)(%f)(%1.2fdB) precision:fixed\n",
80                vol->volume_i, vol->volume, 20.0*log(vol->volume)/M_LN10);
81     } else {
82         av_log(ctx, AV_LOG_VERBOSE, "volume:(%f)(%1.2fdB) precision:%s\n",
83                vol->volume, 20.0*log(vol->volume)/M_LN10,
84                precision_str[vol->precision]);
85     }
86
87     av_opt_free(vol);
88     return ret;
89 }
90
91 static int query_formats(AVFilterContext *ctx)
92 {
93     VolumeContext *vol = ctx->priv;
94     AVFilterFormats *formats = NULL;
95     AVFilterChannelLayouts *layouts;
96     static const enum AVSampleFormat sample_fmts[][7] = {
97         /* PRECISION_FIXED */
98         {
99             AV_SAMPLE_FMT_U8,
100             AV_SAMPLE_FMT_U8P,
101             AV_SAMPLE_FMT_S16,
102             AV_SAMPLE_FMT_S16P,
103             AV_SAMPLE_FMT_S32,
104             AV_SAMPLE_FMT_S32P,
105             AV_SAMPLE_FMT_NONE
106         },
107         /* PRECISION_FLOAT */
108         {
109             AV_SAMPLE_FMT_FLT,
110             AV_SAMPLE_FMT_FLTP,
111             AV_SAMPLE_FMT_NONE
112         },
113         /* PRECISION_DOUBLE */
114         {
115             AV_SAMPLE_FMT_DBL,
116             AV_SAMPLE_FMT_DBLP,
117             AV_SAMPLE_FMT_NONE
118         }
119     };
120
121     layouts = ff_all_channel_layouts();
122     if (!layouts)
123         return AVERROR(ENOMEM);
124     ff_set_common_channel_layouts(ctx, layouts);
125
126     formats = ff_make_format_list(sample_fmts[vol->precision]);
127     if (!formats)
128         return AVERROR(ENOMEM);
129     ff_set_common_formats(ctx, formats);
130
131     formats = ff_all_samplerates();
132     if (!formats)
133         return AVERROR(ENOMEM);
134     ff_set_common_samplerates(ctx, formats);
135
136     return 0;
137 }
138
139 static inline void scale_samples_u8(uint8_t *dst, const uint8_t *src,
140                                     int nb_samples, int volume)
141 {
142     int i;
143     for (i = 0; i < nb_samples; i++)
144         dst[i] = av_clip_uint8(((((int64_t)src[i] - 128) * volume + 128) >> 8) + 128);
145 }
146
147 static inline void scale_samples_u8_small(uint8_t *dst, const uint8_t *src,
148                                           int nb_samples, int volume)
149 {
150     int i;
151     for (i = 0; i < nb_samples; i++)
152         dst[i] = av_clip_uint8((((src[i] - 128) * volume + 128) >> 8) + 128);
153 }
154
155 static inline void scale_samples_s16(uint8_t *dst, const uint8_t *src,
156                                      int nb_samples, int volume)
157 {
158     int i;
159     int16_t *smp_dst       = (int16_t *)dst;
160     const int16_t *smp_src = (const int16_t *)src;
161     for (i = 0; i < nb_samples; i++)
162         smp_dst[i] = av_clip_int16(((int64_t)smp_src[i] * volume + 128) >> 8);
163 }
164
165 static inline void scale_samples_s16_small(uint8_t *dst, const uint8_t *src,
166                                            int nb_samples, int volume)
167 {
168     int i;
169     int16_t *smp_dst       = (int16_t *)dst;
170     const int16_t *smp_src = (const int16_t *)src;
171     for (i = 0; i < nb_samples; i++)
172         smp_dst[i] = av_clip_int16((smp_src[i] * volume + 128) >> 8);
173 }
174
175 static inline void scale_samples_s32(uint8_t *dst, const uint8_t *src,
176                                      int nb_samples, int volume)
177 {
178     int i;
179     int32_t *smp_dst       = (int32_t *)dst;
180     const int32_t *smp_src = (const int32_t *)src;
181     for (i = 0; i < nb_samples; i++)
182         smp_dst[i] = av_clipl_int32((((int64_t)smp_src[i] * volume + 128) >> 8));
183 }
184
185
186
187 static void volume_init(VolumeContext *vol)
188 {
189     vol->samples_align = 1;
190
191     switch (av_get_packed_sample_fmt(vol->sample_fmt)) {
192     case AV_SAMPLE_FMT_U8:
193         if (vol->volume_i < 0x1000000)
194             vol->scale_samples = scale_samples_u8_small;
195         else
196             vol->scale_samples = scale_samples_u8;
197         break;
198     case AV_SAMPLE_FMT_S16:
199         if (vol->volume_i < 0x10000)
200             vol->scale_samples = scale_samples_s16_small;
201         else
202             vol->scale_samples = scale_samples_s16;
203         break;
204     case AV_SAMPLE_FMT_S32:
205         vol->scale_samples = scale_samples_s32;
206         break;
207     case AV_SAMPLE_FMT_FLT:
208         avpriv_float_dsp_init(&vol->fdsp, 0);
209         vol->samples_align = 4;
210         break;
211     case AV_SAMPLE_FMT_DBL:
212         avpriv_float_dsp_init(&vol->fdsp, 0);
213         vol->samples_align = 8;
214         break;
215     }
216 }
217
218 static int config_output(AVFilterLink *outlink)
219 {
220     AVFilterContext *ctx = outlink->src;
221     VolumeContext *vol   = ctx->priv;
222     AVFilterLink *inlink = ctx->inputs[0];
223
224     vol->sample_fmt = inlink->format;
225     vol->channels   = av_get_channel_layout_nb_channels(inlink->channel_layout);
226     vol->planes     = av_sample_fmt_is_planar(inlink->format) ? vol->channels : 1;
227
228     volume_init(vol);
229
230     return 0;
231 }
232
233 static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
234 {
235     VolumeContext *vol    = inlink->dst->priv;
236     AVFilterLink *outlink = inlink->dst->outputs[0];
237     int nb_samples        = buf->audio->nb_samples;
238     AVFilterBufferRef *out_buf;
239
240     if (vol->volume == 1.0 || vol->volume_i == 256)
241         return ff_filter_frame(outlink, buf);
242
243     /* do volume scaling in-place if input buffer is writable */
244     if (buf->perms & AV_PERM_WRITE) {
245         out_buf = buf;
246     } else {
247         out_buf = ff_get_audio_buffer(inlink, AV_PERM_WRITE, nb_samples);
248         if (!out_buf)
249             return AVERROR(ENOMEM);
250         out_buf->pts = buf->pts;
251     }
252
253     if (vol->precision != PRECISION_FIXED || vol->volume_i > 0) {
254         int p, plane_samples;
255
256         if (av_sample_fmt_is_planar(buf->format))
257             plane_samples = FFALIGN(nb_samples, vol->samples_align);
258         else
259             plane_samples = FFALIGN(nb_samples * vol->channels, vol->samples_align);
260
261         if (vol->precision == PRECISION_FIXED) {
262             for (p = 0; p < vol->planes; p++) {
263                 vol->scale_samples(out_buf->extended_data[p],
264                                    buf->extended_data[p], plane_samples,
265                                    vol->volume_i);
266             }
267         } else if (av_get_packed_sample_fmt(vol->sample_fmt) == AV_SAMPLE_FMT_FLT) {
268             for (p = 0; p < vol->planes; p++) {
269                 vol->fdsp.vector_fmul_scalar((float *)out_buf->extended_data[p],
270                                              (const float *)buf->extended_data[p],
271                                              vol->volume, plane_samples);
272             }
273         } else {
274             for (p = 0; p < vol->planes; p++) {
275                 vol->fdsp.vector_dmul_scalar((double *)out_buf->extended_data[p],
276                                              (const double *)buf->extended_data[p],
277                                              vol->volume, plane_samples);
278             }
279         }
280     }
281
282     if (buf != out_buf)
283         avfilter_unref_buffer(buf);
284
285     return ff_filter_frame(outlink, out_buf);
286 }
287
288 static const AVFilterPad avfilter_af_volume_inputs[] = {
289     {
290         .name           = "default",
291         .type           = AVMEDIA_TYPE_AUDIO,
292         .filter_frame   = filter_frame,
293     },
294     { NULL }
295 };
296
297 static const AVFilterPad avfilter_af_volume_outputs[] = {
298     {
299         .name         = "default",
300         .type         = AVMEDIA_TYPE_AUDIO,
301         .config_props = config_output,
302     },
303     { NULL }
304 };
305
306 AVFilter avfilter_af_volume_justin = {
307     .name           = "volume_justin",
308     .description    = NULL_IF_CONFIG_SMALL("Change input volume."),
309     .query_formats  = query_formats,
310     .priv_size      = sizeof(VolumeContext),
311     .init           = init,
312     .inputs         = avfilter_af_volume_inputs,
313     .outputs        = avfilter_af_volume_outputs,
314 };