feeder.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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         KOBJMETHOD_END
  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
Cache object: 51546827353f97b71db2efbe4e048a41
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/sound/pcm/feeder.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/sound/pcm/feeder.c
