remap: Add special remapping case which just re-arranges channels

Input channels may just be copied to output channels, no mixing; this
avoids the generic (slow) matrix remapping code in cases where channels
are dropped or reordered.
This makes use of the remap struct state introduced earlier.

on Intel Core i7-870 @ 2.93 GHz (GCC 4.6, 64-bit):

Checking special remap (s16, stereo rearrange)
func: 126117 usec (avg: 1261.17, min = 1150, max = 2111, stddev = 117.332).
orig: 190509 usec (avg: 1905.09, min = 1807, max = 2402, stddev = 100.984).
Checking special remap (float, stereo rearrange)
func: 194329 usec (avg: 1943.29, min = 1876, max = 2127, stddev = 64.3486).
orig: 205263 usec (avg: 2052.63, min = 2005, max = 2452, stddev = 70.177).
Checking special remap (s16, 4-channel rearrange)
func: 278754 usec (avg: 2787.54, min = 2719, max = 3093, stddev = 78.22).
orig: 383885 usec (avg: 3838.85, min = 3634, max = 4121, stddev = 128.522).
Checking special remap (float, 4-channel rearrange)
func: 312429 usec (avg: 3124.29, min = 3017, max = 3498, stddev = 120.127).
orig: 388198 usec (avg: 3881.98, min = 3768, max = 4655, stddev = 138.441).

on ARM Cortex-A8 (TI OMAP3 DM3730 @ 1GHz) (Linaro GCC 4.6):

Checking special remap (s16, stereo rearrange)
func: 1204647 usec (avg: 12046.5, min = 10406, max = 25451, stddev = 2491.9).
orig: 1660311 usec (avg: 16603.1, min = 14740, max = 20416, stddev = 1708.07).
Checking special remap (float, stereo rearrange)
func: 1391392 usec (avg: 13913.9, min = 12207, max = 28260, stddev = 2238.12).
orig: 9246707 usec (avg: 92467.1, min = 87525, max = 125611, stddev = 5494.64).
Checking special remap (s16, 4-channel rearrange)
func: 2540225 usec (avg: 25402.2, min = 16937, max = 68268, stddev = 10786.7).
orig: 3319852 usec (avg: 33198.5, min = 29571, max = 36957, stddev = 1250.39).
Checking special remap (float, 4-channel rearrange)
func: 3024414 usec (avg: 30244.1, min = 26153, max = 58105, stddev = 4506.01).
orig: 12643624 usec (avg: 126436, min = 120575, max = 159088, stddev = 5519.28).

benchmark code will be posted as follow-up patches

Signed-off-by: Peter Meerwald <pmeerw@pmeerw.net>

diff --git a/src/pulsecore/remap.c b/src/pulsecore/remap.c
index c3de424a49598d08e9a1df3048711337052d0a78..80194a41f57d30793c4f11b9d68ec07fb3c8decd 100644 (file)
--- a/src/pulsecore/remap.c
+++ b/src/pulsecore/remap.c
@@ -26,6 +26,7 @@
 
 #include <string.h>
 
+#include <pulse/xmalloc.h>
 #include <pulse/sample.h>
 #include <pulse/volume.h>
 #include <pulsecore/log.h>
@@ -158,6 +159,60 @@ bool pa_setup_remap_arrange(const pa_remap_t *m, int8_t arrange[PA_CHANNELS_MAX]
     return true;
 }
 
