sys/dev/sound/pcm/feeder.c

   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  * $FreeBSD: src/sys/dev/sound/pcm/feeder.c,v 1.8.2.9 2003/02/08 01:43:07 orion Exp $
  27  * $DragonFly: src/sys/dev/sound/pcm/feeder.c,v 1.2 2003/06/17 04:28:31 dillon 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.2 2003/06/17 04:28:31 dillon 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 = malloc(sizeof(*fte), M_FEEDER, M_WAITOK | M_ZERO);
  66                 if (fte == NULL) {
  67                         printf("can't allocate memory for root feeder\n", fc->name);
  68
  69                         return;
  70                 }
  71                 fte->feederclass = fc;
  72                 fte->desc = NULL;
  73                 fte->idx = feedercnt;
  74                 SLIST_INSERT_HEAD(&feedertab, fte, link);
  75                 feedercnt++;
  76
  77                 /* we've got our root feeder so don't veto pcm loading anymore */
  78                 pcm_veto_load = 0;
  79
  80                 return;
  81         }
  82
  83         KASSERT(fc->desc != NULL, ("feeder '%s' has no descriptor", fc->name));
  84
  85         /* beyond this point failure is non-fatal but may result in some translations being unavailable */
  86         i = 0;
  87         while ((feedercnt < MAXFEEDERS) && (fc->desc[i].type > 0)) {
  88                 /* printf("adding feeder %s, %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out); */
  89                 fte = malloc(sizeof(*fte), M_FEEDER, M_WAITOK | M_ZERO);
  90                 if (fte == NULL) {
  91                         printf("can't allocate memory for feeder '%s', %x -> %x\n", fc->name, fc->desc[i].in, fc->desc[i].out);
  92
  93                         return;
  94                 }
  95                 fte->feederclass = fc;
  96                 fte->desc = &fc->desc[i];
  97                 fte->idx = feedercnt;
  98                 fte->desc->idx = feedercnt;
  99                 SLIST_INSERT_HEAD(&feedertab, fte, link);
 100                 i++;
 101         }
 102         feedercnt++;
 103         if (feedercnt >= MAXFEEDERS)
 104                 printf("MAXFEEDERS (%d >= %d) exceeded\n", feedercnt, MAXFEEDERS);
 105 }
 106
 107 static void
 108 feeder_unregisterall(void *p)
 109 {
 110         struct feedertab_entry *fte, *next;
 111
 112         next = SLIST_FIRST(&feedertab);
 113         while (next != NULL) {
 114                 fte = next;
 115                 next = SLIST_NEXT(fte, link);
 116                 free(fte, M_FEEDER);
 117         }
 118 }
 119
 120 static int
 121 cmpdesc(struct pcm_feederdesc *n, struct pcm_feederdesc *m)
 122 {
 123         return ((n->type == m->type) &&
 124                 ((n->in == 0) || (n->in == m->in)) &&
 125                 ((n->out == 0) || (n->out == m->out)) &&
 126                 (n->flags == m->flags));
 127 }
 128
 129 static void
 130 feeder_destroy(struct pcm_feeder *f)
 131 {
 132         FEEDER_FREE(f);
 133         kobj_delete((kobj_t)f, M_FEEDER);
 134 }
 135
 136 static struct pcm_feeder *
 137 feeder_create(struct feeder_class *fc, struct pcm_feederdesc *desc)
 138 {
 139         struct pcm_feeder *f;
 140         int err;
 141
 142         f = (struct pcm_feeder *)kobj_create((kobj_class_t)fc, M_FEEDER, M_WAITOK | M_ZERO);
 143         if (f == NULL)
 144                 return NULL;
 145
 146         f->align = fc->align;
 147         f->data = fc->data;
 148         f->source = NULL;
 149         f->parent = NULL;
 150         f->class = fc;
 151         f->desc = &(f->desc_static);
 152
 153         if (desc) {
 154                 *(f->desc) = *desc;
 155         } else {
 156                 f->desc->type = FEEDER_ROOT;
 157                 f->desc->in = 0;
 158                 f->desc->out = 0;
 159                 f->desc->flags = 0;
 160                 f->desc->idx = 0;
 161         }
 162
 163         err = FEEDER_INIT(f);
 164         if (err) {
 165                 printf("feeder_init(%p) on %s returned %d\n", f, fc->name, err);
 166                 feeder_destroy(f);
 167
 168                 return NULL;
 169         }
 170
 171         return f;
 172 }
 173
 174 struct feeder_class *
 175 feeder_getclass(struct pcm_feederdesc *desc)
 176 {
 177         struct feedertab_entry *fte;
 178
 179         SLIST_FOREACH(fte, &feedertab, link) {
 180                 if ((desc == NULL) && (fte->desc == NULL))
 181                         return fte->feederclass;
 182                 if ((fte->desc != NULL) && (desc != NULL) && cmpdesc(desc, fte->desc))
 183                         return fte->feederclass;
 184         }
 185         return NULL;
 186 }
 187
 188 int
 189 chn_addfeeder(struct pcm_channel *c, struct feeder_class *fc, struct pcm_feederdesc *desc)
 190 {
 191         struct pcm_feeder *nf;
 192
 193         nf = feeder_create(fc, desc);
 194         if (nf == NULL)
 195                 return ENOSPC;
 196
 197         nf->source = c->feeder;
 198
 199         if (nf->align > 0)
 200                 c->align += nf->align;
 201         else if (nf->align < 0 && c->align < -nf->align)
 202                 c->align = -nf->align;
 203
 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         /* printf("trying %s (%x -> %x)...\n", source->class->name, source->desc->in, source->desc->out); */
 269         if (fmtvalid(source->desc->out, to)) {
 270                 /* 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                         goto no;
 280                 if (fte->desc->type != FEEDER_FMT)
 281                         goto no;
 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 no:
 293         }
 294         /* printf("giving up %s...\n", source->class->name); */
 295
 296         return NULL;
 297 }
 298
 299 u_int32_t
 300 chn_fmtchain(struct pcm_channel *c, u_int32_t *to)
 301 {
 302         struct pcm_feeder *try, *del, *stop;
 303         u_int32_t tmpfrom[2], best, *from;
 304         int i, max, bestmax;
 305
 306         KASSERT(c != NULL, ("c == NULL"));
 307         KASSERT(c->feeder != NULL, ("c->feeder == NULL"));
 308         KASSERT(to != NULL, ("to == NULL"));
 309         KASSERT(to[0] != 0, ("to[0] == 0"));
 310
 311         stop = c->feeder;
 312
 313         if (c->direction == PCMDIR_REC && c->feeder->desc->type == FEEDER_ROOT) {
 314                 from = chn_getcaps(c)->fmtlist;
 315         } else {
 316                 tmpfrom[0] = c->feeder->desc->out;
 317                 tmpfrom[1] = 0;
 318                 from = tmpfrom;
 319         }
 320
 321         i = 0;
 322         best = 0;
 323         bestmax = 100;
 324         while (from[i] != 0) {
 325                 c->feeder->desc->out = from[i];
 326                 try = NULL;
 327                 max = 0;
 328                 while (try == NULL && max < 8) {
 329                         try = feeder_fmtchain(to, c->feeder, stop, max);
 330                         if (try == NULL)
 331                                 max++;
 332                 }
 333                 if (try != NULL && max < bestmax) {
 334                         bestmax = max;
 335                         best = from[i];
 336                 }
 337                 while (try != NULL && try != stop) {
 338                         del = try;
 339                         try = try->source;
 340                         feeder_destroy(del);
 341                 }
 342                 i++;
 343         }
 344         if (best == 0)
 345                 return 0;
 346
 347         c->feeder->desc->out = best;
 348         try = feeder_fmtchain(to, c->feeder, stop, bestmax);
 349         if (try == NULL)
 350                 return 0;
 351
 352         c->feeder = try;
 353         c->align = 0;
 354 #ifdef FEEDER_DEBUG
 355         printf("\n\nchain: ");
 356 #endif
 357         while (try && (try != stop)) {
 358 #ifdef FEEDER_DEBUG
 359                 printf("%s [%d]", try->class->name, try->desc->idx);
 360                 if (try->source)
 361                         printf(" -> ");
 362 #endif
 363                 if (try->source)
 364                         try->source->parent = try;
 365                 if (try->align > 0)
 366                         c->align += try->align;
 367                 else if (try->align < 0 && c->align < -try->align)
 368                         c->align = -try->align;
 369                 try = try->source;
 370         }
 371 #ifdef FEEDER_DEBUG
 372         printf("%s [%d]\n", try->class->name, try->desc->idx);
 373 #endif
 374
 375         return (c->direction == PCMDIR_REC)? best : c->feeder->desc->out;
 376 }
 377
 378 /*****************************************************************************/
 379
 380 static int
 381 feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u_int32_t count, void *source)
 382 {
 383         struct snd_dbuf *src = source;
 384         int l;
 385         u_int8_t x;
 386
 387         KASSERT(count > 0, ("feed_root: count == 0"));
 388         /* count &= ~((1 << ch->align) - 1); */
 389         KASSERT(count > 0, ("feed_root: aligned count == 0 (align = %d)", ch->align));
 390
 391         l = min(count, sndbuf_getready(src));
 392         sndbuf_dispose(src, buffer, l);
 393
 394         /* When recording only return as much data as available */
 395         if (ch->direction == PCMDIR_REC)
 396                 return l;
 397
 398 /*
 399         if (l < count)
 400                 printf("appending %d bytes\n", count - l);
 401 */
 402
 403         x = (sndbuf_getfmt(src) & AFMT_SIGNED)? 0 : 0x80;
 404         while (l < count)
 405                 buffer[l++] = x;
 406
 407         return count;
 408 }
 409
 410 static kobj_method_t feeder_root_methods[] = {
 411         KOBJMETHOD(feeder_feed,         feed_root),
 412         { 0, 0 }
 413 };
 414 static struct feeder_class feeder_root_class = {
 415         name:           "feeder_root",
 416         methods:        feeder_root_methods,
 417         size:           sizeof(struct pcm_feeder),
 418         align:          0,
 419         desc:           NULL,
 420         data:           NULL,
 421 };
 422 SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root_class);
 423 SYSUNINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_unregisterall, NULL);
 424
 425
 426
 427
 428