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