+static void remap_arrange_stereo_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
+    const unsigned n_ic = m->i_ss.channels;
+    const int8_t *arrange = m->state;
+    const int8_t ic0 = arrange[0], ic1 = arrange[1];
+
+    for (; n > 0; n--) {
+        *dst++ = (ic0 >= 0) ? *(src + ic0) : 0;
+        *dst++ = (ic1 >= 0) ? *(src + ic1) : 0;
+        src += n_ic;
+    }
+}
+
+static void remap_arrange_ch4_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
+    const unsigned n_ic = m->i_ss.channels;
+    const int8_t *arrange = m->state;
+    const int8_t ic0 = arrange[0], ic1 = arrange[1],
+        ic2 = arrange[2], ic3 = arrange[3];
+
+    for (; n > 0; n--) {
+        *dst++ = (ic0 >= 0) ? *(src + ic0) : 0;
+        *dst++ = (ic1 >= 0) ? *(src + ic1) : 0;
+        *dst++ = (ic2 >= 0) ? *(src + ic2) : 0;
+        *dst++ = (ic3 >= 0) ? *(src + ic3) : 0;
+        src += n_ic;
+    }
+}
+
+static void remap_arrange_stereo_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
+    const unsigned n_ic = m->i_ss.channels;
+    const int8_t *arrange = m->state;
+    const int ic0 = arrange[0], ic1 = arrange[1];
+
+    for (; n > 0; n--) {
+        *dst++ = (ic0 >= 0) ? *(src + ic0) : 0.0f;
+        *dst++ = (ic1 >= 0) ? *(src + ic1) : 0.0f;
+        src += n_ic;
+    }
+}
+
+static void remap_arrange_ch4_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
+    const unsigned n_ic = m->i_ss.channels;
+    const int8_t *arrange = m->state;
+    const int ic0 = arrange[0], ic1 = arrange[1],
+        ic2 = arrange[2], ic3 = arrange[3];
+
+    for (; n > 0; n--) {
+        *dst++ = (ic0 >= 0) ? *(src + ic0) : 0.0f;
+        *dst++ = (ic1 >= 0) ? *(src + ic1) : 0.0f;
+        *dst++ = (ic2 >= 0) ? *(src + ic2) : 0.0f;
+        *dst++ = (ic3 >= 0) ? *(src + ic3) : 0.0f;
+        src += n_ic;
+    }
+}
+
 void pa_set_remap_func(pa_remap_t *m, pa_do_remap_func_t func_s16,
     pa_do_remap_func_t func_float) {
 
@@ -174,6 +229,7 @@ void pa_set_remap_func(pa_remap_t *m, pa_do_remap_func_t func_s16,
 /* set the function that will execute the remapping based on the matrices */
 static void init_remap_c(pa_remap_t *m) {
     unsigned n_oc, n_ic;
+    int8_t arrange[PA_CHANNELS_MAX];
 
     n_oc = m->o_ss.channels;
     n_ic = m->i_ss.channels;
@@ -185,9 +241,25 @@ static void init_remap_c(pa_remap_t *m) {
         pa_log_info("Using mono to stereo remapping");
         pa_set_remap_func(m, (pa_do_remap_func_t) remap_mono_to_stereo_s16ne_c,
             (pa_do_remap_func_t) remap_mono_to_stereo_float32ne_c);
+    } else if (pa_setup_remap_arrange(m, arrange) && n_oc == 2) {
+
+        pa_log_info("Using stereo arrange remapping");
+        pa_set_remap_func(m, (pa_do_remap_func_t) remap_arrange_stereo_s16ne_c,
+            (pa_do_remap_func_t) remap_arrange_stereo_float32ne_c);
+
+        /* setup state */
+        m->state = pa_xnewdup(int8_t, arrange, PA_CHANNELS_MAX);
+    } else if (pa_setup_remap_arrange(m, arrange) && n_oc == 4) {
+
+        pa_log_info("Using 4-channel arrange remapping");
+        pa_set_remap_func(m, (pa_do_remap_func_t) remap_arrange_ch4_s16ne_c,
+            (pa_do_remap_func_t) remap_arrange_ch4_float32ne_c);
+
+        /* setup state */
+        m->state = pa_xnewdup(int8_t, arrange, PA_CHANNELS_MAX);
     } else {
-        pa_log_info("Using generic matrix remapping");
 
+        pa_log_info("Using generic matrix remapping");
         pa_set_remap_func(m, (pa_do_remap_func_t) remap_channels_matrix_s16ne_c,
             (pa_do_remap_func_t) remap_channels_matrix_float32ne_c);
     }