New crossfeed algorithm for Rockbox: "Meier" crossfeed

Emulates the basic "Meier" crossfeed (2 capacitors, 3 resistors)
as discussed in
http://www.meier-audio.homepage.t-online.de/passivefilter.htm

This crossfeed blends a bit of low-pass filtered L signal into
the R signal (and vice versa) while adding about 300 us delay
to the crossfed-signal. A difference with the crossfeed already
present in rockbox, is that this algorithm keeps the total
spectrum flat (the one currently in rockbox accentuates
low-frequency signals, making it sound a bit muffled).

This implementation is quite lightweight, just 3 multiplies per
left-right pair of samples. Has a default C implementation and
optimized assembly versions for ARM and Coldfire.

The crossfeed effect is quite subtle and is noticeable mostly
one albums that have very strong left-right separation (e.g.
one instrument only on the left, another only on the right).

In the user interface, the new crossfeed option appears as
"Meier" and is not configureable. The existing crossfeed is
renamed to "Custom" as it allows itself to be customised.

There is no entry for the user manual yet.

Change-Id: Iaa100616fe0fcd7e16f08cdb9a7f41501973eee1

1 files changed, 116 insertions, 17 deletions

diff --git a/lib/rbcodec/dsp/crossfeed.c b/lib/rbcodec/dsp/crossfeed.c
index 344addadd7..3fb51a7594 100644
--- a/lib/rbcodec/dsp/crossfeed.c
+++ b/lib/rbcodec/dsp/crossfeed.c
@@ -8,6 +8,7 @@
  * $Id$
  *
  * Copyright (C) 2006 Thom Johansen
+ * Copyright (C) 2010 Bertrik Sikken
  * Copyright (C) 2012 Michael Sevakis
  *
  * This program is free software; you can redistribute it and/or
@@ -31,7 +32,11 @@
 #include <string.h>
 
 /* Implemented here or in target assembly code */
-void crossfeed_process(struct dsp_proc_entry *this, struct dsp_buffer **buf_p);
+void crossfeed_process(struct dsp_proc_entry *this,
+                       struct dsp_buffer **buf_p);
+void crossfeed_meier_process(struct dsp_proc_entry *this,
+                             struct dsp_buffer **buf_p);
+
 
 /**
  * Applies crossfeed to the stereo signal.
@@ -46,20 +51,44 @@ static struct crossfeed_state
 {
     int32_t gain;           /* 00h: Direct path gain */
     int32_t coefs[3];       /* 04h: Coefficients for the shelving filter */
-    int32_t history[4];     /* 10h: Format is x[n - 1], y[n - 1] (L + R) */
-    int32_t delay[13*2];    /* 20h: Delay line buffer (L + R interleaved) */
+    union
+    {
+        struct              /* 10h: Data for meier crossfeed */
+        {
+            int32_t vcl;
+            int32_t vcr;
+            int32_t vdiff;
+            int32_t coef1;
+            int32_t coef2;
+        };
+        struct              /* 10h: Data for custom crossfeed */
+        {
+            int32_t history[4]; /* 10h: Format is x[n - 1], y[n - 1] (L + R) */
+            int32_t delay[13*2];/* 20h: Delay line buffer (L + R interleaved) */
+        };
+    };
     int32_t *index;         /* 88h: Current pointer into the delay line */
     struct dsp_config *dsp; /* 8ch: Current DSP */
                             /* 90h */
 } crossfeed_state IBSS_ATTR;
 
+static int crossfeed_type = CROSSFEED_TYPE_NONE;
+
 /* Discard the sample histories */
 static void crossfeed_flush(struct dsp_proc_entry *this)
 {
     struct crossfeed_state *state = (void *)this->data;
-    memset(state->history, 0, sizeof (state->history));
-    memset(state->delay, 0, sizeof (state->delay));
-    state->index = state->delay;
+
+    if (crossfeed_type == CROSSFEED_TYPE_CUSTOM)
+    {
+        memset(state->history, 0,
+            sizeof (state->history) + sizeof (state->delay));
+        state->index = state->delay;
+    }
+    else
+    {
+        state->vcl = state->vcr = state->vdiff = 0;
+    }
 }
 
 
