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