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