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