ref: b91c9d5d7ce73a1b90794fa008fc2dc4cde53886
dir: /src/vol.c/
/* * (c) 20/03/2000 Fabien COELHO <fabien@coelho.net> for sox. * * Change volume of sound file, with basic linear amplitude formula. * Pretty redundant with -v general option. * Beware of saturations! clipping is checked and reported. * Cannot handle different number of channels. * Cannot handle rate change. */ #include "st.h" #include <math.h> /* exp(), sqrt() */ #include <limits.h> /* LONG_MAX */ /* type used for computations. */ #ifndef VOL_FLOAT #define VOL_FLOAT float #define VOL_FLOAT_SCAN "%f" #endif /* constants */ #define ZERO ((VOL_FLOAT)(0.0e0)) #define LOG_10_20 ((VOL_FLOAT)(0.1151292546497022842009e0)) #define ONE ((VOL_FLOAT)(1.0e0)) #define TWENTY ((VOL_FLOAT)(20.0e0)) #define VOL_USAGE \ "Usage: vol gain [ type [ limitergain ] ]" \ " (default type=amplitude: 1.0 is constant, <0.0 change phase;" \ " type=power 1.0 is constant; type=dB: 0.0 is constant, +6 doubles ampl.)" \ " The peak limiter has a gain much less than 1.0 (ie 0.05 or 0.02) which is only" \ " used on peaks to prevent clipping. (default is no limiter)" typedef struct { VOL_FLOAT gain; /* amplitude gain. */ int uselimiter; /* boolean: are we using the limiter? */ VOL_FLOAT limiterthreshhold; VOL_FLOAT limitergain; /* limiter gain. */ int limited; /* number of limited values to report. */ int totalprocessed; int clipped; /* number of clipped values to report. */ } * vol_t; /* * Process options: gain (float) type (amplitude, power, dB) */ int st_vol_getopts(effp, n, argv) eff_t effp; int n; char **argv; { vol_t vol = (vol_t) effp->priv; vol->gain = ONE; /* default is no change */ vol->uselimiter = 0; /* default is no limiter */ if (n && (!sscanf(argv[0], VOL_FLOAT_SCAN, &vol->gain))) { st_fail(VOL_USAGE); return ST_EOF; } /* adjust gain depending on type (what a great parser;-) */ if (n>1) { switch (argv[1][0]) { case 'd': /* decibels to amplitude */ case 'D': vol->gain = exp(vol->gain*LOG_10_20); break; case 'p': case 'P': /* power to amplitude, keep phase change */ if (vol->gain > ZERO) vol->gain = sqrt(vol->gain); else vol->gain = -sqrt(-vol->gain); break; case 'a': /* amplitude */ case 'A': default: break; } } if (n>2) { if ((fabs(vol->gain) < ONE) || !sscanf(argv[2], VOL_FLOAT_SCAN, &vol->limitergain) || !((vol->limitergain > ZERO) && (vol->limitergain < ONE))) { st_fail(VOL_USAGE); return ST_EOF; } vol->uselimiter = 1; /* ok, we'll use it */ /* The following equation is derived so that there is no discontinuity in output amplitudes */ /* and a LONG_MAX input always maps to a LONG_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 = LONG_MAX * (ONE - vol->limitergain) / (fabs(vol->gain) - vol->limitergain); } return ST_SUCCESS; } /* * Start processing */ int st_vol_start(effp) eff_t effp; { vol_t vol = (vol_t) effp->priv; if (effp->outinfo.channels != effp->ininfo.channels) { st_warn("VOL cannot handle different channels (in=%d, out=%d)" " use avg or pan", effp->ininfo.channels, effp->outinfo.channels); } if (effp->outinfo.rate != effp->ininfo.rate) { st_fail("VOL cannot handle different rates (in=%ld, out=%ld)" " use resample or rate", effp->ininfo.rate, effp->outinfo.rate); return ST_EOF; } vol->clipped = 0; vol->limited = 0; vol->totalprocessed = 0; return ST_SUCCESS; } /* conversion. clipping could be smoother at high ends? * this could be a function on its own, with clip count and report * handled by eff_t and caller. */ static LONG clip(vol_t vol, const VOL_FLOAT v) { if (v > LONG_MAX) { vol->clipped++; return LONG_MAX; } else if (v < -LONG_MAX) { vol->clipped++; return -LONG_MAX; } /* else */ return (LONG) v; } #ifndef MIN #define MIN(s1,s2) ((s1)<(s2)?(s1):(s2)) #endif /* * Process data. */ int st_vol_flow(effp, ibuf, obuf, isamp, osamp) eff_t effp; LONG *ibuf, *obuf; LONG *isamp, *osamp; { vol_t vol = (vol_t) effp->priv; register VOL_FLOAT gain = vol->gain; register VOL_FLOAT limiterthreshhold = vol->limiterthreshhold; register VOL_FLOAT sample; register LONG 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 = (LONG_MAX - vol->limitergain * (LONG_MAX - sample)); vol->limited++; } else if (sample < -limiterthreshhold) { sample = -(LONG_MAX - vol->limitergain * (LONG_MAX + sample)); vol->limited++; } else { sample = gain * sample; } *obuf++ = clip(vol, sample); } } else { /* quite basic, with clipping */ for (;len>0; len--) *obuf++ = clip(vol, gain * *ibuf++); } return ST_SUCCESS; } /* * Do anything required when you stop reading samples. * Don't close input file! */ int st_vol_stop(effp) eff_t effp; { vol_t vol = (vol_t) effp->priv; if (vol->limited) { st_warn("VOL limited %d values (%d percent).", vol->limited, (int) (vol->limited * 100.0 / vol->totalprocessed)); } if (vol->clipped) { st_warn("VOL clipped %d values, amplitude gain=%f too high...", vol->clipped, vol->gain); } return ST_SUCCESS; }