double pa_sw_volume_to_dB(pa_volume_t v) {
pa_return_val_if_fail(PA_VOLUME_IS_VALID(v), PA_DECIBEL_MININFTY);
if (v <= PA_VOLUME_MUTED)
return PA_DECIBEL_MININFTY;
return linear_to_dB(pa_sw_volume_to_linear(v));
}
static sox_bool aboveThreshold(sox_effect_t const * effp,
sox_sample_t value /* >= 0 */, double threshold, int unit)
{
/* When scaling low bit data, noise values got scaled way up */
/* Only consider the original bits when looking for silence */
sox_sample_t masked_value = value & (-1 << (32 - effp->in_signal.precision));
double scaled_value = (double)masked_value / SOX_SAMPLE_MAX;
if (unit == '%')
scaled_value *= 100;
else if (unit == 'd')
scaled_value = linear_to_dB(scaled_value);
return scaled_value > threshold;
}
static int start(sox_effect_t * effp)
{
priv_t * p = (priv_t *)effp->priv;
double w0, A, alpha, mult;
if (p->filter_type == filter_deemph) { /* See deemph.plt for documentation */
if (effp->in_signal.rate == 44100) {
p->fc = 5283;
p->width = 0.4845;
p->gain = -9.477;
}
else if (effp->in_signal.rate == 48000) {
p->fc = 5356;
p->width = 0.479;
p->gain = -9.62;
}
else {
lsx_fail("sample rate must be 44100 (audio-CD) or 48000 (DAT)");
return SOX_EOF;
}
}
w0 = 2 * M_PI * p->fc / effp->in_signal.rate;
A = exp(p->gain / 40 * log(10.));
alpha = 0, mult = dB_to_linear(max(p->gain, 0));
if (w0 > M_PI) {
lsx_fail("frequency must be less than half the sample-rate (Nyquist rate)");
return SOX_EOF;
}
/* Set defaults: */
p->b0 = p->b1 = p->b2 = p->a1 = p->a2 = 0;
p->a0 = 1;
if (p->width) switch (p->width_type) {
case width_slope:
alpha = sin(w0)/2 * sqrt((A + 1/A)*(1/p->width - 1) + 2);
break;
case width_Q:
alpha = sin(w0)/(2*p->width);
break;
case width_bw_oct:
alpha = sin(w0)*sinh(log(2.)/2 * p->width * w0/sin(w0));
break;
case width_bw_Hz:
alpha = sin(w0)/(2*p->fc/p->width);
break;
case width_bw_kHz: assert(0); /* Shouldn't get here */
case width_bw_old:
alpha = tan(M_PI * p->width / effp->in_signal.rate);
break;
}
switch (p->filter_type) {
case filter_LPF: /* H(s) = 1 / (s^2 + s/Q + 1) */
p->b0 = (1 - cos(w0))/2;
p->b1 = 1 - cos(w0);
p->b2 = (1 - cos(w0))/2;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_HPF: /* H(s) = s^2 / (s^2 + s/Q + 1) */
p->b0 = (1 + cos(w0))/2;
p->b1 = -(1 + cos(w0));
p->b2 = (1 + cos(w0))/2;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_BPF_CSG: /* H(s) = s / (s^2 + s/Q + 1) (constant skirt gain, peak gain = Q) */
p->b0 = sin(w0)/2;
p->b1 = 0;
p->b2 = -sin(w0)/2;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_BPF: /* H(s) = (s/Q) / (s^2 + s/Q + 1) (constant 0 dB peak gain) */
p->b0 = alpha;
p->b1 = 0;
p->b2 = -alpha;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_notch: /* H(s) = (s^2 + 1) / (s^2 + s/Q + 1) */
p->b0 = 1;
p->b1 = -2*cos(w0);
p->b2 = 1;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_APF: /* H(s) = (s^2 - s/Q + 1) / (s^2 + s/Q + 1) */
p->b0 = 1 - alpha;
p->b1 = -2*cos(w0);
p->b2 = 1 + alpha;
p->a0 = 1 + alpha;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha;
break;
case filter_peakingEQ: /* H(s) = (s^2 + s*(A/Q) + 1) / (s^2 + s/(A*Q) + 1) */
if (A == 1)
return SOX_EFF_NULL;
p->b0 = 1 + alpha*A;
p->b1 = -2*cos(w0);
p->b2 = 1 - alpha*A;
p->a0 = 1 + alpha/A;
p->a1 = -2*cos(w0);
p->a2 = 1 - alpha/A;
break;
case filter_lowShelf: /* H(s) = A * (s^2 + (sqrt(A)/Q)*s + A)/(A*s^2 + (sqrt(A)/Q)*s + 1) */
if (A == 1)
return SOX_EFF_NULL;
p->b0 = A*( (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha );
p->b1 = 2*A*( (A-1) - (A+1)*cos(w0) );
p->b2 = A*( (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha );
p->a0 = (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha;
p->a1 = -2*( (A-1) + (A+1)*cos(w0) );
p->a2 = (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha;
break;
case filter_deemph: /* Falls through to high-shelf... */
case filter_highShelf: /* H(s) = A * (A*s^2 + (sqrt(A)/Q)*s + 1)/(s^2 + (sqrt(A)/Q)*s + A) */
if (!A)
return SOX_EFF_NULL;
p->b0 = A*( (A+1) + (A-1)*cos(w0) + 2*sqrt(A)*alpha );
p->b1 = -2*A*( (A-1) + (A+1)*cos(w0) );
p->b2 = A*( (A+1) + (A-1)*cos(w0) - 2*sqrt(A)*alpha );
p->a0 = (A+1) - (A-1)*cos(w0) + 2*sqrt(A)*alpha;
p->a1 = 2*( (A-1) - (A+1)*cos(w0) );
p->a2 = (A+1) - (A-1)*cos(w0) - 2*sqrt(A)*alpha;
break;
case filter_LPF_1: /* single-pole */
p->a1 = -exp(-w0);
p->b0 = 1 + p->a1;
break;
case filter_HPF_1: /* single-pole */
p->a1 = -exp(-w0);
p->b0 = (1 - p->a1)/2;
p->b1 = -p->b0;
break;
case filter_BPF_SPK: case filter_BPF_SPK_N: {
double bw_Hz;
if (!p->width)
p->width = p->fc / 2;
bw_Hz = p->width_type == width_Q? p->fc / p->width :
p->width_type == width_bw_Hz? p->width :
p->fc * (pow(2., p->width) - 1) * pow(2., -0.5 * p->width); /* bw_oct */
#include "band.h" /* Has different licence */
break;
}
case filter_AP1: /* Experimental 1-pole all-pass from Tom Erbe @ UCSD */
p->b0 = exp(-w0);
p->b1 = -1;
p->a1 = -exp(-w0);
break;
case filter_AP2: /* Experimental 2-pole all-pass from Tom Erbe @ UCSD */
p->b0 = 1 - sin(w0);
p->b1 = -2 * cos(w0);
p->b2 = 1 + sin(w0);
p->a0 = 1 + sin(w0);
p->a1 = -2 * cos(w0);
p->a2 = 1 - sin(w0);
break;
case filter_riaa: /* http://www.dsprelated.com/showmessage/73300/3.php */
if (effp->in_signal.rate == 44100) {
static const double zeros[] = {-0.2014898, 0.9233820};
static const double poles[] = {0.7083149, 0.9924091};
make_poly_from_roots(zeros, (size_t)2, &p->b0);
make_poly_from_roots(poles, (size_t)2, &p->a0);
}
else if (effp->in_signal.rate == 48000) {
static const double zeros[] = {-0.1766069, 0.9321590};
static const double poles[] = {0.7396325, 0.9931330};
make_poly_from_roots(zeros, (size_t)2, &p->b0);
make_poly_from_roots(poles, (size_t)2, &p->a0);
}
else if (effp->in_signal.rate == 88200) {
static const double zeros[] = {-0.1168735, 0.9648312};
static const double poles[] = {0.8590646, 0.9964002};
make_poly_from_roots(zeros, (size_t)2, &p->b0);
make_poly_from_roots(poles, (size_t)2, &p->a0);
}
else if (effp->in_signal.rate == 96000) {
static const double zeros[] = {-0.1141486, 0.9676817};
static const double poles[] = {0.8699137, 0.9966946};
make_poly_from_roots(zeros, (size_t)2, &p->b0);
make_poly_from_roots(poles, (size_t)2, &p->a0);
}
else {
lsx_fail("Sample rate must be 44.1k, 48k, 88.2k, or 96k");
return SOX_EOF;
}
{ /* Normalise to 0dB at 1kHz (Thanks to Glenn Davis) */
double y = 2 * M_PI * 1000 / effp->in_signal.rate;
double b_re = p->b0 + p->b1 * cos(-y) + p->b2 * cos(-2 * y);
double a_re = p->a0 + p->a1 * cos(-y) + p->a2 * cos(-2 * y);
double b_im = p->b1 * sin(-y) + p->b2 * sin(-2 * y);
double a_im = p->a1 * sin(-y) + p->a2 * sin(-2 * y);
double g = 1 / sqrt((sqr(b_re) + sqr(b_im)) / (sqr(a_re) + sqr(a_im)));
p->b0 *= g; p->b1 *= g; p->b2 *= g;
}
mult = (p->b0 + p->b1 + p->b2) / (p->a0 + p->a1 + p->a2);
lsx_debug("gain=%f", linear_to_dB(mult));
break;
}
if (effp->in_signal.mult)
*effp->in_signal.mult /= mult;
return lsx_biquad_start(effp);
}
static int stop(sox_effect_t * effp)
{
priv_t * p = (priv_t *)effp->priv;
if (!effp->flow) {
double min_runs = 0, max_count = 0, min = 2, max = -2, max_sigma_x = 0, sigma_x = 0, sigma_x2 = 0, min_sigma_x2 = 2, max_sigma_x2 = 0, avg_peak = 0;
off_t num_samples = 0, min_count = 0, max_runs = 0;
uint32_t mask = 0;
unsigned b1, b2, i, n = effp->flows > 1 ? effp->flows : 0;
for (i = 0; i < effp->flows; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
min = min(min, q->min);
max = max(max, q->max);
min_sigma_x2 = min(min_sigma_x2, q->min_sigma_x2);
max_sigma_x2 = max(max_sigma_x2, q->max_sigma_x2);
sigma_x += q->sigma_x;
sigma_x2 += q->sigma_x2;
num_samples += q->num_samples;
mask |= q->mask;
if (fabs(q->sigma_x) > fabs(max_sigma_x))
max_sigma_x = q->sigma_x;
min_count += q->min_count;
min_runs += q->min_runs;
max_count += q->max_count;
max_runs += q->max_runs;
avg_peak += max(-q->min, q->max);
}
avg_peak /= effp->flows;
if (!num_samples) {
lsx_warn("no audio");
return SOX_SUCCESS;
}
if (n == 2)
fprintf(stderr, " Overall Left Right\n");
else if (n) {
fprintf(stderr, " Overall");
for (i = 0; i < n; ++i)
fprintf(stderr, " Ch%-3i", i + 1);
fprintf(stderr, "\n");
}
fprintf(stderr, "DC offset ");
output(p, max_sigma_x / p->num_samples);
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
output(p, q->sigma_x / q->num_samples);
}
fprintf(stderr, "\nMin level ");
output(p, min);
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
output(p, q->min);
}
fprintf(stderr, "\nMax level ");
output(p, max);
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
output(p, q->max);
}
fprintf(stderr, "\nPk lev dB %10.2f", linear_to_dB(max(-min, max)));
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, "%10.2f", linear_to_dB(max(-q->min, q->max)));
}
fprintf(stderr, "\nRMS lev dB%10.2f", linear_to_dB(sqrt(sigma_x2 / num_samples)));
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, "%10.2f", linear_to_dB(sqrt(q->sigma_x2 / q->num_samples)));
}
fprintf(stderr, "\nRMS Pk dB %10.2f", linear_to_dB(sqrt(max_sigma_x2)));
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, "%10.2f", linear_to_dB(sqrt(q->max_sigma_x2)));
}
fprintf(stderr, "\nRMS Tr dB ");
if (min_sigma_x2 != 1)
fprintf(stderr, "%10.2f", linear_to_dB(sqrt(min_sigma_x2)));
else fprintf(stderr, " -");
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
if (q->min_sigma_x2 != 1)
fprintf(stderr, "%10.2f", linear_to_dB(sqrt(q->min_sigma_x2)));
else fprintf(stderr, " -");
}
if (effp->flows > 1)
fprintf(stderr, "\nCrest factor -");
else fprintf(stderr, "\nCrest factor %7.2f", sigma_x2 ? avg_peak / sqrt(sigma_x2 / num_samples) : 1);
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, "%10.2f", q->sigma_x2? max(-q->min, q->max) / sqrt(q->sigma_x2 / q->num_samples) : 1);
}
fprintf(stderr, "\nFlat factor%9.2f", linear_to_dB((min_runs + max_runs) / (min_count + max_count)));
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, " %9.2f", linear_to_dB((q->min_runs + q->max_runs) / (q->min_count + q->max_count)));
}
fprintf(stderr, "\nPk count %9s", lsx_sigfigs3((min_count + max_count) / effp->flows));
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
fprintf(stderr, " %9s", lsx_sigfigs3((double)(q->min_count + q->max_count)));
}
b1 = bit_depth(mask, min, max, &b2);
fprintf(stderr, "\nBit-depth %2u/%-2u", b1, b2);
for (i = 0; i < n; ++i) {
priv_t * q = (priv_t *)(effp - effp->flow + i)->priv;
b1 = bit_depth(q->mask, q->min, q->max, &b2);
fprintf(stderr, " %2u/%-2u", b1, b2);
}
fprintf(stderr, "\nNum samples%9s", lsx_sigfigs3((double)p->num_samples));
fprintf(stderr, "\nLength s %9.3f", p->num_samples / effp->in_signal.rate);
fprintf(stderr, "\nScale max ");
output(p, 1.);
fprintf(stderr, "\nWindow s %9.3f", p->time_constant);
fprintf(stderr, "\n");
}
return SOX_SUCCESS;
}
