mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-07 13:30:03 -05:00
lfe-filter: Cleanup and refactor
- Remove imported dead code - Fix compiler warnings - Fix non-GCC compiler compilation (use more portable macros) - Change lr4 struct to include a biquad struct Thanks to Alexander Patrakov for suggesting many of these changes. Signed-off-by: David Henningsson <david.henningsson@canonical.com>
This commit is contained in:
David Henningsson
parent
979f19a434
commit
3538e6636e
4 changed files with 34 additions and 516 deletions
|
|
@ -8,21 +8,16 @@
|
|||
* found in the LICENSE.WEBKIT file.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include <config.h>
|
||||
#endif
|
||||
|
||||
#include <pulsecore/macro.h>
|
||||
|
||||
#include <math.h>
|
||||
#include "biquad.h"
|
||||
|
||||
#ifndef max
|
||||
#define max(a, b) ({ __typeof__(a) _a = (a); \
|
||||
__typeof__(b) _b = (b); \
|
||||
_a > _b ? _a : _b; })
|
||||
#endif
|
||||
|
||||
#ifndef min
|
||||
#define min(a, b) ({ __typeof__(a) _a = (a); \
|
||||
__typeof__(b) _b = (b); \
|
||||
_a < _b ? _a : _b; })
|
||||
#endif
|
||||
|
||||
#ifndef M_PI
|
||||
#define M_PI 3.14159265358979323846
|
||||
#endif
|
||||
|
|
@ -38,19 +33,18 @@ static void set_coefficient(struct biquad *bq, double b0, double b1, double b2,
|
|||
bq->a2 = a2 * a0_inv;
|
||||
}
|
||||
|
||||
static void biquad_lowpass(struct biquad *bq, double cutoff, double resonance)
|
||||
static void biquad_lowpass(struct biquad *bq, double cutoff)
|
||||
{
|
||||
/* Limit cutoff to 0 to 1. */
|
||||
cutoff = max(0.0, min(cutoff, 1.0));
|
||||
cutoff = PA_MIN(cutoff, 1.0);
|
||||
cutoff = PA_MAX(0.0, cutoff);
|
||||
|
||||
if (cutoff == 1) {
|
||||
if (cutoff >= 1.0) {
|
||||
/* When cutoff is 1, the z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
} else if (cutoff > 0) {
|
||||
/* Compute biquad coefficients for lowpass filter */
|
||||
resonance = max(0.0, resonance); /* can't go negative */
|
||||
double g = pow(10.0, 0.05 * resonance);
|
||||
double d = sqrt((4 - sqrt(16 - 16 / (g * g))) / 2);
|
||||
double d = sqrt(2);
|
||||
|
||||
double theta = M_PI * cutoff;
|
||||
double sn = 0.5 * d * sin(theta);
|
||||
|
|
@ -73,19 +67,18 @@ static void biquad_lowpass(struct biquad *bq, double cutoff, double resonance)
|
|||
}
|
||||
}
|
||||
|
||||
static void biquad_highpass(struct biquad *bq, double cutoff, double resonance)
|
||||
static void biquad_highpass(struct biquad *bq, double cutoff)
|
||||
{
|
||||
/* Limit cutoff to 0 to 1. */
|
||||
cutoff = max(0.0, min(cutoff, 1.0));
|
||||
cutoff = PA_MIN(cutoff, 1.0);
|
||||
cutoff = PA_MAX(0.0, cutoff);
|
||||
|
||||
if (cutoff == 1) {
|
||||
if (cutoff >= 1.0) {
|
||||
/* The z-transform is 0. */
|
||||
set_coefficient(bq, 0, 0, 0, 1, 0, 0);
|
||||
} else if (cutoff > 0) {
|
||||
/* Compute biquad coefficients for highpass filter */
|
||||
resonance = max(0.0, resonance); /* can't go negative */
|
||||
double g = pow(10.0, 0.05 * resonance);
|
||||
double d = sqrt((4 - sqrt(16 - 16 / (g * g))) / 2);
|
||||
double d = sqrt(2);
|
||||
|
||||
double theta = M_PI * cutoff;
|
||||
double sn = 0.5 * d * sin(theta);
|
||||
|
|
@ -110,259 +103,15 @@ static void biquad_highpass(struct biquad *bq, double cutoff, double resonance)
|
|||
}
|
||||
}
|
||||
|
||||
static void biquad_bandpass(struct biquad *bq, double frequency, double Q)
|
||||
void biquad_set(struct biquad *bq, enum biquad_type type, double freq)
|
||||
{
|
||||
/* No negative frequencies allowed. */
|
||||
frequency = max(0.0, frequency);
|
||||
|
||||
/* Don't let Q go negative, which causes an unstable filter. */
|
||||
Q = max(0.0, Q);
|
||||
|
||||
if (frequency > 0 && frequency < 1) {
|
||||
double w0 = M_PI * frequency;
|
||||
if (Q > 0) {
|
||||
double alpha = sin(w0) / (2 * Q);
|
||||
double k = cos(w0);
|
||||
|
||||
double b0 = alpha;
|
||||
double b1 = 0;
|
||||
double b2 = -alpha;
|
||||
double a0 = 1 + alpha;
|
||||
double a1 = -2 * k;
|
||||
double a2 = 1 - alpha;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When Q = 0, the above formulas have problems. If we
|
||||
* look at the z-transform, we can see that the limit
|
||||
* as Q->0 is 1, so set the filter that way.
|
||||
*/
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
} else {
|
||||
/* When the cutoff is zero, the z-transform approaches 0, if Q
|
||||
* > 0. When both Q and cutoff are zero, the z-transform is
|
||||
* pretty much undefined. What should we do in this case?
|
||||
* For now, just make the filter 0. When the cutoff is 1, the
|
||||
* z-transform also approaches 0.
|
||||
*/
|
||||
set_coefficient(bq, 0, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void biquad_lowshelf(struct biquad *bq, double frequency, double db_gain)
|
||||
{
|
||||
/* Clip frequencies to between 0 and 1, inclusive. */
|
||||
frequency = max(0.0, min(frequency, 1.0));
|
||||
|
||||
double A = pow(10.0, db_gain / 40);
|
||||
|
||||
if (frequency == 1) {
|
||||
/* The z-transform is a constant gain. */
|
||||
set_coefficient(bq, A * A, 0, 0, 1, 0, 0);
|
||||
} else if (frequency > 0) {
|
||||
double w0 = M_PI * frequency;
|
||||
double S = 1; /* filter slope (1 is max value) */
|
||||
double alpha = 0.5 * sin(w0) *
|
||||
sqrt((A + 1 / A) * (1 / S - 1) + 2);
|
||||
double k = cos(w0);
|
||||
double k2 = 2 * sqrt(A) * alpha;
|
||||
double a_plus_one = A + 1;
|
||||
double a_minus_one = A - 1;
|
||||
|
||||
double b0 = A * (a_plus_one - a_minus_one * k + k2);
|
||||
double b1 = 2 * A * (a_minus_one - a_plus_one * k);
|
||||
double b2 = A * (a_plus_one - a_minus_one * k - k2);
|
||||
double a0 = a_plus_one + a_minus_one * k + k2;
|
||||
double a1 = -2 * (a_minus_one + a_plus_one * k);
|
||||
double a2 = a_plus_one + a_minus_one * k - k2;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When frequency is 0, the z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void biquad_highshelf(struct biquad *bq, double frequency,
|
||||
double db_gain)
|
||||
{
|
||||
/* Clip frequencies to between 0 and 1, inclusive. */
|
||||
frequency = max(0.0, min(frequency, 1.0));
|
||||
|
||||
double A = pow(10.0, db_gain / 40);
|
||||
|
||||
if (frequency == 1) {
|
||||
/* The z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
} else if (frequency > 0) {
|
||||
double w0 = M_PI * frequency;
|
||||
double S = 1; /* filter slope (1 is max value) */
|
||||
double alpha = 0.5 * sin(w0) *
|
||||
sqrt((A + 1 / A) * (1 / S - 1) + 2);
|
||||
double k = cos(w0);
|
||||
double k2 = 2 * sqrt(A) * alpha;
|
||||
double a_plus_one = A + 1;
|
||||
double a_minus_one = A - 1;
|
||||
|
||||
double b0 = A * (a_plus_one + a_minus_one * k + k2);
|
||||
double b1 = -2 * A * (a_minus_one + a_plus_one * k);
|
||||
double b2 = A * (a_plus_one + a_minus_one * k - k2);
|
||||
double a0 = a_plus_one - a_minus_one * k + k2;
|
||||
double a1 = 2 * (a_minus_one - a_plus_one * k);
|
||||
double a2 = a_plus_one - a_minus_one * k - k2;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When frequency = 0, the filter is just a gain, A^2. */
|
||||
set_coefficient(bq, A * A, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void biquad_peaking(struct biquad *bq, double frequency, double Q,
|
||||
double db_gain)
|
||||
{
|
||||
/* Clip frequencies to between 0 and 1, inclusive. */
|
||||
frequency = max(0.0, min(frequency, 1.0));
|
||||
|
||||
/* Don't let Q go negative, which causes an unstable filter. */
|
||||
Q = max(0.0, Q);
|
||||
|
||||
double A = pow(10.0, db_gain / 40);
|
||||
|
||||
if (frequency > 0 && frequency < 1) {
|
||||
if (Q > 0) {
|
||||
double w0 = M_PI * frequency;
|
||||
double alpha = sin(w0) / (2 * Q);
|
||||
double k = cos(w0);
|
||||
|
||||
double b0 = 1 + alpha * A;
|
||||
double b1 = -2 * k;
|
||||
double b2 = 1 - alpha * A;
|
||||
double a0 = 1 + alpha / A;
|
||||
double a1 = -2 * k;
|
||||
double a2 = 1 - alpha / A;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When Q = 0, the above formulas have problems. If we
|
||||
* look at the z-transform, we can see that the limit
|
||||
* as Q->0 is A^2, so set the filter that way.
|
||||
*/
|
||||
set_coefficient(bq, A * A, 0, 0, 1, 0, 0);
|
||||
}
|
||||
} else {
|
||||
/* When frequency is 0 or 1, the z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void biquad_notch(struct biquad *bq, double frequency, double Q)
|
||||
{
|
||||
/* Clip frequencies to between 0 and 1, inclusive. */
|
||||
frequency = max(0.0, min(frequency, 1.0));
|
||||
|
||||
/* Don't let Q go negative, which causes an unstable filter. */
|
||||
Q = max(0.0, Q);
|
||||
|
||||
if (frequency > 0 && frequency < 1) {
|
||||
if (Q > 0) {
|
||||
double w0 = M_PI * frequency;
|
||||
double alpha = sin(w0) / (2 * Q);
|
||||
double k = cos(w0);
|
||||
|
||||
double b0 = 1;
|
||||
double b1 = -2 * k;
|
||||
double b2 = 1;
|
||||
double a0 = 1 + alpha;
|
||||
double a1 = -2 * k;
|
||||
double a2 = 1 - alpha;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When Q = 0, the above formulas have problems. If we
|
||||
* look at the z-transform, we can see that the limit
|
||||
* as Q->0 is 0, so set the filter that way.
|
||||
*/
|
||||
set_coefficient(bq, 0, 0, 0, 1, 0, 0);
|
||||
}
|
||||
} else {
|
||||
/* When frequency is 0 or 1, the z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void biquad_allpass(struct biquad *bq, double frequency, double Q)
|
||||
{
|
||||
/* Clip frequencies to between 0 and 1, inclusive. */
|
||||
frequency = max(0.0, min(frequency, 1.0));
|
||||
|
||||
/* Don't let Q go negative, which causes an unstable filter. */
|
||||
Q = max(0.0, Q);
|
||||
|
||||
if (frequency > 0 && frequency < 1) {
|
||||
if (Q > 0) {
|
||||
double w0 = M_PI * frequency;
|
||||
double alpha = sin(w0) / (2 * Q);
|
||||
double k = cos(w0);
|
||||
|
||||
double b0 = 1 - alpha;
|
||||
double b1 = -2 * k;
|
||||
double b2 = 1 + alpha;
|
||||
double a0 = 1 + alpha;
|
||||
double a1 = -2 * k;
|
||||
double a2 = 1 - alpha;
|
||||
|
||||
set_coefficient(bq, b0, b1, b2, a0, a1, a2);
|
||||
} else {
|
||||
/* When Q = 0, the above formulas have problems. If we
|
||||
* look at the z-transform, we can see that the limit
|
||||
* as Q->0 is -1, so set the filter that way.
|
||||
*/
|
||||
set_coefficient(bq, -1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
} else {
|
||||
/* When frequency is 0 or 1, the z-transform is 1. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void biquad_set(struct biquad *bq, enum biquad_type type, double freq, double Q,
|
||||
double gain)
|
||||
{
|
||||
/* Default is an identity filter. Also clear history values. */
|
||||
set_coefficient(bq, 1, 0, 0, 1, 0, 0);
|
||||
bq->x1 = 0;
|
||||
bq->x2 = 0;
|
||||
bq->y1 = 0;
|
||||
bq->y2 = 0;
|
||||
|
||||
switch (type) {
|
||||
case BQ_LOWPASS:
|
||||
biquad_lowpass(bq, freq, Q);
|
||||
biquad_lowpass(bq, freq);
|
||||
break;
|
||||
case BQ_HIGHPASS:
|
||||
biquad_highpass(bq, freq, Q);
|
||||
break;
|
||||
case BQ_BANDPASS:
|
||||
biquad_bandpass(bq, freq, Q);
|
||||
break;
|
||||
case BQ_LOWSHELF:
|
||||
biquad_lowshelf(bq, freq, gain);
|
||||
break;
|
||||
case BQ_HIGHSHELF:
|
||||
biquad_highshelf(bq, freq, gain);
|
||||
break;
|
||||
case BQ_PEAKING:
|
||||
biquad_peaking(bq, freq, Q, gain);
|
||||
break;
|
||||
case BQ_NOTCH:
|
||||
biquad_notch(bq, freq, Q);
|
||||
break;
|
||||
case BQ_ALLPASS:
|
||||
biquad_allpass(bq, freq, Q);
|
||||
break;
|
||||
case BQ_NONE:
|
||||
biquad_highpass(bq, freq);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,21 +21,12 @@ extern "C" {
|
|||
struct biquad {
|
||||
float b0, b1, b2;
|
||||
float a1, a2;
|
||||
float x1, x2;
|
||||
float y1, y2;
|
||||
};
|
||||
|
||||
/* The type of the biquad filters */
|
||||
enum biquad_type {
|
||||
BQ_NONE,
|
||||
BQ_LOWPASS,
|
||||
BQ_HIGHPASS,
|
||||
BQ_BANDPASS,
|
||||
BQ_LOWSHELF,
|
||||
BQ_HIGHSHELF,
|
||||
BQ_PEAKING,
|
||||
BQ_NOTCH,
|
||||
BQ_ALLPASS
|
||||
};
|
||||
|
||||
/* Initialize a biquad filter parameters from its type and parameters.
|
||||
|
|
@ -44,11 +35,8 @@ enum biquad_type {
|
|||
* type - The type of the biquad filter.
|
||||
* frequency - The value should be in the range [0, 1]. It is relative to
|
||||
* half of the sampling rate.
|
||||
* Q - Quality factor. See Web Audio API for details.
|
||||
* gain - The value is in dB. See Web Audio API for details.
|
||||
*/
|
||||
void biquad_set(struct biquad *bq, enum biquad_type type, double freq, double Q,
|
||||
double gain);
|
||||
void biquad_set(struct biquad *bq, enum biquad_type type, double freq);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
|
|
|
|||
|
|
@ -9,18 +9,11 @@
|
|||
|
||||
#include <pulsecore/macro.h>
|
||||
|
||||
#include "biquad.h"
|
||||
#include "crossover.h"
|
||||
|
||||
void lr4_set(struct lr4 *lr4, enum biquad_type type, float freq)
|
||||
{
|
||||
struct biquad q;
|
||||
biquad_set(&q, type, freq, 0, 0);
|
||||
lr4->b0 = q.b0;
|
||||
lr4->b1 = q.b1;
|
||||
lr4->b2 = q.b2;
|
||||
lr4->a1 = q.a1;
|
||||
lr4->a2 = q.a2;
|
||||
biquad_set(&lr4->bq, type, freq);
|
||||
lr4->x1 = 0;
|
||||
lr4->x2 = 0;
|
||||
lr4->y1 = 0;
|
||||
|
|
@ -37,11 +30,11 @@ void lr4_process_float32(struct lr4 *lr4, int samples, int channels, float *src,
|
|||
float ly2 = lr4->y2;
|
||||
float lz1 = lr4->z1;
|
||||
float lz2 = lr4->z2;
|
||||
float lb0 = lr4->b0;
|
||||
float lb1 = lr4->b1;
|
||||
float lb2 = lr4->b2;
|
||||
float la1 = lr4->a1;
|
||||
float la2 = lr4->a2;
|
||||
float lb0 = lr4->bq.b0;
|
||||
float lb1 = lr4->bq.b1;
|
||||
float lb2 = lr4->bq.b2;
|
||||
float la1 = lr4->bq.a1;
|
||||
float la2 = lr4->bq.a2;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < samples * channels; i += channels) {
|
||||
|
|
@ -74,11 +67,11 @@ void lr4_process_s16(struct lr4 *lr4, int samples, int channels, short *src, sho
|
|||
float ly2 = lr4->y2;
|
||||
float lz1 = lr4->z1;
|
||||
float lz2 = lr4->z2;
|
||||
float lb0 = lr4->b0;
|
||||
float lb1 = lr4->b1;
|
||||
float lb2 = lr4->b2;
|
||||
float la1 = lr4->a1;
|
||||
float la2 = lr4->a2;
|
||||
float lb0 = lr4->bq.b0;
|
||||
float lb1 = lr4->bq.b1;
|
||||
float lb2 = lr4->bq.b2;
|
||||
float la1 = lr4->bq.a1;
|
||||
float la2 = lr4->bq.a2;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < samples * channels; i += channels) {
|
||||
|
|
@ -102,168 +95,3 @@ void lr4_process_s16(struct lr4 *lr4, int samples, int channels, short *src, sho
|
|||
lr4->z1 = lz1;
|
||||
lr4->z2 = lz2;
|
||||
}
|
||||
|
||||
|
||||
/* Split input data using two LR4 filters, put the result into the input array
|
||||
* and another array.
|
||||
*
|
||||
* data0 --+-- lp --> data0
|
||||
* |
|
||||
* \-- hp --> data1
|
||||
*/
|
||||
static void lr4_split(struct lr4 *lp, struct lr4 *hp, int count, float *data0,
|
||||
float *data1)
|
||||
{
|
||||
float lx1 = lp->x1;
|
||||
float lx2 = lp->x2;
|
||||
float ly1 = lp->y1;
|
||||
float ly2 = lp->y2;
|
||||
float lz1 = lp->z1;
|
||||
float lz2 = lp->z2;
|
||||
float lb0 = lp->b0;
|
||||
float lb1 = lp->b1;
|
||||
float lb2 = lp->b2;
|
||||
float la1 = lp->a1;
|
||||
float la2 = lp->a2;
|
||||
|
||||
float hx1 = hp->x1;
|
||||
float hx2 = hp->x2;
|
||||
float hy1 = hp->y1;
|
||||
float hy2 = hp->y2;
|
||||
float hz1 = hp->z1;
|
||||
float hz2 = hp->z2;
|
||||
float hb0 = hp->b0;
|
||||
float hb1 = hp->b1;
|
||||
float hb2 = hp->b2;
|
||||
float ha1 = hp->a1;
|
||||
float ha2 = hp->a2;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < count; i++) {
|
||||
float x, y, z;
|
||||
x = data0[i];
|
||||
y = lb0*x + lb1*lx1 + lb2*lx2 - la1*ly1 - la2*ly2;
|
||||
z = lb0*y + lb1*ly1 + lb2*ly2 - la1*lz1 - la2*lz2;
|
||||
lx2 = lx1;
|
||||
lx1 = x;
|
||||
ly2 = ly1;
|
||||
ly1 = y;
|
||||
lz2 = lz1;
|
||||
lz1 = z;
|
||||
data0[i] = z;
|
||||
|
||||
y = hb0*x + hb1*hx1 + hb2*hx2 - ha1*hy1 - ha2*hy2;
|
||||
z = hb0*y + hb1*hy1 + hb2*hy2 - ha1*hz1 - ha2*hz2;
|
||||
hx2 = hx1;
|
||||
hx1 = x;
|
||||
hy2 = hy1;
|
||||
hy1 = y;
|
||||
hz2 = hz1;
|
||||
hz1 = z;
|
||||
data1[i] = z;
|
||||
}
|
||||
|
||||
lp->x1 = lx1;
|
||||
lp->x2 = lx2;
|
||||
lp->y1 = ly1;
|
||||
lp->y2 = ly2;
|
||||
lp->z1 = lz1;
|
||||
lp->z2 = lz2;
|
||||
|
||||
hp->x1 = hx1;
|
||||
hp->x2 = hx2;
|
||||
hp->y1 = hy1;
|
||||
hp->y2 = hy2;
|
||||
hp->z1 = hz1;
|
||||
hp->z2 = hz2;
|
||||
}
|
||||
|
||||
/* Split input data using two LR4 filters and sum them back to the original
|
||||
* data array.
|
||||
*
|
||||
* data --+-- lp --+--> data
|
||||
* | |
|
||||
* \-- hp --/
|
||||
*/
|
||||
static void lr4_merge(struct lr4 *lp, struct lr4 *hp, int count, float *data)
|
||||
{
|
||||
float lx1 = lp->x1;
|
||||
float lx2 = lp->x2;
|
||||
float ly1 = lp->y1;
|
||||
float ly2 = lp->y2;
|
||||
float lz1 = lp->z1;
|
||||
float lz2 = lp->z2;
|
||||
float lb0 = lp->b0;
|
||||
float lb1 = lp->b1;
|
||||
float lb2 = lp->b2;
|
||||
float la1 = lp->a1;
|
||||
float la2 = lp->a2;
|
||||
|
||||
float hx1 = hp->x1;
|
||||
float hx2 = hp->x2;
|
||||
float hy1 = hp->y1;
|
||||
float hy2 = hp->y2;
|
||||
float hz1 = hp->z1;
|
||||
float hz2 = hp->z2;
|
||||
float hb0 = hp->b0;
|
||||
float hb1 = hp->b1;
|
||||
float hb2 = hp->b2;
|
||||
float ha1 = hp->a1;
|
||||
float ha2 = hp->a2;
|
||||
|
||||
int i;
|
||||
for (i = 0; i < count; i++) {
|
||||
float x, y, z;
|
||||
x = data[i];
|
||||
y = lb0*x + lb1*lx1 + lb2*lx2 - la1*ly1 - la2*ly2;
|
||||
z = lb0*y + lb1*ly1 + lb2*ly2 - la1*lz1 - la2*lz2;
|
||||
lx2 = lx1;
|
||||
lx1 = x;
|
||||
ly2 = ly1;
|
||||
ly1 = y;
|
||||
lz2 = lz1;
|
||||
lz1 = z;
|
||||
|
||||
y = hb0*x + hb1*hx1 + hb2*hx2 - ha1*hy1 - ha2*hy2;
|
||||
z = hb0*y + hb1*hy1 + hb2*hy2 - ha1*hz1 - ha2*hz2;
|
||||
hx2 = hx1;
|
||||
hx1 = x;
|
||||
hy2 = hy1;
|
||||
hy1 = y;
|
||||
hz2 = hz1;
|
||||
hz1 = z;
|
||||
data[i] = z + lz1;
|
||||
}
|
||||
|
||||
lp->x1 = lx1;
|
||||
lp->x2 = lx2;
|
||||
lp->y1 = ly1;
|
||||
lp->y2 = ly2;
|
||||
lp->z1 = lz1;
|
||||
lp->z2 = lz2;
|
||||
|
||||
hp->x1 = hx1;
|
||||
hp->x2 = hx2;
|
||||
hp->y1 = hy1;
|
||||
hp->y2 = hy2;
|
||||
hp->z1 = hz1;
|
||||
hp->z2 = hz2;
|
||||
}
|
||||
|
||||
void crossover_init(struct crossover *xo, float freq1, float freq2)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < 3; i++) {
|
||||
float f = (i == 0) ? freq1 : freq2;
|
||||
lr4_set(&xo->lp[i], BQ_LOWPASS, f);
|
||||
lr4_set(&xo->hp[i], BQ_HIGHPASS, f);
|
||||
}
|
||||
}
|
||||
|
||||
void crossover_process(struct crossover *xo, int count, float *data0,
|
||||
float *data1, float *data2)
|
||||
{
|
||||
lr4_split(&xo->lp[0], &xo->hp[0], count, data0, data1);
|
||||
lr4_merge(&xo->lp[1], &xo->hp[1], count, data0);
|
||||
lr4_split(&xo->lp[2], &xo->hp[2], count, data1, data2);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,10 +6,7 @@
|
|||
#ifndef CROSSOVER_H_
|
||||
#define CROSSOVER_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "biquad.h"
|
||||
/* An LR4 filter is two biquads with the same parameters connected in series:
|
||||
*
|
||||
* x -- [BIQUAD] -- y -- [BIQUAD] -- z
|
||||
|
|
@ -18,8 +15,7 @@ extern "C" {
|
|||
* The variable [xyz][12] keep the history values.
|
||||
*/
|
||||
struct lr4 {
|
||||
float b0, b1, b2;
|
||||
float a1, a2;
|
||||
struct biquad bq;
|
||||
float x1, x2;
|
||||
float y1, y2;
|
||||
float z1, z2;
|
||||
|
|
@ -30,47 +26,4 @@ void lr4_set(struct lr4 *lr4, enum biquad_type type, float freq);
|
|||
void lr4_process_float32(struct lr4 *lr4, int samples, int channels, float *src, float *dest);
|
||||
void lr4_process_s16(struct lr4 *lr4, int samples, int channels, short *src, short *dest);
|
||||
|
||||
|
||||
/* Three bands crossover filter:
|
||||
*
|
||||
* INPUT --+-- lp0 --+-- lp1 --+---> LOW (0)
|
||||
* | | |
|
||||
* | \-- hp1 --/
|
||||
* |
|
||||
* \-- hp0 --+-- lp2 ------> MID (1)
|
||||
* |
|
||||
* \-- hp2 ------> HIGH (2)
|
||||
*
|
||||
* [f0] [f1]
|
||||
*
|
||||
* Each lp or hp is an LR4 filter, which consists of two second-order
|
||||
* lowpass or highpass butterworth filters.
|
||||
*/
|
||||
struct crossover {
|
||||
struct lr4 lp[3], hp[3];
|
||||
};
|
||||
|
||||
/* Initializes a crossover filter
|
||||
* Args:
|
||||
* xo - The crossover filter we want to initialize.
|
||||
* freq1 - The normalized frequency splits low and mid band.
|
||||
* freq2 - The normalized frequency splits mid and high band.
|
||||
*/
|
||||
void crossover_init(struct crossover *xo, float freq1, float freq2);
|
||||
|
||||
/* Splits input samples to three bands.
|
||||
* Args:
|
||||
* xo - The crossover filter to use.
|
||||
* count - The number of input samples.
|
||||
* data0 - The input samples, also the place to store low band output.
|
||||
* data1 - The place to store mid band output.
|
||||
* data2 - The place to store high band output.
|
||||
*/
|
||||
void crossover_process(struct crossover *xo, int count, float *data0,
|
||||
float *data1, float *data2);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
|
||||
#endif /* CROSSOVER_H_ */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue