#include <string.h>
+#include <pulse/xmalloc.h>
#include <pulse/sample.h>
#include <pulse/volume.h>
#include <pulsecore/log.h>
}
}
-static void remap_channels_matrix_s16ne_c(pa_remap_t *m, void *dst, const void *src, unsigned n) {
+static void remap_channels_matrix_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
unsigned oc, ic, i;
unsigned n_ic, n_oc;
for (oc = 0; oc < n_oc; oc++) {
for (ic = 0; ic < n_ic; ic++) {
- int16_t *d, *s;
- int32_t vol;
-
- vol = m->map_table_i[oc][ic];
+ int16_t *d = dst + oc;
+ const int16_t *s = src + ic;
+ int32_t vol = m->map_table_i[oc][ic];
if (vol <= 0)
continue;
- d = (int16_t *)dst + oc;
- s = (int16_t *)src + ic;
-
if (vol >= 0x10000) {
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
*d += *s;
}
}
-static void remap_channels_matrix_float32ne_c(pa_remap_t *m, void *dst, const void *src, unsigned n) {
+static void remap_channels_matrix_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
unsigned oc, ic, i;
unsigned n_ic, n_oc;
for (oc = 0; oc < n_oc; oc++) {
for (ic = 0; ic < n_ic; ic++) {
- float *d, *s;
- float vol;
-
- vol = m->map_table_f[oc][ic];
+ float *d = dst + oc;
+ const float *s = src + ic;
+ float vol = m->map_table_f[oc][ic];
- if (vol <= 0.0)
+ if (vol <= 0.0f)
continue;
- d = (float *)dst + oc;
- s = (float *)src + ic;
-
- if (vol >= 1.0) {
+ if (vol >= 1.0f) {
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
*d += *s;
} else {
}
}
+bool pa_setup_remap_arrange(const pa_remap_t *m, int8_t arrange[PA_CHANNELS_MAX]) {
+ unsigned ic, oc;
+ unsigned n_ic, n_oc;
+
+ pa_assert(m);
+
+ n_ic = m->i_ss.channels;
+ n_oc = m->o_ss.channels;
+
+ for (oc = 0; oc < n_oc; oc++) {
+ arrange[oc] = -1;
+ for (ic = 0; ic < n_ic; ic++) {
+ int32_t vol = m->map_table_i[oc][ic];
+
+ /* input channel is not used */
+ if (vol == 0)
+ continue;
+
+ /* if mixing this channel, we cannot just rearrange */
+ if (vol != 0x10000 || arrange[oc] >= 0)
+ return false;
+
+ arrange[oc] = ic;
+ }
+ }
+
+ 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) {
+
+ pa_assert(m);
+
+ if (m->format == PA_SAMPLE_S16NE)
+ m->do_remap = func_s16;
+ else if (m->format == PA_SAMPLE_FLOAT32NE)
+ m->do_remap = func_float;
+ else
+ pa_assert_not_reached();
+}
+
/* 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;
m->map_table_i[0][0] == 0x10000 && m->map_table_i[1][0] == 0x10000) {
pa_log_info("Using mono to stereo remapping");
- switch (m->format) {
- case PA_SAMPLE_S16NE:
- m->do_remap = (pa_do_remap_func_t) remap_mono_to_stereo_s16ne_c;
- break;
- case PA_SAMPLE_FLOAT32NE:
- m->do_remap = (pa_do_remap_func_t) remap_mono_to_stereo_float32ne_c;
- break;
- default:
- pa_assert_not_reached();
- }
+ 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");
- switch (m->format) {
- case PA_SAMPLE_S16NE:
- m->do_remap = (pa_do_remap_func_t) remap_channels_matrix_s16ne_c;
- break;
- case PA_SAMPLE_FLOAT32NE:
- m->do_remap = (pa_do_remap_func_t) remap_channels_matrix_float32ne_c;
- break;
- default:
- pa_assert_not_reached();
- }
+ 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);
}
}