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 <gandalf@vilnya.demon.co.uk>
    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_WAITOK | M_ZERO);
   63                 if (fte == NULL) {
   64                         printf("can't allocate memory for root feeder\n", fc->name);
   65 
   66                         return;
   67                 }
   68                 fte->feederclass = fc;
   69                 fte->desc = NULL;
   70                 fte->idx = feedercnt;
   71                 SLIST_INSERT_HEAD(&feedertab, fte, link);
   72                 feedercnt++;
   73 
   74                 /* we've got our root feeder so don't veto pcm loading anymore */
   75                 pcm_veto_load = 0;
   76 
   77                 return;
   78         }
   79 
   80         KASSERT(fc->desc != NULL, ("feeder '%s' has no descriptor", fc->name));
   81 
   82         /* beyond this point failure is non-fatal but may result in some translations being unavailable */
   83         i = 0;
   84         while ((feedercnt < MAXFEEDERS) && (fc->desc[i].type > 0)) {
   85                 /* printf("adding feeder %s, %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out); */
   86                 fte = malloc(sizeof(*fte), M_FEEDER, M_WAITOK | M_ZERO);
   87                 if (fte == NULL) {
   88                         printf("can't allocate memory for feeder '%s', %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out);
   89 
   90                         return;
   91                 }
   92                 fte->feederclass = fc;
   93                 fte->desc = &fc->desc[i];
   94                 fte->idx = feedercnt;
   95                 fte->desc->idx = feedercnt;
   96                 SLIST_INSERT_HEAD(&feedertab, fte, link);
   97                 i++;
   98         }
   99         feedercnt++;
  100         if (feedercnt >= MAXFEEDERS)
  101                 printf("MAXFEEDERS (%d >= %d) exceeded\n", feedercnt, MAXFEEDERS);
  102 }
  103 
  104 static void
  105 feeder_unregisterall(void *p)
  106 {
  107         struct feedertab_entry *fte, *next;
  108 
  109         next = SLIST_FIRST(&feedertab);
  110         while (next != NULL) {
  111                 fte = next;
  112                 next = SLIST_NEXT(fte, link);
  113                 free(fte, M_FEEDER);
  114         }
  115 }
  116 
  117 static int
  118 cmpdesc(struct pcm_feederdesc *n, struct pcm_feederdesc *m)
  119 {
  120         return ((n->type == m->type) &&
  121                 ((n->in == 0) || (n->in == m->in)) &&
  122                 ((n->out == 0) || (n->out == m->out)) &&
  123                 (n->flags == m->flags));
  124 }
  125 
  126 static void
  127 feeder_destroy(struct pcm_feeder *f)
  128 {
  129         FEEDER_FREE(f);
  130         kobj_delete((kobj_t)f, M_FEEDER);
  131 }
  132 
  133 static struct pcm_feeder *
  134 feeder_create(struct feeder_class *fc, struct pcm_feederdesc *desc)
  135 {
  136         struct pcm_feeder *f;
  137         int err;
  138 
  139         f = (struct pcm_feeder *)kobj_create((kobj_class_t)fc, M_FEEDER, M_WAITOK | M_ZERO);
  140         if (f == NULL)
  141                 return NULL;
  142 
  143         f->align = fc->align;
  144         f->data = fc->data;
  145         f->source = NULL;
  146         f->parent = NULL;
  147         f->class = fc;
  148         f->desc = &(f->desc_static);
  149 
  150         if (desc) {
  151                 *(f->desc) = *desc;
  152         } else {
  153                 f->desc->type = FEEDER_ROOT;
  154                 f->desc->in = 0;
  155                 f->desc->out = 0;
  156                 f->desc->flags = 0;
  157                 f->desc->idx = 0;
  158         }
  159 
  160         err = FEEDER_INIT(f);
  161         if (err) {
  162                 printf("feeder_init(%p) on %s returned %d\n", f, fc->name, err);
  163                 feeder_destroy(f);
  164 
  165                 return NULL;
  166         }
  167 
  168         return f;
  169 }
  170 
  171 struct feeder_class *
  172 feeder_getclass(struct pcm_feederdesc *desc)
  173 {
  174         struct feedertab_entry *fte;
  175 
  176         SLIST_FOREACH(fte, &feedertab, link) {
  177                 if ((desc == NULL) && (fte->desc == NULL))
  178                         return fte->feederclass;
  179                 if ((fte->desc != NULL) && (desc != NULL) && cmpdesc(desc, fte->desc))
  180                         return fte->feederclass;
  181         }
  182         return NULL;
  183 }
  184 
  185 int
  186 chn_addfeeder(struct pcm_channel *c, struct feeder_class *fc, struct pcm_feederdesc *desc)
  187 {
  188         struct pcm_feeder *nf;
  189 
  190         nf = feeder_create(fc, desc);
  191         if (nf == NULL)
  192                 return ENOSPC;
  193 
  194         nf->source = c->feeder;
  195 
  196         if (nf->align > 0)
  197                 c->align += nf->align;
  198         else if (nf->align < 0 && c->align < -nf->align)
  199                 c->align = -nf->align;
  200 
  201         c->feeder = nf;
  202 
  203         return 0;
  204 }
  205 
  206 int
  207 chn_removefeeder(struct pcm_channel *c)
  208 {
  209         struct pcm_feeder *f;
  210 
  211         if (c->feeder == NULL)
  212                 return -1;
  213         f = c->feeder;
  214         c->feeder = c->feeder->source;
  215         feeder_destroy(f);
  216 
  217         return 0;
  218 }
  219 
  220 struct pcm_feeder *
  221 chn_findfeeder(struct pcm_channel *c, u_int32_t type)
  222 {
  223         struct pcm_feeder *f;
  224 
  225         f = c->feeder;
  226         while (f != NULL) {
  227                 if (f->desc->type == type)
  228                         return f;
  229                 f = f->source;
  230         }
  231 
  232         return NULL;
  233 }
  234 
  235 static int
  236 chainok(struct pcm_feeder *test, struct pcm_feeder *stop)
  237 {
  238         u_int32_t visited[MAXFEEDERS / 32];
  239         u_int32_t idx, mask;
  240 
  241         bzero(visited, sizeof(visited));
  242         while (test && (test != stop)) {
  243                 idx = test->desc->idx;
  244                 if (idx < 0)
  245                         panic("bad idx %d", idx);
  246                 if (idx >= MAXFEEDERS)
  247                         panic("bad idx %d", idx);
  248                 mask = 1 << (idx & 31);
  249                 idx >>= 5;
  250                 if (visited[idx] & mask)
  251                         return 0;
  252                 visited[idx] |= mask;
  253                 test = test->source;
  254         }
  255 
  256         return 1;
  257 }
  258 
  259 static struct pcm_feeder *
  260 feeder_fmtchain(u_int32_t *to, struct pcm_feeder *source, struct pcm_feeder *stop, int maxdepth)
  261 {
  262         struct feedertab_entry *fte;
  263         struct pcm_feeder *try, *ret;
  264 
  265         /* printf("trying %s (%x -> %x)...\n", source->class->name, source->desc->in, source->desc->out); */
  266         if (fmtvalid(source->desc->out, to)) {
  267                 /* printf("got it\n"); */
  268                 return source;
  269         }
  270 
  271         if (maxdepth < 0)
  272                 return NULL;
  273 
  274         SLIST_FOREACH(fte, &feedertab, link) {
  275                 if (fte->desc == NULL)
  276                         goto no;
  277                 if (fte->desc->type != FEEDER_FMT)
  278                         goto no;
  279                 if (fte->desc->in == source->desc->out) {
  280                         try = feeder_create(fte->feederclass, fte->desc);
  281                         if (try) {
  282                                 try->source = source;
  283                                 ret = chainok(try, stop)? feeder_fmtchain(to, try, stop, maxdepth - 1) : NULL;
  284                                 if (ret != NULL)
  285                                         return ret;
  286                                 feeder_destroy(try);
  287                         }
  288                 }
  289 no:
  290         }
  291         /* printf("giving up %s...\n", source->class->name); */
  292 
  293         return NULL;
  294 }
  295 
  296 u_int32_t
  297 chn_fmtchain(struct pcm_channel *c, u_int32_t *to)
  298 {
  299         struct pcm_feeder *try, *del, *stop;
  300         u_int32_t tmpfrom[2], best, *from;
  301         int i, max, bestmax;
  302 
  303         KASSERT(c != NULL, ("c == NULL"));
  304         KASSERT(c->feeder != NULL, ("c->feeder == NULL"));
  305         KASSERT(to != NULL, ("to == NULL"));
  306         KASSERT(to[0] != 0, ("to[0] == 0"));
  307 
  308         stop = c->feeder;
  309 
  310         if (c->direction == PCMDIR_REC && c->feeder->desc->type == FEEDER_ROOT) {
  311                 from = chn_getcaps(c)->fmtlist;
  312         } else {
  313                 tmpfrom[0] = c->feeder->desc->out;
  314                 tmpfrom[1] = 0;
  315                 from = tmpfrom;
  316         }
  317 
  318         i = 0;
  319         best = 0;
  320         bestmax = 100;
  321         while (from[i] != 0) {
  322                 c->feeder->desc->out = from[i];
  323                 try = NULL;
  324                 max = 0;
  325                 while (try == NULL && max < 8) {
  326                         try = feeder_fmtchain(to, c->feeder, stop, max);
  327                         if (try == NULL)
  328                                 max++;
  329                 }
  330                 if (try != NULL && max < bestmax) {
  331                         bestmax = max;
  332                         best = from[i];
  333                 }
  334                 while (try != NULL && try != stop) {
  335                         del = try;
  336                         try = try->source;
  337                         feeder_destroy(del);
  338                 }
  339                 i++;
  340         }
  341         if (best == 0)
  342                 return 0;
  343 
  344         c->feeder->desc->out = best;
  345         try = feeder_fmtchain(to, c->feeder, stop, bestmax);
  346         if (try == NULL)
  347                 return 0;
  348 
  349         c->feeder = try;
  350         c->align = 0;
  351 #ifdef FEEDER_DEBUG
  352         printf("\n\nchain: ");
  353 #endif
  354         while (try && (try != stop)) {
  355 #ifdef FEEDER_DEBUG
  356                 printf("%s [%d]", try->class->name, try->desc->idx);
  357                 if (try->source)
  358                         printf(" -> ");
  359 #endif
  360                 if (try->source)
  361                         try->source->parent = try;
  362                 if (try->align > 0)
  363                         c->align += try->align;
  364                 else if (try->align < 0 && c->align < -try->align)
  365                         c->align = -try->align;
  366                 try = try->source;
  367         }
  368 #ifdef FEEDER_DEBUG
  369         printf("%s [%d]\n", try->class->name, try->desc->idx);
  370 #endif
  371 
  372         return (c->direction == PCMDIR_REC)? best : c->feeder->desc->out;
  373 }
  374 
  375 /*****************************************************************************/
  376 
  377 static int
  378 feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u_int32_t count, void *source)
  379 {
  380         struct snd_dbuf *src = source;
  381         int l;
  382         u_int8_t x;
  383 
  384         KASSERT(count > 0, ("feed_root: count == 0"));
  385         /* count &= ~((1 << ch->align) - 1); */
  386         KASSERT(count > 0, ("feed_root: aligned count == 0 (align = %d)", ch->align));
  387 
  388         l = min(count, sndbuf_getready(src));
  389         sndbuf_dispose(src, buffer, l);
  390 
  391         /* When recording only return as much data as available */
  392         if (ch->direction == PCMDIR_REC)
  393                 return l;
  394 
  395 /*
  396         if (l < count)
  397                 printf("appending %d bytes\n", count - l);
  398 */
  399 
  400         x = (sndbuf_getfmt(src) & AFMT_SIGNED)? 0 : 0x80;
  401         while (l < count)
  402                 buffer[l++] = x;
  403 
  404         return count;
  405 }
  406 
  407 static kobj_method_t feeder_root_methods[] = {
  408         KOBJMETHOD(feeder_feed,         feed_root),
  409         { 0, 0 }
  410 };
  411 static struct feeder_class feeder_root_class = {
  412         .name =         "feeder_root",
  413         .methods =      feeder_root_methods,
  414         .size =         sizeof(struct pcm_feeder),
  415         .align =        0,
  416         .desc =         NULL,
  417         .data =         NULL,
  418 };
  419 SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root_class);
  420 SYSUNINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_unregisterall, NULL);
  421 
  422 
  423 
  424 
  425
Cache object: 5683f6fe80fbb603b8ee8b615449ca44
[ 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
