remap: Change remapping function argument type from void to int16_t / float as approp...
[pulseaudio] / src / pulsecore / remap.c
1 /***
2 This file is part of PulseAudio.
3
4 Copyright 2004-2006 Lennart Poettering
5 Copyright 2009 Wim Taymans <wim.taymans@collabora.co.uk.com>
6
7 PulseAudio is free software; you can redistribute it and/or modify
8 it under the terms of the GNU Lesser General Public License as published
9 by the Free Software Foundation; either version 2.1 of the License,
10 or (at your option) any later version.
11
12 PulseAudio is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public License
18 along with PulseAudio; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20 USA.
21 ***/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26
27 #include <string.h>
28
29 #include <pulse/sample.h>
30 #include <pulse/volume.h>
31 #include <pulsecore/log.h>
32 #include <pulsecore/macro.h>
33
34 #include "remap.h"
35
36 static void remap_mono_to_stereo_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
37 unsigned i;
38
39 for (i = n >> 2; i; i--) {
40 dst[0] = dst[1] = src[0];
41 dst[2] = dst[3] = src[1];
42 dst[4] = dst[5] = src[2];
43 dst[6] = dst[7] = src[3];
44 src += 4;
45 dst += 8;
46 }
47 for (i = n & 3; i; i--) {
48 dst[0] = dst[1] = src[0];
49 src++;
50 dst += 2;
51 }
52 }
53
54 static void remap_mono_to_stereo_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
55 unsigned i;
56
57 for (i = n >> 2; i; i--) {
58 dst[0] = dst[1] = src[0];
59 dst[2] = dst[3] = src[1];
60 dst[4] = dst[5] = src[2];
61 dst[6] = dst[7] = src[3];
62 src += 4;
63 dst += 8;
64 }
65 for (i = n & 3; i; i--) {
66 dst[0] = dst[1] = src[0];
67 src++;
68 dst += 2;
69 }
70 }
71
72 static void remap_channels_matrix_s16ne_c(pa_remap_t *m, int16_t *dst, const int16_t *src, unsigned n) {
73 unsigned oc, ic, i;
74 unsigned n_ic, n_oc;
75
76 n_ic = m->i_ss.channels;
77 n_oc = m->o_ss.channels;
78
79 memset(dst, 0, n * sizeof(int16_t) * n_oc);
80
81 for (oc = 0; oc < n_oc; oc++) {
82
83 for (ic = 0; ic < n_ic; ic++) {
84 int16_t *d = dst + oc;
85 const int16_t *s = src + ic;
86 int32_t vol = m->map_table_i[oc][ic];
87
88 if (vol <= 0)
89 continue;
90
91 if (vol >= 0x10000) {
92 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
93 *d += *s;
94 } else {
95 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
96 *d += (int16_t) (((int32_t)*s * vol) >> 16);
97 }
98 }
99 }
100 }
101
102 static void remap_channels_matrix_float32ne_c(pa_remap_t *m, float *dst, const float *src, unsigned n) {
103 unsigned oc, ic, i;
104 unsigned n_ic, n_oc;
105
106 n_ic = m->i_ss.channels;
107 n_oc = m->o_ss.channels;
108
109 memset(dst, 0, n * sizeof(float) * n_oc);
110
111 for (oc = 0; oc < n_oc; oc++) {
112
113 for (ic = 0; ic < n_ic; ic++) {
114 float *d = dst + oc;
115 const float *s = src + ic;
116 float vol = m->map_table_f[oc][ic];
117
118 if (vol <= 0.0f)
119 continue;
120
121 if (vol >= 1.0f) {
122 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
123 *d += *s;
124 } else {
125 for (i = n; i > 0; i--, s += n_ic, d += n_oc)
126 *d += *s * vol;
127 }
128 }
129 }
130 }
131
132 bool pa_setup_remap_arrange(const pa_remap_t *m, int8_t arrange[PA_CHANNELS_MAX]) {
133 unsigned ic, oc;
134 unsigned n_ic, n_oc;
135
136 pa_assert(m);
137
138 n_ic = m->i_ss.channels;
139 n_oc = m->o_ss.channels;
140
141 for (oc = 0; oc < n_oc; oc++) {
142 arrange[oc] = -1;
143 for (ic = 0; ic < n_ic; ic++) {
144 int32_t vol = m->map_table_i[oc][ic];
145
146 /* input channel is not used */
147 if (vol == 0)
148 continue;
149
150 /* if mixing this channel, we cannot just rearrange */
151 if (vol != 0x10000 || arrange[oc] >= 0)
152 return false;
153
154 arrange[oc] = ic;
155 }
156 }
157
158 return true;
159 }
160
161 void pa_set_remap_func(pa_remap_t *m, pa_do_remap_func_t func_s16,
162 pa_do_remap_func_t func_float) {
163
164 pa_assert(m);
165
166 if (m->format == PA_SAMPLE_S16NE)
167 m->do_remap = func_s16;
168 else if (m->format == PA_SAMPLE_FLOAT32NE)
169 m->do_remap = func_float;
170 else
171 pa_assert_not_reached();
172 }
173
174 /* set the function that will execute the remapping based on the matrices */
175 static void init_remap_c(pa_remap_t *m) {
176 unsigned n_oc, n_ic;
177
178 n_oc = m->o_ss.channels;
179 n_ic = m->i_ss.channels;
180
181 /* find some common channel remappings, fall back to full matrix operation. */
182 if (n_ic == 1 && n_oc == 2 &&
183 m->map_table_i[0][0] == 0x10000 && m->map_table_i[1][0] == 0x10000) {
184
185 pa_log_info("Using mono to stereo remapping");
186 pa_set_remap_func(m, (pa_do_remap_func_t) remap_mono_to_stereo_s16ne_c,
187 (pa_do_remap_func_t) remap_mono_to_stereo_float32ne_c);
188 } else {
189 pa_log_info("Using generic matrix remapping");
190
191 pa_set_remap_func(m, (pa_do_remap_func_t) remap_channels_matrix_s16ne_c,
192 (pa_do_remap_func_t) remap_channels_matrix_float32ne_c);
193 }
194 }
195
196 /* default C implementation */
197 static pa_init_remap_func_t init_remap_func = init_remap_c;
198
199 void pa_init_remap_func(pa_remap_t *m) {
200 pa_assert(init_remap_func);
201
202 m->do_remap = NULL;
203
204 /* call the installed remap init function */
205 init_remap_func(m);
206
207 if (m->do_remap == NULL) {
208 /* nothing was installed, fallback to C version */
209 init_remap_c(m);
210 }
211 }
212
213 pa_init_remap_func_t pa_get_init_remap_func(void) {
214 return init_remap_func;
215 }
216
217 void pa_set_init_remap_func(pa_init_remap_func_t func) {
218 init_remap_func = func;
219 }