1 /*- 2 * Copyright (c) 1999 Cameron Grant <cg@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 * $FreeBSD: src/sys/dev/sound/pcm/feeder.c,v 1.33.2.3 2006/03/07 15:51:19 jhb Exp $ 27 * $DragonFly: src/sys/dev/sound/pcm/feeder.c,v 1.6 2007/01/04 21:47:03 corecode Exp $ 28 */ 29 30 #include <dev/sound/pcm/sound.h> 31 32 #include "feeder_if.h" 33 34 SND_DECLARE_FILE("$DragonFly: src/sys/dev/sound/pcm/feeder.c,v 1.6 2007/01/04 21:47:03 corecode Exp $"); 35 36 MALLOC_DEFINE(M_FEEDER, "feeder", "pcm feeder"); 37 38 #define MAXFEEDERS 256 39 #undef FEEDER_DEBUG 40 41 struct feedertab_entry { 42 SLIST_ENTRY(feedertab_entry) link; 43 struct feeder_class *feederclass; 44 struct pcm_feederdesc *desc; 45 46 int idx; 47 }; 48 static SLIST_HEAD(, feedertab_entry) feedertab; 49 50 /*****************************************************************************/ 51 52 void 53 feeder_register(void *p) 54 { 55 static int feedercnt = 0; 56 57 struct feeder_class *fc = p; 58 struct feedertab_entry *fte; 59 int i; 60 61 if (feedercnt == 0) { 62 KASSERT(fc->desc == NULL, ("first feeder not root: %s", fc->name)); 63 64 SLIST_INIT(&feedertab); 65 fte = kmalloc(sizeof(*fte), M_FEEDER, M_NOWAIT | M_ZERO); 66 if (fte == NULL) { 67 kprintf("can't allocate memory for root feeder: %s\n", 68 fc->name); 69 70 return; 71 } 72 fte->feederclass = fc; 73 fte->desc = NULL; 74 fte->idx = feedercnt; 75 SLIST_INSERT_HEAD(&feedertab, fte, link); 76 feedercnt++; 77 78 /* we've got our root feeder so don't veto pcm loading anymore */ 79 pcm_veto_load = 0; 80 81 return; 82 } 83 84 KASSERT(fc->desc != NULL, ("feeder '%s' has no descriptor", fc->name)); 85 86 /* beyond this point failure is non-fatal but may result in some translations being unavailable */ 87 i = 0; 88 while ((feedercnt < MAXFEEDERS) && (fc->desc[i].type > 0)) { 89 /* kprintf("adding feeder %s, %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out); */ 90 fte = kmalloc(sizeof(*fte), M_FEEDER, M_NOWAIT | M_ZERO); 91 if (fte == NULL) { 92 kprintf("can't allocate memory for feeder '%s', %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out); 93 94 return; 95 } 96 fte->feederclass = fc; 97 fte->desc = &fc->desc[i]; 98 fte->idx = feedercnt; 99 fte->desc->idx = feedercnt; 100 SLIST_INSERT_HEAD(&feedertab, fte, link); 101 i++; 102 } 103 feedercnt++; 104 if (feedercnt >= MAXFEEDERS) 105 kprintf("MAXFEEDERS (%d >= %d) exceeded\n", feedercnt, MAXFEEDERS); 106 } 107 108 static void 109 feeder_unregisterall(void *p) 110 { 111 struct feedertab_entry *fte, *next; 112 113 next = SLIST_FIRST(&feedertab); 114 while (next != NULL) { 115 fte = next; 116 next = SLIST_NEXT(fte, link); 117 kfree(fte, M_FEEDER); 118 } 119 } 120 121 static int 122 cmpdesc(struct pcm_feederdesc *n, struct pcm_feederdesc *m) 123 { 124 return ((n->type == m->type) && 125 ((n->in == 0) || (n->in == m->in)) && 126 ((n->out == 0) || (n->out == m->out)) && 127 (n->flags == m->flags)); 128 } 129 130 static void 131 feeder_destroy(struct pcm_feeder *f) 132 { 133 FEEDER_FREE(f); 134 kobj_delete((kobj_t)f, M_FEEDER); 135 } 136 137 static struct pcm_feeder * 138 feeder_create(struct feeder_class *fc, struct pcm_feederdesc *desc) 139 { 140 struct pcm_feeder *f; 141 int err; 142 143 f = (struct pcm_feeder *)kobj_create((kobj_class_t)fc, M_FEEDER, M_NOWAIT | M_ZERO); 144 if (f == NULL) 145 return NULL; 146 147 f->align = fc->align; 148 f->data = fc->data; 149 f->source = NULL; 150 f->parent = NULL; 151 f->class = fc; 152 f->desc = &(f->desc_static); 153 154 if (desc) { 155 *(f->desc) = *desc; 156 } else { 157 f->desc->type = FEEDER_ROOT; 158 f->desc->in = 0; 159 f->desc->out = 0; 160 f->desc->flags = 0; 161 f->desc->idx = 0; 162 } 163 164 err = FEEDER_INIT(f); 165 if (err) { 166 kprintf("feeder_init(%p) on %s returned %d\n", f, fc->name, err); 167 feeder_destroy(f); 168 169 return NULL; 170 } 171 172 return f; 173 } 174 175 struct feeder_class * 176 feeder_getclass(struct pcm_feederdesc *desc) 177 { 178 struct feedertab_entry *fte; 179 180 SLIST_FOREACH(fte, &feedertab, link) { 181 if ((desc == NULL) && (fte->desc == NULL)) 182 return fte->feederclass; 183 if ((fte->desc != NULL) && (desc != NULL) && cmpdesc(desc, fte->desc)) 184 return fte->feederclass; 185 } 186 return NULL; 187 } 188 189 int 190 chn_addfeeder(struct pcm_channel *c, struct feeder_class *fc, struct pcm_feederdesc *desc) 191 { 192 struct pcm_feeder *nf; 193 194 nf = feeder_create(fc, desc); 195 if (nf == NULL) 196 return ENOSPC; 197 198 nf->source = c->feeder; 199 200 /* XXX we should use the lowest common denominator for align */ 201 if (nf->align > 0) 202 c->align += nf->align; 203 else if (nf->align < 0 && c->align < -nf->align) 204 c->align = -nf->align; 205 if (c->feeder != NULL) 206 c->feeder->parent = nf; 207 c->feeder = nf; 208 209 return 0; 210 } 211 212 int 213 chn_removefeeder(struct pcm_channel *c) 214 { 215 struct pcm_feeder *f; 216 217 if (c->feeder == NULL) 218 return -1; 219 f = c->feeder; 220 c->feeder = c->feeder->source; 221 feeder_destroy(f); 222 223 return 0; 224 } 225 226 struct pcm_feeder * 227 chn_findfeeder(struct pcm_channel *c, u_int32_t type) 228 { 229 struct pcm_feeder *f; 230 231 f = c->feeder; 232 while (f != NULL) { 233 if (f->desc->type == type) 234 return f; 235 f = f->source; 236 } 237 238 return NULL; 239 } 240 241 static int 242 chainok(struct pcm_feeder *test, struct pcm_feeder *stop) 243 { 244 u_int32_t visited[MAXFEEDERS / 32]; 245 u_int32_t idx, mask; 246 247 bzero(visited, sizeof(visited)); 248 while (test && (test != stop)) { 249 idx = test->desc->idx; 250 if (idx < 0) 251 panic("bad idx %d", idx); 252 if (idx >= MAXFEEDERS) 253 panic("bad idx %d", idx); 254 mask = 1 << (idx & 31); 255 idx >>= 5; 256 if (visited[idx] & mask) 257 return 0; 258 visited[idx] |= mask; 259 test = test->source; 260 } 261 262 return 1; 263 } 264 265 static struct pcm_feeder * 266 feeder_fmtchain(u_int32_t *to, struct pcm_feeder *source, struct pcm_feeder *stop, int maxdepth) 267 { 268 struct feedertab_entry *fte; 269 struct pcm_feeder *try, *ret; 270 271 DEB(kprintf("trying %s (0x%08x -> 0x%08x)...\n", source->class->name, source->desc->in, source->desc->out)); 272 if (fmtvalid(source->desc->out, to)) { 273 DEB(kprintf("got it\n")); 274 return source; 275 } 276 277 if (maxdepth < 0) 278 return NULL; 279 280 SLIST_FOREACH(fte, &feedertab, link) { 281 if (fte->desc == NULL) 282 continue; 283 if (fte->desc->type != FEEDER_FMT) 284 continue; 285 if (fte->desc->in == source->desc->out) { 286 try = feeder_create(fte->feederclass, fte->desc); 287 if (try) { 288 try->source = source; 289 ret = chainok(try, stop)? feeder_fmtchain(to, try, stop, maxdepth - 1) : NULL; 290 if (ret != NULL) 291 return ret; 292 feeder_destroy(try); 293 } 294 } 295 } 296 /* kprintf("giving up %s...\n", source->class->name); */ 297 298 return NULL; 299 } 300 301 int 302 chn_fmtscore(u_int32_t fmt) 303 { 304 if (fmt & AFMT_32BIT) 305 return 60; 306 if (fmt & AFMT_24BIT) 307 return 50; 308 if (fmt & AFMT_16BIT) 309 return 40; 310 if (fmt & (AFMT_U8|AFMT_S8)) 311 return 30; 312 if (fmt & AFMT_MU_LAW) 313 return 20; 314 if (fmt & AFMT_A_LAW) 315 return 10; 316 return 0; 317 } 318 319 u_int32_t 320 chn_fmtbestbit(u_int32_t fmt, u_int32_t *fmts) 321 { 322 u_int32_t best; 323 int i, score, score2, oldscore; 324 325 best = 0; 326 score = chn_fmtscore(fmt); 327 oldscore = 0; 328 for (i = 0; fmts[i] != 0; i++) { 329 score2 = chn_fmtscore(fmts[i]); 330 if (oldscore == 0 || (score2 == score) || 331 (score2 > oldscore && score2 < score) || 332 (score2 < oldscore && score2 > score) || 333 (oldscore < score && score2 > oldscore)) { 334 best = fmts[i]; 335 oldscore = score2; 336 } 337 } 338 return best; 339 } 340 341 u_int32_t 342 chn_fmtbeststereo(u_int32_t fmt, u_int32_t *fmts) 343 { 344 u_int32_t best; 345 int i, score, score2, oldscore; 346 347 best = 0; 348 score = chn_fmtscore(fmt); 349 oldscore = 0; 350 for (i = 0; fmts[i] != 0; i++) { 351 if ((fmt & AFMT_STEREO) == (fmts[i] & AFMT_STEREO)) { 352 score2 = chn_fmtscore(fmts[i]); 353 if (oldscore == 0 || (score2 == score) || 354 (score2 > oldscore && score2 < score) || 355 (score2 < oldscore && score2 > score) || 356 (oldscore < score && score2 > oldscore)) { 357 best = fmts[i]; 358 oldscore = score2; 359 } 360 } 361 } 362 return best; 363 } 364 365 u_int32_t 366 chn_fmtbest(u_int32_t fmt, u_int32_t *fmts) 367 { 368 u_int32_t best1, best2; 369 int score, score1, score2; 370 371 best1 = chn_fmtbeststereo(fmt, fmts); 372 best2 = chn_fmtbestbit(fmt, fmts); 373 374 if (best1 != 0 && best2 != 0) { 375 if (fmt & AFMT_STEREO) 376 return best1; 377 else { 378 score = chn_fmtscore(fmt); 379 score1 = chn_fmtscore(best1); 380 score2 = chn_fmtscore(best2); 381 if (score1 == score2 || score1 == score) 382 return best1; 383 else if (score2 == score) 384 return best2; 385 else if (score1 > score2) 386 return best1; 387 return best2; 388 } 389 } else if (best2 == 0) 390 return best1; 391 else 392 return best2; 393 } 394 395 u_int32_t 396 chn_fmtchain(struct pcm_channel *c, u_int32_t *to) 397 { 398 struct pcm_feeder *try, *del, *stop; 399 u_int32_t tmpfrom[2], tmpto[2], best, *from; 400 int i, max, bestmax; 401 402 KASSERT(c != NULL, ("c == NULL")); 403 KASSERT(c->feeder != NULL, ("c->feeder == NULL")); 404 KASSERT(to != NULL, ("to == NULL")); 405 KASSERT(to[0] != 0, ("to[0] == 0")); 406 407 stop = c->feeder; 408 409 if (c->direction == PCMDIR_REC && c->feeder->desc->type == FEEDER_ROOT) { 410 from = chn_getcaps(c)->fmtlist; 411 if (fmtvalid(to[0], from)) 412 from = to; 413 else { 414 best = chn_fmtbest(to[0], from); 415 if (best != 0) { 416 tmpfrom[0] = best; 417 tmpfrom[1] = 0; 418 from = tmpfrom; 419 } 420 } 421 } else { 422 tmpfrom[0] = c->feeder->desc->out; 423 tmpfrom[1] = 0; 424 from = tmpfrom; 425 if (to[1] != 0) { 426 if (fmtvalid(tmpfrom[0], to)) { 427 tmpto[0] = tmpfrom[0]; 428 tmpto[1] = 0; 429 to = tmpto; 430 } else { 431 best = chn_fmtbest(tmpfrom[0], to); 432 if (best != 0) { 433 tmpto[0] = best; 434 tmpto[1] = 0; 435 to = tmpto; 436 } 437 } 438 } 439 } 440 441 i = 0; 442 best = 0; 443 bestmax = 100; 444 while (from[i] != 0) { 445 c->feeder->desc->out = from[i]; 446 try = NULL; 447 max = 0; 448 while (try == NULL && max < 8) { 449 try = feeder_fmtchain(to, c->feeder, stop, max); 450 if (try == NULL) 451 max++; 452 } 453 if (try != NULL && max < bestmax) { 454 bestmax = max; 455 best = from[i]; 456 } 457 while (try != NULL && try != stop) { 458 del = try; 459 try = try->source; 460 feeder_destroy(del); 461 } 462 i++; 463 } 464 if (best == 0) 465 return 0; 466 467 c->feeder->desc->out = best; 468 try = feeder_fmtchain(to, c->feeder, stop, bestmax); 469 if (try == NULL) 470 return 0; 471 472 c->feeder = try; 473 c->align = 0; 474 #ifdef FEEDER_DEBUG 475 kprintf("\n\nchain: "); 476 #endif 477 while (try && (try != stop)) { 478 #ifdef FEEDER_DEBUG 479 kprintf("%s [%d]", try->class->name, try->desc->idx); 480 if (try->source) 481 kprintf(" -> "); 482 #endif 483 if (try->source) 484 try->source->parent = try; 485 if (try->align > 0) 486 c->align += try->align; 487 else if (try->align < 0 && c->align < -try->align) 488 c->align = -try->align; 489 try = try->source; 490 } 491 #ifdef FEEDER_DEBUG 492 kprintf("%s [%d]\n", try->class->name, try->desc->idx); 493 #endif 494 495 if (c->direction == PCMDIR_REC) { 496 try = c->feeder; 497 while (try != NULL) { 498 if (try->desc->type == FEEDER_ROOT) 499 return try->desc->out; 500 try = try->source; 501 } 502 return best; 503 } else 504 return c->feeder->desc->out; 505 } 506 507 void 508 feeder_printchain(struct pcm_feeder *head) 509 { 510 struct pcm_feeder *f; 511 512 kprintf("feeder chain (head @%p)\n", head); 513 f = head; 514 while (f != NULL) { 515 kprintf("%s/%d @ %p\n", f->class->name, f->desc->idx, f); 516 f = f->source; 517 } 518 kprintf("[end]\n\n"); 519 } 520 521 /*****************************************************************************/ 522 523 static int 524 feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u_int32_t count, void *source) 525 { 526 struct snd_dbuf *src = source; 527 int l; 528 u_int8_t x; 529 530 KASSERT(count > 0, ("feed_root: count == 0")); 531 /* count &= ~((1 << ch->align) - 1); */ 532 KASSERT(count > 0, ("feed_root: aligned count == 0 (align = %d)", ch->align)); 533 534 l = min(count, sndbuf_getready(src)); 535 sndbuf_dispose(src, buffer, l); 536 537 /* When recording only return as much data as available */ 538 if (ch->direction == PCMDIR_REC) 539 return l; 540 541 /* 542 if (l < count) 543 kprintf("appending %d bytes\n", count - l); 544 */ 545 546 x = (sndbuf_getfmt(src) & AFMT_SIGNED)? 0 : 0x80; 547 while (l < count) 548 buffer[l++] = x; 549 550 return count; 551 } 552 553 static kobj_method_t feeder_root_methods[] = { 554 KOBJMETHOD(feeder_feed, feed_root), 555 { 0, 0 } 556 }; 557 static struct feeder_class feeder_root_class = { 558 .name = "feeder_root", 559 .methods = feeder_root_methods, 560 .size = sizeof(struct pcm_feeder), 561 .align = 0, 562 .desc = NULL, 563 .data = NULL, 564 }; 565 SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root_class); 566 SYSUNINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_unregisterall, NULL); 567 568 569 570 571 572