1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2008-2009 Ariff Abdullah <ariff@FreeBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 #ifdef HAVE_KERNEL_OPTION_HEADERS
30 #include "opt_snd.h"
31 #endif
32
33 #include <dev/sound/pcm/sound.h>
34
35 #include "feeder_if.h"
36
37 /* chain state */
38 struct feeder_chain_state {
39 uint32_t afmt; /* audio format */
40 uint32_t rate; /* sampling rate */
41 struct pcmchan_matrix *matrix; /* matrix map */
42 };
43
44 /*
45 * chain descriptor that will be passed around from the beginning until the
46 * end of chain process.
47 */
48 struct feeder_chain_desc {
49 struct feeder_chain_state origin; /* original state */
50 struct feeder_chain_state current; /* current state */
51 struct feeder_chain_state target; /* target state */
52 struct pcm_feederdesc desc; /* feeder descriptor */
53 uint32_t afmt_ne; /* preferred native endian */
54 int mode; /* chain mode */
55 int use_eq; /* need EQ? */
56 int use_matrix; /* need channel matrixing? */
57 int use_volume; /* need softpcmvol? */
58 int dummy; /* dummy passthrough */
59 int expensive; /* possibly expensive */
60 };
61
62 #define FEEDER_CHAIN_LEAN 0
63 #define FEEDER_CHAIN_16 1
64 #define FEEDER_CHAIN_32 2
65 #define FEEDER_CHAIN_MULTI 3
66 #define FEEDER_CHAIN_FULLMULTI 4
67 #define FEEDER_CHAIN_LAST 5
68
69 #if defined(SND_FEEDER_FULL_MULTIFORMAT)
70 #define FEEDER_CHAIN_DEFAULT FEEDER_CHAIN_FULLMULTI
71 #elif defined(SND_FEEDER_MULTIFORMAT)
72 #define FEEDER_CHAIN_DEFAULT FEEDER_CHAIN_MULTI
73 #else
74 #define FEEDER_CHAIN_DEFAULT FEEDER_CHAIN_LEAN
75 #endif
76
77 /*
78 * List of preferred formats that might be required during
79 * processing. It will be decided through snd_fmtbest().
80 */
81
82 /* 'Lean' mode, signed 16 or 32 bit native endian. */
83 static uint32_t feeder_chain_formats_lean[] = {
84 AFMT_S16_NE, AFMT_S32_NE,
85 0
86 };
87
88 /* Force everything to signed 16 bit native endian. */
89 static uint32_t feeder_chain_formats_16[] = {
90 AFMT_S16_NE,
91 0
92 };
93
94 /* Force everything to signed 32 bit native endian. */
95 static uint32_t feeder_chain_formats_32[] = {
96 AFMT_S32_NE,
97 0
98 };
99
100 /* Multiple choices, all except 8 bit. */
101 static uint32_t feeder_chain_formats_multi[] = {
102 AFMT_S16_LE, AFMT_S16_BE, AFMT_U16_LE, AFMT_U16_BE,
103 AFMT_S24_LE, AFMT_S24_BE, AFMT_U24_LE, AFMT_U24_BE,
104 AFMT_S32_LE, AFMT_S32_BE, AFMT_U32_LE, AFMT_U32_BE,
105 AFMT_F32_LE, AFMT_F32_BE,
106 0
107 };
108
109 /* Everything that is convertible. */
110 static uint32_t feeder_chain_formats_fullmulti[] = {
111 AFMT_S8, AFMT_U8,
112 AFMT_S16_LE, AFMT_S16_BE, AFMT_U16_LE, AFMT_U16_BE,
113 AFMT_S24_LE, AFMT_S24_BE, AFMT_U24_LE, AFMT_U24_BE,
114 AFMT_S32_LE, AFMT_S32_BE, AFMT_U32_LE, AFMT_U32_BE,
115 AFMT_F32_LE, AFMT_F32_BE,
116 0
117 };
118
119 static uint32_t *feeder_chain_formats[FEEDER_CHAIN_LAST] = {
120 [FEEDER_CHAIN_LEAN] = feeder_chain_formats_lean,
121 [FEEDER_CHAIN_16] = feeder_chain_formats_16,
122 [FEEDER_CHAIN_32] = feeder_chain_formats_32,
123 [FEEDER_CHAIN_MULTI] = feeder_chain_formats_multi,
124 [FEEDER_CHAIN_FULLMULTI] = feeder_chain_formats_fullmulti
125 };
126
127 static int feeder_chain_mode = FEEDER_CHAIN_DEFAULT;
128
129 #if defined(_KERNEL) && defined(SND_DEBUG) && defined(SND_FEEDER_FULL_MULTIFORMAT)
130 SYSCTL_INT(_hw_snd, OID_AUTO, feeder_chain_mode, CTLFLAG_RWTUN,
131 &feeder_chain_mode, 0,
132 "feeder chain mode "
133 "(0=lean, 1=16bit, 2=32bit, 3=multiformat, 4=fullmultiformat)");
134 #endif
135
136 /*
137 * feeder_build_format(): Chain any format converter.
138 */
139 static int
feeder_build_format(struct pcm_channel * c,struct feeder_chain_desc * cdesc)140 feeder_build_format(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
141 {
142 struct feeder_class *fc;
143 struct pcm_feederdesc *desc;
144 int ret;
145
146 desc = &(cdesc->desc);
147 desc->in = 0;
148 desc->out = 0;
149
150 fc = feeder_getclass(FEEDER_FORMAT);
151 if (fc == NULL) {
152 device_printf(c->dev,
153 "%s(): can't find feeder_format\n", __func__);
154 return (ENOTSUP);
155 }
156
157 desc->in = cdesc->current.afmt;
158 desc->out = cdesc->target.afmt;
159
160 ret = feeder_add(c, fc, desc);
161 if (ret != 0) {
162 device_printf(c->dev,
163 "%s(): can't add feeder_format\n", __func__);
164 return (ret);
165 }
166
167 c->feederflags |= 1 << FEEDER_FORMAT;
168
169 cdesc->current.afmt = cdesc->target.afmt;
170
171 return (0);
172 }
173
174 /*
175 * feeder_build_formatne(): Chain format converter that suite best for native
176 * endian format.
177 */
178 static int
feeder_build_formatne(struct pcm_channel * c,struct feeder_chain_desc * cdesc)179 feeder_build_formatne(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
180 {
181 struct feeder_chain_state otarget;
182 int ret;
183
184 if (cdesc->afmt_ne == 0 ||
185 AFMT_ENCODING(cdesc->current.afmt) == cdesc->afmt_ne)
186 return (0);
187
188 otarget = cdesc->target;
189 cdesc->target = cdesc->current;
190 cdesc->target.afmt = SND_FORMAT(cdesc->afmt_ne,
191 cdesc->current.matrix->channels, cdesc->current.matrix->ext);
192
193 ret = feeder_build_format(c, cdesc);
194 if (ret != 0)
195 return (ret);
196
197 cdesc->target = otarget;
198
199 return (0);
200 }
201
202 /*
203 * feeder_build_rate(): Chain sample rate converter.
204 */
205 static int
feeder_build_rate(struct pcm_channel * c,struct feeder_chain_desc * cdesc)206 feeder_build_rate(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
207 {
208 struct feeder_class *fc;
209 struct pcm_feeder *f;
210 struct pcm_feederdesc *desc;
211 int ret;
212
213 ret = feeder_build_formatne(c, cdesc);
214 if (ret != 0)
215 return (ret);
216
217 desc = &(cdesc->desc);
218 desc->in = 0;
219 desc->out = 0;
220
221 fc = feeder_getclass(FEEDER_RATE);
222 if (fc == NULL) {
223 device_printf(c->dev,
224 "%s(): can't find feeder_rate\n", __func__);
225 return (ENOTSUP);
226 }
227
228 desc->in = cdesc->current.afmt;
229 desc->out = desc->in;
230
231 ret = feeder_add(c, fc, desc);
232 if (ret != 0) {
233 device_printf(c->dev,
234 "%s(): can't add feeder_rate\n", __func__);
235 return (ret);
236 }
237
238 f = c->feeder;
239
240 /*
241 * If in 'dummy' mode (possibly due to passthrough mode), set the
242 * conversion quality to the lowest possible (should be fastest) since
243 * listener won't be hearing anything. Theoretically we can just
244 * disable it, but that will cause weird runtime behaviour:
245 * application appear to play something that is either too fast or too
246 * slow.
247 */
248 if (cdesc->dummy != 0) {
249 ret = FEEDER_SET(f, FEEDRATE_QUALITY, 0);
250 if (ret != 0) {
251 device_printf(c->dev,
252 "%s(): can't set resampling quality\n", __func__);
253 return (ret);
254 }
255 }
256
257 ret = FEEDER_SET(f, FEEDRATE_SRC, cdesc->current.rate);
258 if (ret != 0) {
259 device_printf(c->dev,
260 "%s(): can't set source rate\n", __func__);
261 return (ret);
262 }
263
264 ret = FEEDER_SET(f, FEEDRATE_DST, cdesc->target.rate);
265 if (ret != 0) {
266 device_printf(c->dev,
267 "%s(): can't set destination rate\n", __func__);
268 return (ret);
269 }
270
271 c->feederflags |= 1 << FEEDER_RATE;
272
273 cdesc->current.rate = cdesc->target.rate;
274
275 return (0);
276 }
277
278 /*
279 * feeder_build_matrix(): Chain channel matrixing converter.
280 */
281 static int
feeder_build_matrix(struct pcm_channel * c,struct feeder_chain_desc * cdesc)282 feeder_build_matrix(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
283 {
284 struct feeder_class *fc;
285 struct pcm_feeder *f;
286 struct pcm_feederdesc *desc;
287 int ret;
288
289 ret = feeder_build_formatne(c, cdesc);
290 if (ret != 0)
291 return (ret);
292
293 desc = &(cdesc->desc);
294 desc->in = 0;
295 desc->out = 0;
296
297 fc = feeder_getclass(FEEDER_MATRIX);
298 if (fc == NULL) {
299 device_printf(c->dev,
300 "%s(): can't find feeder_matrix\n", __func__);
301 return (ENOTSUP);
302 }
303
304 desc->in = cdesc->current.afmt;
305 desc->out = SND_FORMAT(cdesc->current.afmt,
306 cdesc->target.matrix->channels, cdesc->target.matrix->ext);
307
308 ret = feeder_add(c, fc, desc);
309 if (ret != 0) {
310 device_printf(c->dev,
311 "%s(): can't add feeder_matrix\n", __func__);
312 return (ret);
313 }
314
315 f = c->feeder;
316 ret = feeder_matrix_setup(f, cdesc->current.matrix,
317 cdesc->target.matrix);
318 if (ret != 0) {
319 device_printf(c->dev,
320 "%s(): feeder_matrix_setup() failed\n", __func__);
321 return (ret);
322 }
323
324 c->feederflags |= 1 << FEEDER_MATRIX;
325
326 cdesc->current.afmt = desc->out;
327 cdesc->current.matrix = cdesc->target.matrix;
328 cdesc->use_matrix = 0;
329
330 return (0);
331 }
332
333 /*
334 * feeder_build_volume(): Chain soft volume.
335 */
336 static int
feeder_build_volume(struct pcm_channel * c,struct feeder_chain_desc * cdesc)337 feeder_build_volume(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
338 {
339 struct feeder_class *fc;
340 struct pcm_feeder *f;
341 struct pcm_feederdesc *desc;
342 int ret;
343
344 ret = feeder_build_formatne(c, cdesc);
345 if (ret != 0)
346 return (ret);
347
348 desc = &(cdesc->desc);
349 desc->in = 0;
350 desc->out = 0;
351
352 fc = feeder_getclass(FEEDER_VOLUME);
353 if (fc == NULL) {
354 device_printf(c->dev,
355 "%s(): can't find feeder_volume\n", __func__);
356 return (ENOTSUP);
357 }
358
359 desc->in = cdesc->current.afmt;
360 desc->out = desc->in;
361
362 ret = feeder_add(c, fc, desc);
363 if (ret != 0) {
364 device_printf(c->dev,
365 "%s(): can't add feeder_volume\n", __func__);
366 return (ret);
367 }
368
369 f = c->feeder;
370
371 /*
372 * If in 'dummy' mode (possibly due to passthrough mode), set BYPASS
373 * mode since listener won't be hearing anything. Theoretically we can
374 * just disable it, but that will confuse volume per channel mixer.
375 */
376 if (cdesc->dummy != 0) {
377 ret = FEEDER_SET(f, FEEDVOLUME_STATE, FEEDVOLUME_BYPASS);
378 if (ret != 0) {
379 device_printf(c->dev,
380 "%s(): can't set volume bypass\n", __func__);
381 return (ret);
382 }
383 }
384
385 ret = feeder_volume_apply_matrix(f, cdesc->current.matrix);
386 if (ret != 0) {
387 device_printf(c->dev,
388 "%s(): feeder_volume_apply_matrix() failed\n", __func__);
389 return (ret);
390 }
391
392 c->feederflags |= 1 << FEEDER_VOLUME;
393
394 cdesc->use_volume = 0;
395
396 return (0);
397 }
398
399 /*
400 * feeder_build_eq(): Chain parametric software equalizer.
401 */
402 static int
feeder_build_eq(struct pcm_channel * c,struct feeder_chain_desc * cdesc)403 feeder_build_eq(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
404 {
405 struct feeder_class *fc;
406 struct pcm_feeder *f;
407 struct pcm_feederdesc *desc;
408 int ret;
409
410 ret = feeder_build_formatne(c, cdesc);
411 if (ret != 0)
412 return (ret);
413
414 desc = &(cdesc->desc);
415 desc->in = 0;
416 desc->out = 0;
417
418 fc = feeder_getclass(FEEDER_EQ);
419 if (fc == NULL) {
420 device_printf(c->dev,
421 "%s(): can't find feeder_eq\n", __func__);
422 return (ENOTSUP);
423 }
424
425 desc->in = cdesc->current.afmt;
426 desc->out = desc->in;
427
428 ret = feeder_add(c, fc, desc);
429 if (ret != 0) {
430 device_printf(c->dev,
431 "%s(): can't add feeder_eq\n", __func__);
432 return (ret);
433 }
434
435 f = c->feeder;
436
437 ret = FEEDER_SET(f, FEEDEQ_RATE, cdesc->current.rate);
438 if (ret != 0) {
439 device_printf(c->dev,
440 "%s(): can't set rate on feeder_eq\n", __func__);
441 return (ret);
442 }
443
444 c->feederflags |= 1 << FEEDER_EQ;
445
446 cdesc->use_eq = 0;
447
448 return (0);
449 }
450
451 /*
452 * feeder_build_root(): Chain root feeder, the top, father of all.
453 */
454 static int
feeder_build_root(struct pcm_channel * c,struct feeder_chain_desc * cdesc)455 feeder_build_root(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
456 {
457 struct feeder_class *fc;
458 int ret;
459
460 fc = feeder_getclass(FEEDER_ROOT);
461 if (fc == NULL) {
462 device_printf(c->dev,
463 "%s(): can't find feeder_root\n", __func__);
464 return (ENOTSUP);
465 }
466
467 ret = feeder_add(c, fc, NULL);
468 if (ret != 0) {
469 device_printf(c->dev,
470 "%s(): can't add feeder_root\n", __func__);
471 return (ret);
472 }
473
474 c->feederflags |= 1 << FEEDER_ROOT;
475
476 c->feeder->desc->in = cdesc->current.afmt;
477 c->feeder->desc->out = cdesc->current.afmt;
478
479 return (0);
480 }
481
482 /*
483 * feeder_build_mixer(): Chain software mixer for virtual channels.
484 */
485 static int
feeder_build_mixer(struct pcm_channel * c,struct feeder_chain_desc * cdesc)486 feeder_build_mixer(struct pcm_channel *c, struct feeder_chain_desc *cdesc)
487 {
488 struct feeder_class *fc;
489 struct pcm_feederdesc *desc;
490 int ret;
491
492 desc = &(cdesc->desc);
493 desc->in = 0;
494 desc->out = 0;
495
496 fc = feeder_getclass(FEEDER_MIXER);
497 if (fc == NULL) {
498 device_printf(c->dev,
499 "%s(): can't find feeder_mixer\n", __func__);
500 return (ENOTSUP);
501 }
502
503 desc->in = cdesc->current.afmt;
504 desc->out = desc->in;
505
506 ret = feeder_add(c, fc, desc);
507 if (ret != 0) {
508 device_printf(c->dev,
509 "%s(): can't add feeder_mixer\n", __func__);
510 return (ret);
511 }
512
513 c->feederflags |= 1 << FEEDER_MIXER;
514
515 return (0);
516 }
517
518 /* Macrosses to ease our job doing stuffs later. */
519 #define FEEDER_BW(c, t) ((c)->t.matrix->channels * (c)->t.rate)
520
521 #define FEEDRATE_UP(c) ((c)->target.rate > (c)->current.rate)
522 #define FEEDRATE_DOWN(c) ((c)->target.rate < (c)->current.rate)
523 #define FEEDRATE_REQUIRED(c) (FEEDRATE_UP(c) || FEEDRATE_DOWN(c))
524
525 #define FEEDMATRIX_UP(c) ((c)->target.matrix->channels > \
526 (c)->current.matrix->channels)
527 #define FEEDMATRIX_DOWN(c) ((c)->target.matrix->channels < \
528 (c)->current.matrix->channels)
529 #define FEEDMATRIX_REQUIRED(c) (FEEDMATRIX_UP(c) || \
530 FEEDMATRIX_DOWN(c) || (c)->use_matrix != 0)
531
532 #define FEEDFORMAT_REQUIRED(c) (AFMT_ENCODING((c)->current.afmt) != \
533 AFMT_ENCODING((c)->target.afmt))
534
535 #define FEEDVOLUME_REQUIRED(c) ((c)->use_volume != 0)
536
537 #define FEEDEQ_VALIDRATE(c, t) (feeder_eq_validrate((c)->t.rate) != 0)
538 #define FEEDEQ_ECONOMY(c) (FEEDER_BW(c, current) < FEEDER_BW(c, target))
539 #define FEEDEQ_REQUIRED(c) ((c)->use_eq != 0 && \
540 FEEDEQ_VALIDRATE(c, current))
541
542 #define FEEDFORMAT_NE_REQUIRED(c) \
543 ((c)->afmt_ne != AFMT_S32_NE && \
544 (((c)->mode == FEEDER_CHAIN_16 && \
545 AFMT_ENCODING((c)->current.afmt) != AFMT_S16_NE) || \
546 ((c)->mode == FEEDER_CHAIN_32 && \
547 AFMT_ENCODING((c)->current.afmt) != AFMT_S32_NE) || \
548 (c)->mode == FEEDER_CHAIN_FULLMULTI || \
549 ((c)->mode == FEEDER_CHAIN_MULTI && \
550 ((c)->current.afmt & AFMT_8BIT)) || \
551 ((c)->mode == FEEDER_CHAIN_LEAN && \
552 !((c)->current.afmt & (AFMT_S16_NE | AFMT_S32_NE)))))
553
554 static void
feeder_default_matrix(struct pcmchan_matrix * m,uint32_t fmt,int id)555 feeder_default_matrix(struct pcmchan_matrix *m, uint32_t fmt, int id)
556 {
557 int x;
558
559 memset(m, 0, sizeof(*m));
560
561 m->id = id;
562 m->channels = AFMT_CHANNEL(fmt);
563 m->ext = AFMT_EXTCHANNEL(fmt);
564 for (x = 0; x != SND_CHN_T_MAX; x++)
565 m->offset[x] = -1;
566 }
567
568 int
feeder_chain(struct pcm_channel * c)569 feeder_chain(struct pcm_channel *c)
570 {
571 struct snddev_info *d;
572 struct pcmchan_caps *caps;
573 struct feeder_chain_desc cdesc;
574 struct pcmchan_matrix *hwmatrix, *softmatrix;
575 uint32_t hwfmt, softfmt;
576 int ret;
577
578 CHN_LOCKASSERT(c);
579
580 /* Remove everything first. */
581 feeder_remove(c);
582
583 KASSERT(c->feeder == NULL, ("feeder chain not empty"));
584
585 /* clear and populate chain descriptor. */
586 bzero(&cdesc, sizeof(cdesc));
587
588 switch (feeder_chain_mode) {
589 case FEEDER_CHAIN_LEAN:
590 case FEEDER_CHAIN_16:
591 case FEEDER_CHAIN_32:
592 #if defined(SND_FEEDER_MULTIFORMAT) || defined(SND_FEEDER_FULL_MULTIFORMAT)
593 case FEEDER_CHAIN_MULTI:
594 #endif
595 #if defined(SND_FEEDER_FULL_MULTIFORMAT)
596 case FEEDER_CHAIN_FULLMULTI:
597 #endif
598 break;
599 default:
600 feeder_chain_mode = FEEDER_CHAIN_DEFAULT;
601 break;
602 }
603
604 cdesc.mode = feeder_chain_mode;
605 cdesc.expensive = 1; /* XXX faster.. */
606
607 #define VCHAN_PASSTHROUGH(c) (((c)->flags & (CHN_F_VIRTUAL | \
608 CHN_F_PASSTHROUGH)) == \
609 (CHN_F_VIRTUAL | CHN_F_PASSTHROUGH))
610
611 /* Get the best possible hardware format. */
612 if (VCHAN_PASSTHROUGH(c))
613 hwfmt = c->parentchannel->format;
614 else {
615 caps = chn_getcaps(c);
616 if (caps == NULL || caps->fmtlist == NULL) {
617 device_printf(c->dev,
618 "%s(): failed to get channel caps\n", __func__);
619 return (ENODEV);
620 }
621
622 if ((c->format & AFMT_PASSTHROUGH) &&
623 !snd_fmtvalid(c->format, caps->fmtlist))
624 return (ENODEV);
625
626 hwfmt = snd_fmtbest(c->format, caps->fmtlist);
627 if (hwfmt == 0 || !snd_fmtvalid(hwfmt, caps->fmtlist)) {
628 device_printf(c->dev,
629 "%s(): invalid hardware format 0x%08x\n",
630 __func__, hwfmt);
631 {
632 int i;
633 for (i = 0; caps->fmtlist[i] != 0; i++)
634 printf("0x%08x\n", caps->fmtlist[i]);
635 printf("Req: 0x%08x\n", c->format);
636 }
637 return (ENODEV);
638 }
639 }
640
641 /*
642 * The 'hardware' possibly have different interpretation of channel
643 * matrixing, so get it first .....
644 */
645 hwmatrix = CHANNEL_GETMATRIX(c->methods, c->devinfo, hwfmt);
646 if (hwmatrix == NULL) {
647 /* setup a default matrix */
648 hwmatrix = &c->matrix_scratch;
649 feeder_default_matrix(hwmatrix, hwfmt,
650 SND_CHN_MATRIX_UNKNOWN);
651 }
652 /* ..... and rebuild hwfmt. */
653 hwfmt = SND_FORMAT(hwfmt, hwmatrix->channels, hwmatrix->ext);
654
655 /* Reset and rebuild default channel format/matrix map. */
656 softfmt = c->format;
657 softmatrix = &c->matrix;
658 if (softmatrix->channels != AFMT_CHANNEL(softfmt) ||
659 softmatrix->ext != AFMT_EXTCHANNEL(softfmt)) {
660 softmatrix = feeder_matrix_format_map(softfmt);
661 if (softmatrix == NULL) {
662 /* setup a default matrix */
663 softmatrix = &c->matrix;
664 feeder_default_matrix(softmatrix, softfmt,
665 SND_CHN_MATRIX_PCMCHANNEL);
666 } else {
667 c->matrix = *softmatrix;
668 c->matrix.id = SND_CHN_MATRIX_PCMCHANNEL;
669 }
670 }
671 softfmt = SND_FORMAT(softfmt, softmatrix->channels, softmatrix->ext);
672 if (softfmt != c->format)
673 device_printf(c->dev,
674 "%s(): WARNING: %s Soft format 0x%08x -> 0x%08x\n",
675 __func__, CHN_DIRSTR(c), c->format, softfmt);
676
677 /*
678 * PLAY and REC are opposite.
679 */
680 if (c->direction == PCMDIR_PLAY) {
681 cdesc.origin.afmt = softfmt;
682 cdesc.origin.matrix = softmatrix;
683 cdesc.origin.rate = c->speed;
684 cdesc.target.afmt = hwfmt;
685 cdesc.target.matrix = hwmatrix;
686 cdesc.target.rate = c->bufhard->spd;
687 } else {
688 cdesc.origin.afmt = hwfmt;
689 cdesc.origin.matrix = hwmatrix;
690 cdesc.origin.rate = c->bufhard->spd;
691 cdesc.target.afmt = softfmt;
692 cdesc.target.matrix = softmatrix;
693 cdesc.target.rate = c->speed;
694 }
695
696 d = c->parentsnddev;
697
698 /*
699 * If channel is in bitperfect or passthrough mode, make it appear
700 * that 'origin' and 'target' identical, skipping mostly chain
701 * procedures.
702 */
703 if (CHN_BITPERFECT(c) || (c->format & AFMT_PASSTHROUGH)) {
704 if (c->direction == PCMDIR_PLAY)
705 cdesc.origin = cdesc.target;
706 else
707 cdesc.target = cdesc.origin;
708 c->format = cdesc.target.afmt;
709 c->speed = cdesc.target.rate;
710 } else {
711 /*
712 * Bail out early if we do not support either of those formats.
713 */
714 if ((cdesc.origin.afmt & AFMT_CONVERTIBLE) == 0 ||
715 (cdesc.target.afmt & AFMT_CONVERTIBLE) == 0) {
716 device_printf(c->dev,
717 "%s(): unsupported formats: in=0x%08x, out=0x%08x\n",
718 __func__, cdesc.origin.afmt, cdesc.target.afmt);
719 return (ENODEV);
720 }
721
722 /* hwfmt is not convertible, so 'dummy' it. */
723 if (hwfmt & AFMT_PASSTHROUGH)
724 cdesc.dummy = 1;
725
726 if ((softfmt & AFMT_CONVERTIBLE) &&
727 (((d->flags & SD_F_VPC) && !(c->flags & CHN_F_HAS_VCHAN)) ||
728 (!(d->flags & SD_F_VPC) && (d->flags & SD_F_SOFTPCMVOL) &&
729 !(c->flags & CHN_F_VIRTUAL))))
730 cdesc.use_volume = 1;
731
732 if (feeder_matrix_compare(cdesc.origin.matrix,
733 cdesc.target.matrix) != 0)
734 cdesc.use_matrix = 1;
735
736 /* Soft EQ only applicable for PLAY. */
737 if (cdesc.dummy == 0 &&
738 c->direction == PCMDIR_PLAY && (d->flags & SD_F_EQ) &&
739 (((d->flags & SD_F_EQ_PC) &&
740 !(c->flags & CHN_F_HAS_VCHAN)) ||
741 (!(d->flags & SD_F_EQ_PC) && !(c->flags & CHN_F_VIRTUAL))))
742 cdesc.use_eq = 1;
743
744 if (FEEDFORMAT_NE_REQUIRED(&cdesc)) {
745 cdesc.afmt_ne =
746 (cdesc.dummy != 0) ?
747 snd_fmtbest(AFMT_ENCODING(softfmt),
748 feeder_chain_formats[cdesc.mode]) :
749 snd_fmtbest(AFMT_ENCODING(cdesc.target.afmt),
750 feeder_chain_formats[cdesc.mode]);
751 if (cdesc.afmt_ne == 0) {
752 device_printf(c->dev,
753 "%s(): snd_fmtbest failed!\n", __func__);
754 cdesc.afmt_ne =
755 (((cdesc.dummy != 0) ? softfmt :
756 cdesc.target.afmt) &
757 (AFMT_24BIT | AFMT_32BIT)) ?
758 AFMT_S32_NE : AFMT_S16_NE;
759 }
760 }
761 }
762
763 cdesc.current = cdesc.origin;
764
765 /* Build everything. */
766
767 c->feederflags = 0;
768
769 #define FEEDER_BUILD(t) do { \
770 ret = feeder_build_##t(c, &cdesc); \
771 if (ret != 0) \
772 return (ret); \
773 } while (0)
774
775 if (!(c->flags & CHN_F_HAS_VCHAN) || c->direction == PCMDIR_REC)
776 FEEDER_BUILD(root);
777 else if (c->direction == PCMDIR_PLAY && (c->flags & CHN_F_HAS_VCHAN))
778 FEEDER_BUILD(mixer);
779 else
780 return (ENOTSUP);
781
782 /*
783 * The basic idea is: The smaller the bandwidth, the cheaper the
784 * conversion process, with following constraints:-
785 *
786 * 1) Almost all feeders work best in 16/32 native endian.
787 * 2) Try to avoid 8bit feeders due to poor dynamic range.
788 * 3) Avoid volume, format, matrix and rate in BITPERFECT or
789 * PASSTHROUGH mode.
790 * 4) Try putting volume before EQ or rate. Should help to
791 * avoid/reduce possible clipping.
792 * 5) EQ require specific, valid rate, unless it allow sloppy
793 * conversion.
794 */
795 if (FEEDMATRIX_UP(&cdesc)) {
796 if (FEEDEQ_REQUIRED(&cdesc) &&
797 (!FEEDEQ_VALIDRATE(&cdesc, target) ||
798 (cdesc.expensive == 0 && FEEDEQ_ECONOMY(&cdesc))))
799 FEEDER_BUILD(eq);
800 if (FEEDRATE_REQUIRED(&cdesc))
801 FEEDER_BUILD(rate);
802 FEEDER_BUILD(matrix);
803 if (FEEDVOLUME_REQUIRED(&cdesc))
804 FEEDER_BUILD(volume);
805 if (FEEDEQ_REQUIRED(&cdesc))
806 FEEDER_BUILD(eq);
807 } else if (FEEDMATRIX_DOWN(&cdesc)) {
808 FEEDER_BUILD(matrix);
809 if (FEEDVOLUME_REQUIRED(&cdesc))
810 FEEDER_BUILD(volume);
811 if (FEEDEQ_REQUIRED(&cdesc) &&
812 (!FEEDEQ_VALIDRATE(&cdesc, target) ||
813 FEEDEQ_ECONOMY(&cdesc)))
814 FEEDER_BUILD(eq);
815 if (FEEDRATE_REQUIRED(&cdesc))
816 FEEDER_BUILD(rate);
817 if (FEEDEQ_REQUIRED(&cdesc))
818 FEEDER_BUILD(eq);
819 } else {
820 if (FEEDRATE_DOWN(&cdesc)) {
821 if (FEEDEQ_REQUIRED(&cdesc) &&
822 !FEEDEQ_VALIDRATE(&cdesc, target)) {
823 if (FEEDVOLUME_REQUIRED(&cdesc))
824 FEEDER_BUILD(volume);
825 FEEDER_BUILD(eq);
826 }
827 FEEDER_BUILD(rate);
828 }
829 if (FEEDMATRIX_REQUIRED(&cdesc))
830 FEEDER_BUILD(matrix);
831 if (FEEDVOLUME_REQUIRED(&cdesc))
832 FEEDER_BUILD(volume);
833 if (FEEDRATE_UP(&cdesc)) {
834 if (FEEDEQ_REQUIRED(&cdesc) &&
835 !FEEDEQ_VALIDRATE(&cdesc, target))
836 FEEDER_BUILD(eq);
837 FEEDER_BUILD(rate);
838 }
839 if (FEEDEQ_REQUIRED(&cdesc))
840 FEEDER_BUILD(eq);
841 }
842
843 if (FEEDFORMAT_REQUIRED(&cdesc))
844 FEEDER_BUILD(format);
845
846 if (c->direction == PCMDIR_REC && (c->flags & CHN_F_HAS_VCHAN))
847 FEEDER_BUILD(mixer);
848
849 sndbuf_setfmt(c->bufsoft, c->format);
850 sndbuf_setspd(c->bufsoft, c->speed);
851
852 sndbuf_setfmt(c->bufhard, hwfmt);
853
854 chn_syncstate(c);
855
856 return (0);
857 }
858