1 /*-
2 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 /* feeder_volume, a long 'Lost Technology' rather than a new feature. */
28
29 #ifdef _KERNEL
30 #ifdef HAVE_KERNEL_OPTION_HEADERS
31 #include "opt_snd.h"
32 #endif
33 #include <dev/sound/pcm/sound.h>
34 #include <dev/sound/pcm/pcm.h>
35 #include "feeder_if.h"
36
37 #define SND_USE_FXDIV
38 #include "snd_fxdiv_gen.h"
39
40 SND_DECLARE_FILE("$FreeBSD: releng/9.0/sys/dev/sound/pcm/feeder_volume.c 193640 2009-06-07 19:12:08Z ariff $");
41 #endif
42
43 typedef void (*feed_volume_t)(int *, int *, uint32_t, uint8_t *, uint32_t);
44
45 #define FEEDVOLUME_CALC8(s, v) (SND_VOL_CALC_SAMPLE((intpcm_t) \
46 (s) << 8, v) >> 8)
47 #define FEEDVOLUME_CALC16(s, v) SND_VOL_CALC_SAMPLE((intpcm_t)(s), v)
48 #define FEEDVOLUME_CALC24(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v)
49 #define FEEDVOLUME_CALC32(s, v) SND_VOL_CALC_SAMPLE((intpcm64_t)(s), v)
50
51 #define FEEDVOLUME_DECLARE(SIGN, BIT, ENDIAN) \
52 static void \
53 feed_volume_##SIGN##BIT##ENDIAN(int *vol, int *matrix, \
54 uint32_t channels, uint8_t *dst, uint32_t count) \
55 { \
56 intpcm##BIT##_t v; \
57 intpcm_t x; \
58 uint32_t i; \
59 \
60 dst += count * PCM_##BIT##_BPS * channels; \
61 do { \
62 i = channels; \
63 do { \
64 dst -= PCM_##BIT##_BPS; \
65 i--; \
66 x = PCM_READ_##SIGN##BIT##_##ENDIAN(dst); \
67 v = FEEDVOLUME_CALC##BIT(x, vol[matrix[i]]); \
68 x = PCM_CLAMP_##SIGN##BIT(v); \
69 _PCM_WRITE_##SIGN##BIT##_##ENDIAN(dst, x); \
70 } while (i != 0); \
71 } while (--count != 0); \
72 }
73
74 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
75 FEEDVOLUME_DECLARE(S, 16, LE)
76 FEEDVOLUME_DECLARE(S, 32, LE)
77 #endif
78 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
79 FEEDVOLUME_DECLARE(S, 16, BE)
80 FEEDVOLUME_DECLARE(S, 32, BE)
81 #endif
82 #ifdef SND_FEEDER_MULTIFORMAT
83 FEEDVOLUME_DECLARE(S, 8, NE)
84 FEEDVOLUME_DECLARE(S, 24, LE)
85 FEEDVOLUME_DECLARE(S, 24, BE)
86 FEEDVOLUME_DECLARE(U, 8, NE)
87 FEEDVOLUME_DECLARE(U, 16, LE)
88 FEEDVOLUME_DECLARE(U, 24, LE)
89 FEEDVOLUME_DECLARE(U, 32, LE)
90 FEEDVOLUME_DECLARE(U, 16, BE)
91 FEEDVOLUME_DECLARE(U, 24, BE)
92 FEEDVOLUME_DECLARE(U, 32, BE)
93 #endif
94
95 struct feed_volume_info {
96 uint32_t bps, channels;
97 feed_volume_t apply;
98 int volume_class;
99 int state;
100 int matrix[SND_CHN_MAX];
101 };
102
103 #define FEEDVOLUME_ENTRY(SIGN, BIT, ENDIAN) \
104 { \
105 AFMT_##SIGN##BIT##_##ENDIAN, \
106 feed_volume_##SIGN##BIT##ENDIAN \
107 }
108
109 static const struct {
110 uint32_t format;
111 feed_volume_t apply;
112 } feed_volume_info_tab[] = {
113 #if BYTE_ORDER == LITTLE_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
114 FEEDVOLUME_ENTRY(S, 16, LE),
115 FEEDVOLUME_ENTRY(S, 32, LE),
116 #endif
117 #if BYTE_ORDER == BIG_ENDIAN || defined(SND_FEEDER_MULTIFORMAT)
118 FEEDVOLUME_ENTRY(S, 16, BE),
119 FEEDVOLUME_ENTRY(S, 32, BE),
120 #endif
121 #ifdef SND_FEEDER_MULTIFORMAT
122 FEEDVOLUME_ENTRY(S, 8, NE),
123 FEEDVOLUME_ENTRY(S, 24, LE),
124 FEEDVOLUME_ENTRY(S, 24, BE),
125 FEEDVOLUME_ENTRY(U, 8, NE),
126 FEEDVOLUME_ENTRY(U, 16, LE),
127 FEEDVOLUME_ENTRY(U, 24, LE),
128 FEEDVOLUME_ENTRY(U, 32, LE),
129 FEEDVOLUME_ENTRY(U, 16, BE),
130 FEEDVOLUME_ENTRY(U, 24, BE),
131 FEEDVOLUME_ENTRY(U, 32, BE)
132 #endif
133 };
134
135 #define FEEDVOLUME_TAB_SIZE ((int32_t) \
136 (sizeof(feed_volume_info_tab) / \
137 sizeof(feed_volume_info_tab[0])))
138
139 static int
140 feed_volume_init(struct pcm_feeder *f)
141 {
142 struct feed_volume_info *info;
143 struct pcmchan_matrix *m;
144 uint32_t i;
145 int ret;
146
147 if (f->desc->in != f->desc->out ||
148 AFMT_CHANNEL(f->desc->in) > SND_CHN_MAX)
149 return (EINVAL);
150
151 for (i = 0; i < FEEDVOLUME_TAB_SIZE; i++) {
152 if (AFMT_ENCODING(f->desc->in) ==
153 feed_volume_info_tab[i].format) {
154 info = malloc(sizeof(*info), M_DEVBUF,
155 M_NOWAIT | M_ZERO);
156 if (info == NULL)
157 return (ENOMEM);
158
159 info->bps = AFMT_BPS(f->desc->in);
160 info->channels = AFMT_CHANNEL(f->desc->in);
161 info->apply = feed_volume_info_tab[i].apply;
162 info->volume_class = SND_VOL_C_PCM;
163 info->state = FEEDVOLUME_ENABLE;
164
165 f->data = info;
166 m = feeder_matrix_default_channel_map(info->channels);
167 if (m == NULL) {
168 free(info, M_DEVBUF);
169 return (EINVAL);
170 }
171
172 ret = feeder_volume_apply_matrix(f, m);
173 if (ret != 0)
174 free(info, M_DEVBUF);
175
176 return (ret);
177 }
178 }
179
180 return (EINVAL);
181 }
182
183 static int
184 feed_volume_free(struct pcm_feeder *f)
185 {
186 struct feed_volume_info *info;
187
188 info = f->data;
189 if (info != NULL)
190 free(info, M_DEVBUF);
191
192 f->data = NULL;
193
194 return (0);
195 }
196
197 static int
198 feed_volume_set(struct pcm_feeder *f, int what, int value)
199 {
200 struct feed_volume_info *info;
201 struct pcmchan_matrix *m;
202 int ret;
203
204 info = f->data;
205 ret = 0;
206
207 switch (what) {
208 case FEEDVOLUME_CLASS:
209 if (value < SND_VOL_C_BEGIN || value > SND_VOL_C_END)
210 return (EINVAL);
211 info->volume_class = value;
212 break;
213 case FEEDVOLUME_CHANNELS:
214 if (value < SND_CHN_MIN || value > SND_CHN_MAX)
215 return (EINVAL);
216 m = feeder_matrix_default_channel_map(value);
217 if (m == NULL)
218 return (EINVAL);
219 ret = feeder_volume_apply_matrix(f, m);
220 break;
221 case FEEDVOLUME_STATE:
222 if (!(value == FEEDVOLUME_ENABLE || value == FEEDVOLUME_BYPASS))
223 return (EINVAL);
224 info->state = value;
225 break;
226 default:
227 return (EINVAL);
228 break;
229 }
230
231 return (ret);
232 }
233
234 static int
235 feed_volume_feed(struct pcm_feeder *f, struct pcm_channel *c, uint8_t *b,
236 uint32_t count, void *source)
237 {
238 struct feed_volume_info *info;
239 uint32_t j, align;
240 int i, *vol, *matrix;
241 uint8_t *dst;
242
243 /*
244 * Fetch filter data operation.
245 */
246 info = f->data;
247
248 if (info->state == FEEDVOLUME_BYPASS)
249 return (FEEDER_FEED(f->source, c, b, count, source));
250
251 vol = c->volume[SND_VOL_C_VAL(info->volume_class)];
252 matrix = info->matrix;
253
254 /*
255 * First, let see if we really need to apply gain at all.
256 */
257 j = 0;
258 i = info->channels;
259 do {
260 if (vol[matrix[--i]] != SND_VOL_FLAT) {
261 j = 1;
262 break;
263 }
264 } while (i != 0);
265
266 /* Nope, just bypass entirely. */
267 if (j == 0)
268 return (FEEDER_FEED(f->source, c, b, count, source));
269
270 dst = b;
271 align = info->bps * info->channels;
272
273 do {
274 if (count < align)
275 break;
276
277 j = SND_FXDIV(FEEDER_FEED(f->source, c, dst, count, source),
278 align);
279 if (j == 0)
280 break;
281
282 info->apply(vol, matrix, info->channels, dst, j);
283
284 j *= align;
285 dst += j;
286 count -= j;
287
288 } while (count != 0);
289
290 return (dst - b);
291 }
292
293 static struct pcm_feederdesc feeder_volume_desc[] = {
294 { FEEDER_VOLUME, 0, 0, 0, 0 },
295 { 0, 0, 0, 0, 0 }
296 };
297
298 static kobj_method_t feeder_volume_methods[] = {
299 KOBJMETHOD(feeder_init, feed_volume_init),
300 KOBJMETHOD(feeder_free, feed_volume_free),
301 KOBJMETHOD(feeder_set, feed_volume_set),
302 KOBJMETHOD(feeder_feed, feed_volume_feed),
303 KOBJMETHOD_END
304 };
305
306 FEEDER_DECLARE(feeder_volume, NULL);
307
308 /* Extern */
309
310 /*
311 * feeder_volume_apply_matrix(): For given matrix map, apply its configuration
312 * to feeder_volume matrix structure. There are
313 * possibilites that feeder_volume be inserted
314 * before or after feeder_matrix, which in this
315 * case feeder_volume must be in a good terms
316 * with _current_ matrix.
317 */
318 int
319 feeder_volume_apply_matrix(struct pcm_feeder *f, struct pcmchan_matrix *m)
320 {
321 struct feed_volume_info *info;
322 uint32_t i;
323
324 if (f == NULL || f->desc == NULL || f->desc->type != FEEDER_VOLUME ||
325 f->data == NULL || m == NULL || m->channels < SND_CHN_MIN ||
326 m->channels > SND_CHN_MAX)
327 return (EINVAL);
328
329 info = f->data;
330
331 for (i = 0; i < (sizeof(info->matrix) / sizeof(info->matrix[0])); i++) {
332 if (i < m->channels)
333 info->matrix[i] = m->map[i].type;
334 else
335 info->matrix[i] = SND_CHN_T_FL;
336 }
337
338 info->channels = m->channels;
339
340 return (0);
341 }
Cache object: 404fb7fa2c324c02cf743a84b13e6886
|