mirror of
https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git
synced 2025-11-05 13:29:57 -05:00
5effc83479
FSF addresses used in PA sources are no longer valid and rpmlint generates numerous warnings during packaging because of this. This patch changes all FSF addresses to FSF web page according to the GPL how-to: https://www.gnu.org/licenses/gpl-howto.en.html Done automatically by sed-ing through sources.
466 lines
14 KiB
C
466 lines
14 KiB
C
/***
|
|
This file is part of PulseAudio.
|
|
|
|
Copyright 2004-2006 Lennart Poettering
|
|
Copyright 2009 Wim Taymans <wim.taymans@collabora.co.uk.com>
|
|
|
|
PulseAudio is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU Lesser General Public License as published
|
|
by the Free Software Foundation; either version 2.1 of the License,
|
|
or (at your option) any later version.
|
|
|
|
PulseAudio is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with PulseAudio; if not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include <pulse/xmalloc.h>
|
|
#include <pulse/sample.h>
|
|
#include <pulse/volume.h>
|
|
#include <pulsecore/log.h>
|
|
#include <pulsecore/macro.h>
|
|
|
|
#include "cpu.h"
|
|
#include "remap.h"
|
|
|
|
static void remap_mono_to_stereo_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i; i--) {
|
|
dst[0] = dst[1] = src[0];
|
|
dst[2] = dst[3] = src[1];
|
|
dst[4] = dst[5] = src[2];
|
|
dst[6] = dst[7] = src[3];
|
|
src += 4;
|
|
dst += 8;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = dst[1] = src[0];
|
|
src++;
|
|
dst += 2;
|
|
}
|
|
}
|
|
|
|
static void remap_mono_to_stereo_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i; i--) {
|
|
dst[0] = dst[1] = src[0];
|
|
dst[2] = dst[3] = src[1];
|
|
dst[4] = dst[5] = src[2];
|
|
dst[6] = dst[7] = src[3];
|
|
src += 4;
|
|
dst += 8;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = dst[1] = src[0];
|
|
src++;
|
|
dst += 2;
|
|
}
|
|
}
|
|
|
|
static void remap_stereo_to_mono_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i > 0; i--) {
|
|
dst[0] = (src[0] + src[1])/2;
|
|
dst[1] = (src[2] + src[3])/2;
|
|
dst[2] = (src[4] + src[5])/2;
|
|
dst[3] = (src[6] + src[7])/2;
|
|
src += 8;
|
|
dst += 4;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = (src[0] + src[1])/2;
|
|
src += 2;
|
|
dst += 1;
|
|
}
|
|
}
|
|
|
|
static void remap_stereo_to_mono_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i > 0; i--) {
|
|
dst[0] = (src[0] + src[1])*0.5f;
|
|
dst[1] = (src[2] + src[3])*0.5f;
|
|
dst[2] = (src[4] + src[5])*0.5f;
|
|
dst[3] = (src[6] + src[7])*0.5f;
|
|
src += 8;
|
|
dst += 4;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = (src[0] + src[1])*0.5f;
|
|
src += 2;
|
|
dst += 1;
|
|
}
|
|
}
|
|
|
|
static void remap_mono_to_ch4_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i; i--) {
|
|
dst[0] = dst[1] = dst[2] = dst[3] = src[0];
|
|
dst[4] = dst[5] = dst[6] = dst[7] = src[1];
|
|
dst[8] = dst[9] = dst[10] = dst[11] = src[2];
|
|
dst[12] = dst[13] = dst[14] = dst[15] = src[3];
|
|
src += 4;
|
|
dst += 16;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = dst[1] = dst[2] = dst[3] = src[0];
|
|
src++;
|
|
dst += 4;
|
|
}
|
|
}
|
|
|
|
static void remap_mono_to_ch4_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i; i--) {
|
|
dst[0] = dst[1] = dst[2] = dst[3] = src[0];
|
|
dst[4] = dst[5] = dst[6] = dst[7] = src[1];
|
|
dst[8] = dst[9] = dst[10] = dst[11] = src[2];
|
|
dst[12] = dst[13] = dst[14] = dst[15] = src[3];
|
|
src += 4;
|
|
dst += 16;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = dst[1] = dst[2] = dst[3] = src[0];
|
|
src++;
|
|
dst += 4;
|
|
}
|
|
}
|
|
|
|
static void remap_ch4_to_mono_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i > 0; i--) {
|
|
dst[0] = (src[0] + src[1] + src[2] + src[3])/4;
|
|
dst[1] = (src[4] + src[5] + src[6] + src[7])/4;
|
|
dst[2] = (src[8] + src[9] + src[10] + src[11])/4;
|
|
dst[3] = (src[12] + src[13] + src[14] + src[15])/4;
|
|
src += 16;
|
|
dst += 4;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = (src[0] + src[1] + src[2] + src[3])/4;
|
|
src += 4;
|
|
dst += 1;
|
|
}
|
|
}
|
|
|
|
static void remap_ch4_to_mono_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
|
|
unsigned i;
|
|
|
|
for (i = n >> 2; i > 0; i--) {
|
|
dst[0] = (src[0] + src[1] + src[2] + src[3])*0.25f;
|
|
dst[1] = (src[4] + src[5] + src[6] + src[7])*0.25f;
|
|
dst[2] = (src[8] + src[9] + src[10] + src[11])*0.25f;
|
|
dst[3] = (src[12] + src[13] + src[14] + src[15])*0.25f;
|
|
src += 16;
|
|
dst += 4;
|
|
}
|
|
for (i = n & 3; i; i--) {
|
|
dst[0] = (src[0] + src[1] + src[2] + src[3])*0.25f;
|
|
src += 4;
|
|
dst += 1;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
n_ic = m->i_ss.channels;
|
|
n_oc = m->o_ss.channels;
|
|
|
|
memset(dst, 0, n * sizeof(int16_t) * n_oc);
|
|
|
|
for (oc = 0; oc < n_oc; oc++) {
|
|
|
|
for (ic = 0; ic < n_ic; 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;
|
|
|
|
if (vol >= 0x10000) {
|
|
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
|
|
*d += *s;
|
|
} else {
|
|
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
|
|
*d += (int16_t) (((int32_t)*s * vol) >> 16);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
n_ic = m->i_ss.channels;
|
|
n_oc = m->o_ss.channels;
|
|
|
|
memset(dst, 0, n * sizeof(float) * n_oc);
|
|
|
|
for (oc = 0; oc < n_oc; oc++) {
|
|
|
|
for (ic = 0; ic < n_ic; ic++) {
|
|
float *d = dst + oc;
|
|
const float *s = src + ic;
|
|
float vol = m->map_table_f[oc][ic];
|
|
|
|
if (vol <= 0.0f)
|
|
continue;
|
|
|
|
if (vol >= 1.0f) {
|
|
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
|
|
*d += *s;
|
|
} else {
|
|
for (i = n; i > 0; i--, s += n_ic, d += n_oc)
|
|
*d += *s * vol;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Produce an array containing input channel indices to map to output channels.
|
|
* If the output channel is empty, the array element is -1. */
|
|
bool pa_setup_remap_arrange(const pa_remap_t *m, int8_t arrange[PA_CHANNELS_MAX]) {
|
|
unsigned ic, oc;
|
|
unsigned n_ic, n_oc;
|
|
unsigned count_output = 0;
|
|
|
|
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;
|
|
count_output++;
|
|
}
|
|
}
|
|
|
|
return count_output > 0;
|
|
}
|
|
|
|
static void remap_arrange_mono_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;
|
|
|
|
src += arrange[0];
|
|
for (; n > 0; n--) {
|
|
*dst++ = *src;
|
|
src += n_ic;
|
|
}
|
|
}
|
|
|
|
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_mono_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;
|
|
|
|
src += arrange[0];
|
|
for (; n > 0; n--) {
|
|
*dst++ = *src;
|
|
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();
|
|
}
|
|
|
|
static bool force_generic_code = false;
|
|
|
|
/* 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;
|
|
|
|
/* find some common channel remappings, fall back to full matrix operation. */
|
|
if (force_generic_code) {
|
|
pa_log_info("Forced to use 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);
|
|
return;
|
|
}
|
|
|
|
if (n_ic == 1 && n_oc == 2 &&
|
|
m->map_table_i[0][0] == 0x10000 && m->map_table_i[1][0] == 0x10000) {
|
|
|
|
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 (n_ic == 2 && n_oc == 1 &&
|
|
m->map_table_i[0][0] == 0x8000 && m->map_table_i[0][1] == 0x8000) {
|
|
|
|
pa_log_info("Using stereo to mono remapping");
|
|
pa_set_remap_func(m, (pa_do_remap_func_t) remap_stereo_to_mono_s16ne_c,
|
|
(pa_do_remap_func_t) remap_stereo_to_mono_float32ne_c);
|
|
} else if (n_ic == 1 && n_oc == 4 &&
|
|
m->map_table_i[0][0] == 0x10000 && m->map_table_i[1][0] == 0x10000 &&
|
|
m->map_table_i[2][0] == 0x10000 && m->map_table_i[3][0] == 0x10000) {
|
|
|
|
pa_log_info("Using mono to 4-channel remapping");
|
|
pa_set_remap_func(m, (pa_do_remap_func_t)remap_mono_to_ch4_s16ne_c,
|
|
(pa_do_remap_func_t) remap_mono_to_ch4_float32ne_c);
|
|
} else if (n_ic == 4 && n_oc == 1 &&
|
|
m->map_table_i[0][0] == 0x4000 && m->map_table_i[0][1] == 0x4000 &&
|
|
m->map_table_i[0][2] == 0x4000 && m->map_table_i[0][3] == 0x4000) {
|
|
|
|
pa_log_info("Using 4-channel to mono remapping");
|
|
pa_set_remap_func(m, (pa_do_remap_func_t) remap_ch4_to_mono_s16ne_c,
|
|
(pa_do_remap_func_t) remap_ch4_to_mono_float32ne_c);
|
|
} else if (pa_setup_remap_arrange(m, arrange) && n_oc == 1) {
|
|
|
|
pa_log_info("Using mono arrange remapping");
|
|
pa_set_remap_func(m, (pa_do_remap_func_t) remap_arrange_mono_s16ne_c,
|
|
(pa_do_remap_func_t) remap_arrange_mono_float32ne_c);
|
|
|
|
/* setup state */
|
|
m->state = pa_xnewdup(int8_t, arrange, PA_CHANNELS_MAX);
|
|
} 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_set_remap_func(m, (pa_do_remap_func_t) remap_channels_matrix_s16ne_c,
|
|
(pa_do_remap_func_t) remap_channels_matrix_float32ne_c);
|
|
}
|
|
}
|
|
|
|
/* default C implementation */
|
|
static pa_init_remap_func_t init_remap_func = init_remap_c;
|
|
|
|
void pa_init_remap_func(pa_remap_t *m) {
|
|
pa_assert(init_remap_func);
|
|
|
|
m->do_remap = NULL;
|
|
|
|
/* call the installed remap init function */
|
|
init_remap_func(m);
|
|
|
|
if (m->do_remap == NULL) {
|
|
/* nothing was installed, fallback to C version */
|
|
init_remap_c(m);
|
|
}
|
|
}
|
|
|
|
pa_init_remap_func_t pa_get_init_remap_func(void) {
|
|
return init_remap_func;
|
|
}
|
|
|
|
void pa_set_init_remap_func(pa_init_remap_func_t func) {
|
|
init_remap_func = func;
|
|
}
|
|
|
|
void pa_remap_func_init(const pa_cpu_info *cpu_info) {
|
|
force_generic_code = cpu_info->force_generic_code;
|
|
}
|