![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to esdaudio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / audio|
Return to esdaudio.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / audio |
1.1 root 1: /*
2: * QEMU ESD audio driver
3: *
4: * Copyright (c) 2006 Frederick Reeve (brushed up by malc)
5: *
6: * Permission is hereby granted, free of charge, to any person obtaining a copy
7: * of this software and associated documentation files (the "Software"), to deal
8: * in the Software without restriction, including without limitation the rights
9: * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10: * copies of the Software, and to permit persons to whom the Software is
11: * furnished to do so, subject to the following conditions:
12: *
13: * The above copyright notice and this permission notice shall be included in
14: * all copies or substantial portions of the Software.
15: *
16: * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17: * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19: * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20: * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21: * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22: * THE SOFTWARE.
23: */
24: #include <esd.h>
25: #include "qemu-common.h"
26: #include "audio.h"
27: #include <signal.h>
28:
29: #define AUDIO_CAP "esd"
30: #include "audio_int.h"
31: #include "audio_pt_int.h"
32:
33: typedef struct {
34: HWVoiceOut hw;
35: int done;
36: int live;
37: int decr;
38: int rpos;
39: void *pcm_buf;
40: int fd;
41: struct audio_pt pt;
42: } ESDVoiceOut;
43:
44: typedef struct {
45: HWVoiceIn hw;
46: int done;
47: int dead;
48: int incr;
49: int wpos;
50: void *pcm_buf;
51: int fd;
52: struct audio_pt pt;
53: } ESDVoiceIn;
54:
55: static struct {
56: int samples;
57: int divisor;
58: char *dac_host;
59: char *adc_host;
60: } conf = {
61: 1024,
62: 2,
63: NULL,
64: NULL
65: };
66:
67: static void GCC_FMT_ATTR (2, 3) qesd_logerr (int err, const char *fmt, ...)
68: {
69: va_list ap;
70:
71: va_start (ap, fmt);
72: AUD_vlog (AUDIO_CAP, fmt, ap);
73: va_end (ap);
74:
75: AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
76: }
77:
78: /* playback */
79: static void *qesd_thread_out (void *arg)
80: {
81: ESDVoiceOut *esd = arg;
82: HWVoiceOut *hw = &esd->hw;
83: int threshold;
84:
85: threshold = conf.divisor ? hw->samples / conf.divisor : 0;
86:
87: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
88: return NULL;
89: }
90:
91: for (;;) {
92: int decr, to_mix, rpos;
93:
94: for (;;) {
95: if (esd->done) {
96: goto exit;
97: }
98:
99: if (esd->live > threshold) {
100: break;
101: }
102:
103: if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
104: goto exit;
105: }
106: }
107:
108: decr = to_mix = esd->live;
109: rpos = hw->rpos;
110:
111: if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
112: return NULL;
113: }
114:
115: while (to_mix) {
116: ssize_t written;
117: int chunk = audio_MIN (to_mix, hw->samples - rpos);
118: struct st_sample *src = hw->mix_buf + rpos;
119:
120: hw->clip (esd->pcm_buf, src, chunk);
121:
122: again:
123: written = write (esd->fd, esd->pcm_buf, chunk << hw->info.shift);
124: if (written == -1) {
125: if (errno == EINTR || errno == EAGAIN) {
126: goto again;
127: }
128: qesd_logerr (errno, "write failed\n");
129: return NULL;
130: }
131:
132: if (written != chunk << hw->info.shift) {
133: int wsamples = written >> hw->info.shift;
134: int wbytes = wsamples << hw->info.shift;
135: if (wbytes != written) {
136: dolog ("warning: Misaligned write %d (requested %d), "
137: "alignment %d\n",
138: wbytes, written, hw->info.align + 1);
139: }
140: to_mix -= wsamples;
141: rpos = (rpos + wsamples) % hw->samples;
142: break;
143: }
144:
145: rpos = (rpos + chunk) % hw->samples;
146: to_mix -= chunk;
147: }
148:
149: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
150: return NULL;
151: }
152:
153: esd->rpos = rpos;
154: esd->live -= decr;
155: esd->decr += decr;
156: }
157:
158: exit:
159: audio_pt_unlock (&esd->pt, AUDIO_FUNC);
160: return NULL;
161: }
162:
163: static int qesd_run_out (HWVoiceOut *hw)
164: {
165: int live, decr;
166: ESDVoiceOut *esd = (ESDVoiceOut *) hw;
167:
168: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
169: return 0;
170: }
171:
172: live = audio_pcm_hw_get_live_out (hw);
173: decr = audio_MIN (live, esd->decr);
174: esd->decr -= decr;
175: esd->live = live - decr;
176: hw->rpos = esd->rpos;
177: if (esd->live > 0) {
178: audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
179: }
180: else {
181: audio_pt_unlock (&esd->pt, AUDIO_FUNC);
182: }
183: return decr;
184: }
185:
186: static int qesd_write (SWVoiceOut *sw, void *buf, int len)
187: {
188: return audio_pcm_sw_write (sw, buf, len);
189: }
190:
191: static int qesd_init_out (HWVoiceOut *hw, struct audsettings *as)
192: {
193: ESDVoiceOut *esd = (ESDVoiceOut *) hw;
194: struct audsettings obt_as = *as;
195: int esdfmt = ESD_STREAM | ESD_PLAY;
196: int err;
197: sigset_t set, old_set;
198:
199: sigfillset (&set);
200:
201: esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
202: switch (as->fmt) {
203: case AUD_FMT_S8:
204: case AUD_FMT_U8:
205: esdfmt |= ESD_BITS8;
206: obt_as.fmt = AUD_FMT_U8;
207: break;
208:
209: case AUD_FMT_S32:
210: case AUD_FMT_U32:
211: dolog ("Will use 16 instead of 32 bit samples\n");
212:
213: case AUD_FMT_S16:
214: case AUD_FMT_U16:
215: deffmt:
216: esdfmt |= ESD_BITS16;
217: obt_as.fmt = AUD_FMT_S16;
218: break;
219:
220: default:
221: dolog ("Internal logic error: Bad audio format %d\n", as->fmt);
222: goto deffmt;
223:
224: }
225: obt_as.endianness = AUDIO_HOST_ENDIANNESS;
226:
227: audio_pcm_init_info (&hw->info, &obt_as);
228:
229: hw->samples = conf.samples;
230: esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
231: if (!esd->pcm_buf) {
232: dolog ("Could not allocate buffer (%d bytes)\n",
233: hw->samples << hw->info.shift);
234: return -1;
235: }
236:
237: esd->fd = -1;
238: err = pthread_sigmask (SIG_BLOCK, &set, &old_set);
239: if (err) {
240: qesd_logerr (err, "pthread_sigmask failed\n");
241: goto fail1;
242: }
243:
244: esd->fd = esd_play_stream (esdfmt, as->freq, conf.dac_host, NULL);
245: if (esd->fd < 0) {
246: qesd_logerr (errno, "esd_play_stream failed\n");
247: goto fail2;
248: }
249:
250: if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) {
251: goto fail3;
252: }
253:
254: err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);
255: if (err) {
256: qesd_logerr (err, "pthread_sigmask(restore) failed\n");
257: }
258:
259: return 0;
260:
261: fail3:
262: if (close (esd->fd)) {
263: qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
264: AUDIO_FUNC, esd->fd);
265: }
266: esd->fd = -1;
267:
268: fail2:
269: err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);
270: if (err) {
271: qesd_logerr (err, "pthread_sigmask(restore) failed\n");
272: }
273:
274: fail1:
275: qemu_free (esd->pcm_buf);
276: esd->pcm_buf = NULL;
277: return -1;
278: }
279:
280: static void qesd_fini_out (HWVoiceOut *hw)
281: {
282: void *ret;
283: ESDVoiceOut *esd = (ESDVoiceOut *) hw;
284:
285: audio_pt_lock (&esd->pt, AUDIO_FUNC);
286: esd->done = 1;
287: audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
288: audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
289:
290: if (esd->fd >= 0) {
291: if (close (esd->fd)) {
292: qesd_logerr (errno, "failed to close esd socket\n");
293: }
294: esd->fd = -1;
295: }
296:
297: audio_pt_fini (&esd->pt, AUDIO_FUNC);
298:
299: qemu_free (esd->pcm_buf);
300: esd->pcm_buf = NULL;
301: }
302:
303: static int qesd_ctl_out (HWVoiceOut *hw, int cmd, ...)
304: {
305: (void) hw;
306: (void) cmd;
307: return 0;
308: }
309:
310: /* capture */
311: static void *qesd_thread_in (void *arg)
312: {
313: ESDVoiceIn *esd = arg;
314: HWVoiceIn *hw = &esd->hw;
315: int threshold;
316:
317: threshold = conf.divisor ? hw->samples / conf.divisor : 0;
318:
319: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
320: return NULL;
321: }
322:
323: for (;;) {
324: int incr, to_grab, wpos;
325:
326: for (;;) {
327: if (esd->done) {
328: goto exit;
329: }
330:
331: if (esd->dead > threshold) {
332: break;
333: }
334:
335: if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
336: goto exit;
337: }
338: }
339:
340: incr = to_grab = esd->dead;
341: wpos = hw->wpos;
342:
343: if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
344: return NULL;
345: }
346:
347: while (to_grab) {
348: ssize_t nread;
349: int chunk = audio_MIN (to_grab, hw->samples - wpos);
350: void *buf = advance (esd->pcm_buf, wpos);
351:
352: again:
353: nread = read (esd->fd, buf, chunk << hw->info.shift);
354: if (nread == -1) {
355: if (errno == EINTR || errno == EAGAIN) {
356: goto again;
357: }
358: qesd_logerr (errno, "read failed\n");
359: return NULL;
360: }
361:
362: if (nread != chunk << hw->info.shift) {
363: int rsamples = nread >> hw->info.shift;
364: int rbytes = rsamples << hw->info.shift;
365: if (rbytes != nread) {
366: dolog ("warning: Misaligned write %d (requested %d), "
367: "alignment %d\n",
368: rbytes, nread, hw->info.align + 1);
369: }
370: to_grab -= rsamples;
371: wpos = (wpos + rsamples) % hw->samples;
372: break;
373: }
374:
375: hw->conv (hw->conv_buf + wpos, buf, nread >> hw->info.shift,
376: &nominal_volume);
377: wpos = (wpos + chunk) % hw->samples;
378: to_grab -= chunk;
379: }
380:
381: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
382: return NULL;
383: }
384:
385: esd->wpos = wpos;
386: esd->dead -= incr;
387: esd->incr += incr;
388: }
389:
390: exit:
391: audio_pt_unlock (&esd->pt, AUDIO_FUNC);
392: return NULL;
393: }
394:
395: static int qesd_run_in (HWVoiceIn *hw)
396: {
397: int live, incr, dead;
398: ESDVoiceIn *esd = (ESDVoiceIn *) hw;
399:
400: if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
401: return 0;
402: }
403:
404: live = audio_pcm_hw_get_live_in (hw);
405: dead = hw->samples - live;
406: incr = audio_MIN (dead, esd->incr);
407: esd->incr -= incr;
408: esd->dead = dead - incr;
409: hw->wpos = esd->wpos;
410: if (esd->dead > 0) {
411: audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
412: }
413: else {
414: audio_pt_unlock (&esd->pt, AUDIO_FUNC);
415: }
416: return incr;
417: }
418:
419: static int qesd_read (SWVoiceIn *sw, void *buf, int len)
420: {
421: return audio_pcm_sw_read (sw, buf, len);
422: }
423:
424: static int qesd_init_in (HWVoiceIn *hw, struct audsettings *as)
425: {
426: ESDVoiceIn *esd = (ESDVoiceIn *) hw;
427: struct audsettings obt_as = *as;
428: int esdfmt = ESD_STREAM | ESD_RECORD;
429: int err;
430: sigset_t set, old_set;
431:
432: sigfillset (&set);
433:
434: esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
435: switch (as->fmt) {
436: case AUD_FMT_S8:
437: case AUD_FMT_U8:
438: esdfmt |= ESD_BITS8;
439: obt_as.fmt = AUD_FMT_U8;
440: break;
441:
442: case AUD_FMT_S16:
443: case AUD_FMT_U16:
444: esdfmt |= ESD_BITS16;
445: obt_as.fmt = AUD_FMT_S16;
446: break;
447:
448: case AUD_FMT_S32:
449: case AUD_FMT_U32:
450: dolog ("Will use 16 instead of 32 bit samples\n");
451: esdfmt |= ESD_BITS16;
452: obt_as.fmt = AUD_FMT_S16;
453: break;
454: }
455: obt_as.endianness = AUDIO_HOST_ENDIANNESS;
456:
457: audio_pcm_init_info (&hw->info, &obt_as);
458:
459: hw->samples = conf.samples;
460: esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
461: if (!esd->pcm_buf) {
462: dolog ("Could not allocate buffer (%d bytes)\n",
463: hw->samples << hw->info.shift);
464: return -1;
465: }
466:
467: esd->fd = -1;
468:
469: err = pthread_sigmask (SIG_BLOCK, &set, &old_set);
470: if (err) {
471: qesd_logerr (err, "pthread_sigmask failed\n");
472: goto fail1;
473: }
474:
475: esd->fd = esd_record_stream (esdfmt, as->freq, conf.adc_host, NULL);
476: if (esd->fd < 0) {
477: qesd_logerr (errno, "esd_record_stream failed\n");
478: goto fail2;
479: }
480:
481: if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) {
482: goto fail3;
483: }
484:
485: err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);
486: if (err) {
487: qesd_logerr (err, "pthread_sigmask(restore) failed\n");
488: }
489:
490: return 0;
491:
492: fail3:
493: if (close (esd->fd)) {
494: qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
495: AUDIO_FUNC, esd->fd);
496: }
497: esd->fd = -1;
498:
499: fail2:
500: err = pthread_sigmask (SIG_SETMASK, &old_set, NULL);
501: if (err) {
502: qesd_logerr (err, "pthread_sigmask(restore) failed\n");
503: }
504:
505: fail1:
506: qemu_free (esd->pcm_buf);
507: esd->pcm_buf = NULL;
508: return -1;
509: }
510:
511: static void qesd_fini_in (HWVoiceIn *hw)
512: {
513: void *ret;
514: ESDVoiceIn *esd = (ESDVoiceIn *) hw;
515:
516: audio_pt_lock (&esd->pt, AUDIO_FUNC);
517: esd->done = 1;
518: audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
519: audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
520:
521: if (esd->fd >= 0) {
522: if (close (esd->fd)) {
523: qesd_logerr (errno, "failed to close esd socket\n");
524: }
525: esd->fd = -1;
526: }
527:
528: audio_pt_fini (&esd->pt, AUDIO_FUNC);
529:
530: qemu_free (esd->pcm_buf);
531: esd->pcm_buf = NULL;
532: }
533:
534: static int qesd_ctl_in (HWVoiceIn *hw, int cmd, ...)
535: {
536: (void) hw;
537: (void) cmd;
538: return 0;
539: }
540:
541: /* common */
542: static void *qesd_audio_init (void)
543: {
544: return &conf;
545: }
546:
547: static void qesd_audio_fini (void *opaque)
548: {
549: (void) opaque;
550: ldebug ("esd_fini");
551: }
552:
553: struct audio_option qesd_options[] = {
554: {"SAMPLES", AUD_OPT_INT, &conf.samples,
555: "buffer size in samples", NULL, 0},
556:
557: {"DIVISOR", AUD_OPT_INT, &conf.divisor,
558: "threshold divisor", NULL, 0},
559:
560: {"DAC_HOST", AUD_OPT_STR, &conf.dac_host,
561: "playback host", NULL, 0},
562:
563: {"ADC_HOST", AUD_OPT_STR, &conf.adc_host,
564: "capture host", NULL, 0},
565:
566: {NULL, 0, NULL, NULL, NULL, 0}
567: };
568:
569: static struct audio_pcm_ops qesd_pcm_ops = {
570: qesd_init_out,
571: qesd_fini_out,
572: qesd_run_out,
573: qesd_write,
574: qesd_ctl_out,
575:
576: qesd_init_in,
577: qesd_fini_in,
578: qesd_run_in,
579: qesd_read,
580: qesd_ctl_in,
581: };
582:
583: struct audio_driver esd_audio_driver = {
584: INIT_FIELD (name = ) "esd",
585: INIT_FIELD (descr = )
586: "http://en.wikipedia.org/wiki/Esound",
587: INIT_FIELD (options = ) qesd_options,
588: INIT_FIELD (init = ) qesd_audio_init,
589: INIT_FIELD (fini = ) qesd_audio_fini,
590: INIT_FIELD (pcm_ops = ) &qesd_pcm_ops,
591: INIT_FIELD (can_be_default = ) 0,
592: INIT_FIELD (max_voices_out = ) INT_MAX,
593: INIT_FIELD (max_voices_in = ) INT_MAX,
594: INIT_FIELD (voice_size_out = ) sizeof (ESDVoiceOut),
595: INIT_FIELD (voice_size_in = ) sizeof (ESDVoiceIn)
596: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.