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: src/sys/dev/sound/pcm/feeder.c,v 1.32.4.1 2005/01/30 01:00:05 imp Exp $");
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 /* 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 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 u_int32_t
299 chn_fmtchain(struct pcm_channel *c, u_int32_t *to)
300 {
301 struct pcm_feeder *try, *del, *stop;
302 u_int32_t tmpfrom[2], best, *from;
303 int i, max, bestmax;
304
305 KASSERT(c != NULL, ("c == NULL"));
306 KASSERT(c->feeder != NULL, ("c->feeder == NULL"));
307 KASSERT(to != NULL, ("to == NULL"));
308 KASSERT(to[0] != 0, ("to[0] == 0"));
309
310 stop = c->feeder;
311
312 if (c->direction == PCMDIR_REC && c->feeder->desc->type == FEEDER_ROOT) {
313 from = chn_getcaps(c)->fmtlist;
314 } else {
315 tmpfrom[0] = c->feeder->desc->out;
316 tmpfrom[1] = 0;
317 from = tmpfrom;
318 }
319
320 i = 0;
321 best = 0;
322 bestmax = 100;
323 while (from[i] != 0) {
324 c->feeder->desc->out = from[i];
325 try = NULL;
326 max = 0;
327 while (try == NULL && max < 8) {
328 try = feeder_fmtchain(to, c->feeder, stop, max);
329 if (try == NULL)
330 max++;
331 }
332 if (try != NULL && max < bestmax) {
333 bestmax = max;
334 best = from[i];
335 }
336 while (try != NULL && try != stop) {
337 del = try;
338 try = try->source;
339 feeder_destroy(del);
340 }
341 i++;
342 }
343 if (best == 0)
344 return 0;
345
346 c->feeder->desc->out = best;
347 try = feeder_fmtchain(to, c->feeder, stop, bestmax);
348 if (try == NULL)
349 return 0;
350
351 c->feeder = try;
352 c->align = 0;
353 #ifdef FEEDER_DEBUG
354 printf("\n\nchain: ");
355 #endif
356 while (try && (try != stop)) {
357 #ifdef FEEDER_DEBUG
358 printf("%s [%d]", try->class->name, try->desc->idx);
359 if (try->source)
360 printf(" -> ");
361 #endif
362 if (try->source)
363 try->source->parent = try;
364 if (try->align > 0)
365 c->align += try->align;
366 else if (try->align < 0 && c->align < -try->align)
367 c->align = -try->align;
368 try = try->source;
369 }
370 #ifdef FEEDER_DEBUG
371 printf("%s [%d]\n", try->class->name, try->desc->idx);
372 #endif
373
374 return (c->direction == PCMDIR_REC)? best : c->feeder->desc->out;
375 }
376
377 void
378 feeder_printchain(struct pcm_feeder *head)
379 {
380 struct pcm_feeder *f;
381
382 printf("feeder chain (head @%p)\n", head);
383 f = head;
384 while (f != NULL) {
385 printf("%s/%d @ %p\n", f->class->name, f->desc->idx, f);
386 f = f->source;
387 }
388 printf("[end]\n\n");
389 }
390
391 /*****************************************************************************/
392
393 static int
394 feed_root(struct pcm_feeder *feeder, struct pcm_channel *ch, u_int8_t *buffer, u_int32_t count, void *source)
395 {
396 struct snd_dbuf *src = source;
397 int l;
398 u_int8_t x;
399
400 KASSERT(count > 0, ("feed_root: count == 0"));
401 /* count &= ~((1 << ch->align) - 1); */
402 KASSERT(count > 0, ("feed_root: aligned count == 0 (align = %d)", ch->align));
403
404 l = min(count, sndbuf_getready(src));
405 sndbuf_dispose(src, buffer, l);
406
407 /* When recording only return as much data as available */
408 if (ch->direction == PCMDIR_REC)
409 return l;
410
411 /*
412 if (l < count)
413 printf("appending %d bytes\n", count - l);
414 */
415
416 x = (sndbuf_getfmt(src) & AFMT_SIGNED)? 0 : 0x80;
417 while (l < count)
418 buffer[l++] = x;
419
420 return count;
421 }
422
423 static kobj_method_t feeder_root_methods[] = {
424 KOBJMETHOD(feeder_feed, feed_root),
425 { 0, 0 }
426 };
427 static struct feeder_class feeder_root_class = {
428 .name = "feeder_root",
429 .methods = feeder_root_methods,
430 .size = sizeof(struct pcm_feeder),
431 .align = 0,
432 .desc = NULL,
433 .data = NULL,
434 };
435 SYSINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_register, &feeder_root_class);
436 SYSUNINIT(feeder_root, SI_SUB_DRIVERS, SI_ORDER_FIRST, feeder_unregisterall, NULL);
437
438
439
440
441
Cache object: f3bbd72aa981522fbb8a7d83125568e0
|