- 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 <[email protected]>
---
 src/pulsecore/filter/biquad.c    | 278 +++------------------------------------
 src/pulsecore/filter/biquad.h    |   8 --
 src/pulsecore/filter/crossover.c | 194 ++-------------------------
 src/pulsecore/filter/crossover.h |  51 +------
 4 files changed, 31 insertions(+), 500 deletions(-)

diff --git a/src/pulsecore/filter/biquad.c b/src/pulsecore/filter/biquad.c
index b28256d..a6121f4 100644
--- a/src/pulsecore/filter/biquad.c
+++ b/src/pulsecore/filter/biquad.c
@@ -8,20 +8,15 @@
  * found in the LICENSE.WEBKIT file.
  */
 
-#include <math.h>
-#include "biquad.h"
 
-#ifndef max
-#define max(a, b) ({ __typeof__(a) _a = (a);   \
-                       __typeof__(b) _b = (b); \
-                       _a > _b ? _a : _b; })
+#ifdef HAVE_CONFIG_H
+#include <config.h>
 #endif
 
-#ifndef min
-#define min(a, b) ({ __typeof__(a) _a = (a);   \
-                       __typeof__(b) _b = (b); \
-                       _a < _b ? _a : _b; })
-#endif
+#include <pulsecore/macro.h>
+
+#include <math.h>
+#include "biquad.h"
 
 #ifndef M_PI
 #define M_PI 3.14159265358979323846
@@ -41,15 +36,16 @@ static void set_coefficient(struct biquad *bq, double b0, 
double b1, double b2,
 static void biquad_lowpass(struct biquad *bq, double cutoff, double resonance)
 {
        /* 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 r = PA_MAX(0.0, resonance); /* can't go negative */
+               double g = pow(10.0, 0.05 * r);
                double d = sqrt((4 - sqrt(16 - 16 / (g * g))) / 2);
 
                double theta = M_PI * cutoff;
@@ -76,15 +72,16 @@ static void biquad_lowpass(struct biquad *bq, double 
cutoff, double resonance)
 static void biquad_highpass(struct biquad *bq, double cutoff, double resonance)
 {
        /* 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 r = PA_MAX(0.0, resonance); /* can't go negative */
+               double g = pow(10.0, 0.05 * r);
                double d = sqrt((4 - sqrt(16 - 16 / (g * g))) / 2);
 
                double theta = M_PI * cutoff;
@@ -110,232 +107,9 @@ static void biquad_highpass(struct biquad *bq, double 
cutoff, double resonance)
        }
 }
 
-static void biquad_bandpass(struct biquad *bq, double frequency, double Q)
-{
-       /* 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:
@@ -344,25 +118,9 @@ void biquad_set(struct biquad *bq, enum biquad_type type, 
double freq, double Q,
        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:
+               /* Identity filter. */
+               set_coefficient(bq, 1, 0, 0, 1, 0, 0);
                break;
        }
 }
diff --git a/src/pulsecore/filter/biquad.h b/src/pulsecore/filter/biquad.h
index c584aa9..4a84b61 100644
--- a/src/pulsecore/filter/biquad.h
+++ b/src/pulsecore/filter/biquad.h
@@ -21,8 +21,6 @@ extern "C" {
 struct biquad {
        float b0, b1, b2;
        float a1, a2;
-       float x1, x2;
-       float y1, y2;
 };
 
 /* The type of the biquad filters */
@@ -30,12 +28,6 @@ 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.
diff --git a/src/pulsecore/filter/crossover.c b/src/pulsecore/filter/crossover.c
index 6a817d4..c2a584b 100644
--- a/src/pulsecore/filter/crossover.c
+++ b/src/pulsecore/filter/crossover.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, 0, 0);
        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; 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; 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);
-}
diff --git a/src/pulsecore/filter/crossover.h b/src/pulsecore/filter/crossover.h
index a88f5b6..c5c9765 100644
--- a/src/pulsecore/filter/crossover.h
+++ b/src/pulsecore/filter/crossover.h
@@ -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_ */
-- 
1.9.1

_______________________________________________
pulseaudio-discuss mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/pulseaudio-discuss

Reply via email to