@@ -74,30 +103,48 @@ static void crossfeed_process_new_format(struct dsp_proc_entry *this,
 
     DSP_PRINT_FORMAT(DSP_PROC_CROSSFEED, DSP_PROC_CROSSFEED, buf->format);
 
+    bool was_active = dsp_proc_active(state->dsp, DSP_PROC_CROSSFEED);
     bool active = buf->format.num_channels >= 2;
     dsp_proc_activate(state->dsp, DSP_PROC_CROSSFEED, active);
 
     if (!active)
     {
         /* Can't do this. Sleep until next change */
-        crossfeed_flush(this);
         DEBUGF("  DSP_PROC_CROSSFEED- deactivated\n");
         return;
     }
 
-    /* Switch to the real function and call it once */
-    this->process[0] = crossfeed_process;
+    dsp_proc_fn_type fn = crossfeed_process;
+
+    if (crossfeed_type != CROSSFEED_TYPE_CUSTOM)
+    {
+        /* 1 / (F.Rforward.C) */
+        state->coef1 = (0x7fffffff / NATIVE_FREQUENCY) * 2128;
+        /* 1 / (F.Rcross.C) */
+        state->coef2 = (0x7fffffff / NATIVE_FREQUENCY) * 1000;
+        fn = crossfeed_meier_process;
+    }
+
+    if (!was_active || this->process[0] != fn)
+    {
+        crossfeed_flush(this); /* Going online or actual type change */
+        this->process[0] = fn; /* Set real function */
+    }
+
+    /* Call it once */
     dsp_proc_call(this, buf_p, (unsigned)buf->format.changed - 1);
 }
 
-/* Enable or disable the crossfeed */
-void dsp_crossfeed_enable(bool enable)
+/* Set the type of crossfeed to use */
+void dsp_set_crossfeed_type(int type)
 {
-    if (enable != !crossfeed_state.dsp)
-        return;
+    if (type == crossfeed_type)
+        return; /* No change */
+
+    crossfeed_type = type;
 
     struct dsp_config *dsp = dsp_get_config(CODEC_IDX_AUDIO);
-    dsp_proc_enable(dsp, DSP_PROC_CROSSFEED, enable);
+    dsp_proc_enable(dsp, DSP_PROC_CROSSFEED, type != CROSSFEED_TYPE_NONE);
 }
 
 /* Set the gain of the dry mix */
@@ -182,6 +229,50 @@ void crossfeed_process(struct dsp_proc_entry *this, struct dsp_buffer **buf_p)
 }
 #endif /* CPU */
 
+#if !defined(CPU_COLDFIRE) && !defined(CPU_ARM)
+/**
+ * Implementation of the "simple" passive crossfeed circuit by Jan Meier.
+ * See also: http://www.meier-audio.homepage.t-online.de/passivefilter.htm
+ */
+
+void crossfeed_meier_process(struct dsp_proc_entry *this,
+                             struct dsp_buffer **buf_p)
+{
+    struct dsp_buffer *buf = *buf_p;
+
+    /* Get filter state */
+    struct crossfeed_state *state = (struct crossfeed_state *)this->data;
+    int32_t vcl = state->vcl;
+    int32_t vcr = state->vcr;
+    int32_t vdiff = state->vdiff;
+    int32_t coef1 = state->coef1;
+    int32_t coef2 = state->coef2;
+
+    int count = buf->remcount;
+
+    for (int i = 0; i < count; i++)
+    {
+        /* Calculate new output */
+        int32_t lout = buf->p32[0][i] + vcl;
+        int32_t rout = buf->p32[1][i] + vcr;
+        buf->p32[0][i] = lout;
+        buf->p32[1][i] = rout;
+
+        /* Update filter state */
+        int32_t common = FRACMUL(vdiff, coef2);
+        vcl -= FRACMUL(vcl, coef1) + common;
+        vcr -= FRACMUL(vcr, coef1) - common;
+
+        vdiff = lout - rout;
+    }
+
+    /* Store filter state */
+    state->vcl = vcl;
+    state->vcr = vcr;
+    state->vdiff = vdiff;
+}
+#endif /* CPU */
+
 /* DSP message hook */
 static intptr_t crossfeed_configure(struct dsp_proc_entry *this,
                                     struct dsp_config *dsp,
@@ -191,11 +282,19 @@ static intptr_t crossfeed_configure(struct dsp_proc_entry *this,
     switch (setting)
     {
     case DSP_PROC_INIT:
-        this->data = (intptr_t)&crossfeed_state;
+        if (value == 0)
+        {
+            /* New object */
+            this->data = (intptr_t)&crossfeed_state;
+            this->process[1] = crossfeed_process_new_format;
+            ((struct crossfeed_state *)this->data)->dsp = dsp;
+        }
+
+        /* Force format change call each time */
         this->process[0] = crossfeed_process_new_format;
-        this->process[1] = crossfeed_process_new_format;
-        ((struct crossfeed_state *)this->data)->dsp = dsp;
         dsp_proc_activate(dsp, DSP_PROC_CROSSFEED, true);
+        break;
+
     case DSP_FLUSH:
         crossfeed_flush(this);
         break;