sys/dev/sound/pcm/feeder.c

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