ref: 364af1c842b21770642afc516b12491381ee79ef
dir: /src/vol.c/
/* Copyright (c) 20/03/2000 Fabien COELHO <fabien@coelho.net>
* Copyright (c) 2000-2007 SoX contributors
*
* SoX vol effect; change volume with basic linear amplitude formula.
* Beware of saturations! Clipping is checked and reported.
*
* FIXME: deprecate or remove the limiter in favour of compand.
*/
#define vol_usage \
"GAIN [TYPE [LIMITERGAIN]]\n" \
"\t(default TYPE=amplitude: 1 is constant, < 0 change phase;\n" \
"\tTYPE=power 1 is constant; TYPE=dB: 0 is constant, +6 doubles ampl.)\n" \
"\tThe peak limiter has a gain much less than 1 (e.g. 0.05 or 0.02) and\n" \
"\tis only used on peaks (to prevent clipping); default is no limiter."
#include "sox_i.h"
typedef struct {
double gain; /* amplitude gain. */
sox_bool uselimiter;
double limiterthreshhold;
double limitergain;
int limited; /* number of limited values to report. */
int totalprocessed;
} priv_t;
enum {vol_amplitude, vol_dB, vol_power};
static enum_item const vol_types[] = {
ENUM_ITEM(vol_,amplitude)
ENUM_ITEM(vol_,dB)
ENUM_ITEM(vol_,power)
{0, 0}};
/*
* Process options: gain (float) type (amplitude, power, dB)
*/
static int getopts(sox_effect_t * effp, int argc, char **argv)
{
priv_t * vol = (priv_t *) effp->priv;
char type_string[11];
char * type_ptr = type_string;
char dummy; /* To check for extraneous chars. */
sox_bool have_type;
vol->gain = 1; /* Default is no change. */
vol->uselimiter = sox_false; /* Default is no limiter. */
/* Get the vol, and the type if it's in the same arg. */
if (!argc || (have_type = sscanf(argv[0], "%lf %10s %c", &vol->gain, type_string, &dummy) - 1) > 1)
return lsx_usage(effp);
++argv, --argc;
/* No type yet? Get it from the next arg: */
if (!have_type && argc) {
have_type = sox_true;
type_ptr = *argv;
++argv, --argc;
}
if (have_type) {
enum_item const * p = find_enum_text(type_ptr, vol_types);
if (!p)
return lsx_usage(effp);
switch (p->value) {
case vol_dB: vol->gain = dB_to_linear(vol->gain); break;
case vol_power: /* power to amplitude, keep phase change */
vol->gain = vol->gain > 0 ? sqrt(vol->gain) : -sqrt(-vol->gain);
break;
}
}
if (argc) {
if (fabs(vol->gain) < 1 || sscanf(*argv, "%lf %c", &vol->limitergain, &dummy) != 1 || vol->limitergain <= 0 || vol->limitergain >= 1)
return lsx_usage(effp);
vol->uselimiter = sox_true;
/* The following equation is derived so that there is no
* discontinuity in output amplitudes */
/* and a SOX_SAMPLE_MAX input always maps to a SOX_SAMPLE_MAX output
* when the limiter is activated. */
/* (NOTE: There **WILL** be a discontinuity in the slope
* of the output amplitudes when using the limiter.) */
vol->limiterthreshhold = SOX_SAMPLE_MAX * (1.0 - vol->limitergain) / (fabs(vol->gain) - vol->limitergain);
}
sox_debug("mult=%g limit=%g", vol->gain, vol->limitergain);
return SOX_SUCCESS;
}
/*
* Start processing
*/
static int start(sox_effect_t * effp)
{
priv_t * vol = (priv_t *) effp->priv;
if (vol->gain == 1)
return SOX_EFF_NULL;
vol->limited = 0;
vol->totalprocessed = 0;
return SOX_SUCCESS;
}
/*
* Process data.
*/
static int flow(sox_effect_t * effp, const sox_sample_t *ibuf, sox_sample_t *obuf,
sox_size_t *isamp, sox_size_t *osamp)
{
priv_t * vol = (priv_t *) effp->priv;
register double gain = vol->gain;
register double limiterthreshhold = vol->limiterthreshhold;
register double sample;
register sox_size_t len;
len = min(*osamp, *isamp);
/* report back dealt with amount. */
*isamp = len; *osamp = len;
if (vol->uselimiter)
{
vol->totalprocessed += len;
for (;len>0; len--)
{
sample = *ibuf++;
if (sample > limiterthreshhold)
{
sample = (SOX_SAMPLE_MAX - vol->limitergain * (SOX_SAMPLE_MAX - sample));
vol->limited++;
}
else if (sample < -limiterthreshhold)
{
sample = -(SOX_SAMPLE_MAX - vol->limitergain * (SOX_SAMPLE_MAX + sample));
/* FIXME: MIN is (-MAX)-1 so need to make sure we
* don't go over that. Probably could do this
* check inside the above equation but I didn't
* think it thru.
*/
if (sample < SOX_SAMPLE_MIN)
sample = SOX_SAMPLE_MIN;
vol->limited++;
} else
sample = gain * sample;
SOX_SAMPLE_CLIP_COUNT(sample, effp->clips);
*obuf++ = sample;
}
}
else
{
/* quite basic, with clipping */
for (;len>0; len--)
{
sample = gain * *ibuf++;
SOX_SAMPLE_CLIP_COUNT(sample, effp->clips);
*obuf++ = sample;
}
}
return SOX_SUCCESS;
}
static int stop(sox_effect_t * effp)
{
priv_t * vol = (priv_t *) effp->priv;
if (vol->limited) {
sox_warn("limited %d values (%d percent).",
vol->limited, (int) (vol->limited * 100.0 / vol->totalprocessed));
}
return SOX_SUCCESS;
}
sox_effect_handler_t const * sox_vol_effect_fn(void)
{
static sox_effect_handler_t handler = {
"vol", vol_usage, SOX_EFF_MCHAN, getopts, start, flow, 0, stop, 0, sizeof(priv_t)
};
return &handler;
}
static int gain_getopts(sox_effect_t * effp, int argc, char * * argv)
{
char * args[] = {0, "dB"};
if (argc != 1)
return lsx_usage(effp);
args[0] = argv[0];
return sox_vol_effect_fn()->getopts(effp, array_length(args), args);
}
sox_effect_handler_t const * sox_gain_effect_fn(void)
{
static sox_effect_handler_t handler;
handler = *sox_vol_effect_fn();
handler.name = "gain";
handler.usage = "dB-gain";
handler.getopts = gain_getopts;
return &handler;
}