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 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 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 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 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 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 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 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 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 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 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