scsi: convert to QEMU Object Model
[qemu.git] / audio / esdaudio.c
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
28 #define AUDIO_CAP "esd"
29 #include "audio_int.h"
30 #include "audio_pt_int.h"
31
32 typedef struct {
33 HWVoiceOut hw;
34 int done;
35 int live;
36 int decr;
37 int rpos;
38 void *pcm_buf;
39 int fd;
40 struct audio_pt pt;
41 } ESDVoiceOut;
42
43 typedef struct {
44 HWVoiceIn hw;
45 int done;
46 int dead;
47 int incr;
48 int wpos;
49 void *pcm_buf;
50 int fd;
51 struct audio_pt pt;
52 } ESDVoiceIn;
53
54 static struct {
55 int samples;
56 int divisor;
57 char *dac_host;
58 char *adc_host;
59 } conf = {
60 .samples = 1024,
61 .divisor = 2,
62 };
63
64 static void GCC_FMT_ATTR (2, 3) qesd_logerr (int err, const char *fmt, ...)
65 {
66 va_list ap;
67
68 va_start (ap, fmt);
69 AUD_vlog (AUDIO_CAP, fmt, ap);
70 va_end (ap);
71
72 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err));
73 }
74
75 /* playback */
76 static void *qesd_thread_out (void *arg)
77 {
78 ESDVoiceOut *esd = arg;
79 HWVoiceOut *hw = &esd->hw;
80 int threshold;
81
82 threshold = conf.divisor ? hw->samples / conf.divisor : 0;
83
84 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
85 return NULL;
86 }
87
88 for (;;) {
89 int decr, to_mix, rpos;
90
91 for (;;) {
92 if (esd->done) {
93 goto exit;
94 }
95
96 if (esd->live > threshold) {
97 break;
98 }
99
100 if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
101 goto exit;
102 }
103 }
104
105 decr = to_mix = esd->live;
106 rpos = hw->rpos;
107
108 if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
109 return NULL;
110 }
111
112 while (to_mix) {
113 ssize_t written;
114 int chunk = audio_MIN (to_mix, hw->samples - rpos);
115 struct st_sample *src = hw->mix_buf + rpos;
116
117 hw->clip (esd->pcm_buf, src, chunk);
118
119 again:
120 written = write (esd->fd, esd->pcm_buf, chunk << hw->info.shift);
121 if (written == -1) {
122 if (errno == EINTR || errno == EAGAIN) {
123 goto again;
124 }
125 qesd_logerr (errno, "write failed\n");
126 return NULL;
127 }
128
129 if (written != chunk << hw->info.shift) {
130 int wsamples = written >> hw->info.shift;
131 int wbytes = wsamples << hw->info.shift;
132 if (wbytes != written) {
133 dolog ("warning: Misaligned write %d (requested %zd), "
134 "alignment %d\n",
135 wbytes, written, hw->info.align + 1);
136 }
137 to_mix -= wsamples;
138 rpos = (rpos + wsamples) % hw->samples;
139 break;
140 }
141
142 rpos = (rpos + chunk) % hw->samples;
143 to_mix -= chunk;
144 }
145
146 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
147 return NULL;
148 }
149
150 esd->rpos = rpos;
151 esd->live -= decr;
152 esd->decr += decr;
153 }
154
155 exit:
156 audio_pt_unlock (&esd->pt, AUDIO_FUNC);
157 return NULL;
158 }
159
160 static int qesd_run_out (HWVoiceOut *hw, int live)
161 {
162 int decr;
163 ESDVoiceOut *esd = (ESDVoiceOut *) hw;
164
165 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
166 return 0;
167 }
168
169 decr = audio_MIN (live, esd->decr);
170 esd->decr -= decr;
171 esd->live = live - decr;
172 hw->rpos = esd->rpos;
173 if (esd->live > 0) {
174 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
175 }
176 else {
177 audio_pt_unlock (&esd->pt, AUDIO_FUNC);
178 }
179 return decr;
180 }
181
182 static int qesd_write (SWVoiceOut *sw, void *buf, int len)
183 {
184 return audio_pcm_sw_write (sw, buf, len);
185 }
186
187 static int qesd_init_out (HWVoiceOut *hw, struct audsettings *as)
188 {
189 ESDVoiceOut *esd = (ESDVoiceOut *) hw;
190 struct audsettings obt_as = *as;
191 int esdfmt = ESD_STREAM | ESD_PLAY;
192
193 esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
194 switch (as->fmt) {
195 case AUD_FMT_S8:
196 case AUD_FMT_U8:
197 esdfmt |= ESD_BITS8;
198 obt_as.fmt = AUD_FMT_U8;
199 break;
200
201 case AUD_FMT_S32:
202 case AUD_FMT_U32:
203 dolog ("Will use 16 instead of 32 bit samples\n");
204
205 case AUD_FMT_S16:
206 case AUD_FMT_U16:
207 deffmt:
208 esdfmt |= ESD_BITS16;
209 obt_as.fmt = AUD_FMT_S16;
210 break;
211
212 default:
213 dolog ("Internal logic error: Bad audio format %d\n", as->fmt);
214 goto deffmt;
215
216 }
217 obt_as.endianness = AUDIO_HOST_ENDIANNESS;
218
219 audio_pcm_init_info (&hw->info, &obt_as);
220
221 hw->samples = conf.samples;
222 esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
223 if (!esd->pcm_buf) {
224 dolog ("Could not allocate buffer (%d bytes)\n",
225 hw->samples << hw->info.shift);
226 return -1;
227 }
228
229 esd->fd = esd_play_stream (esdfmt, as->freq, conf.dac_host, NULL);
230 if (esd->fd < 0) {
231 qesd_logerr (errno, "esd_play_stream failed\n");
232 goto fail1;
233 }
234
235 if (audio_pt_init (&esd->pt, qesd_thread_out, esd, AUDIO_CAP, AUDIO_FUNC)) {
236 goto fail2;
237 }
238
239 return 0;
240
241 fail2:
242 if (close (esd->fd)) {
243 qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
244 AUDIO_FUNC, esd->fd);
245 }
246 esd->fd = -1;
247
248 fail1:
249 g_free (esd->pcm_buf);
250 esd->pcm_buf = NULL;
251 return -1;
252 }
253
254 static void qesd_fini_out (HWVoiceOut *hw)
255 {
256 void *ret;
257 ESDVoiceOut *esd = (ESDVoiceOut *) hw;
258
259 audio_pt_lock (&esd->pt, AUDIO_FUNC);
260 esd->done = 1;
261 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
262 audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
263
264 if (esd->fd >= 0) {
265 if (close (esd->fd)) {
266 qesd_logerr (errno, "failed to close esd socket\n");
267 }
268 esd->fd = -1;
269 }
270
271 audio_pt_fini (&esd->pt, AUDIO_FUNC);
272
273 g_free (esd->pcm_buf);
274 esd->pcm_buf = NULL;
275 }
276
277 static int qesd_ctl_out (HWVoiceOut *hw, int cmd, ...)
278 {
279 (void) hw;
280 (void) cmd;
281 return 0;
282 }
283
284 /* capture */
285 static void *qesd_thread_in (void *arg)
286 {
287 ESDVoiceIn *esd = arg;
288 HWVoiceIn *hw = &esd->hw;
289 int threshold;
290
291 threshold = conf.divisor ? hw->samples / conf.divisor : 0;
292
293 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
294 return NULL;
295 }
296
297 for (;;) {
298 int incr, to_grab, wpos;
299
300 for (;;) {
301 if (esd->done) {
302 goto exit;
303 }
304
305 if (esd->dead > threshold) {
306 break;
307 }
308
309 if (audio_pt_wait (&esd->pt, AUDIO_FUNC)) {
310 goto exit;
311 }
312 }
313
314 incr = to_grab = esd->dead;
315 wpos = hw->wpos;
316
317 if (audio_pt_unlock (&esd->pt, AUDIO_FUNC)) {
318 return NULL;
319 }
320
321 while (to_grab) {
322 ssize_t nread;
323 int chunk = audio_MIN (to_grab, hw->samples - wpos);
324 void *buf = advance (esd->pcm_buf, wpos);
325
326 again:
327 nread = read (esd->fd, buf, chunk << hw->info.shift);
328 if (nread == -1) {
329 if (errno == EINTR || errno == EAGAIN) {
330 goto again;
331 }
332 qesd_logerr (errno, "read failed\n");
333 return NULL;
334 }
335
336 if (nread != chunk << hw->info.shift) {
337 int rsamples = nread >> hw->info.shift;
338 int rbytes = rsamples << hw->info.shift;
339 if (rbytes != nread) {
340 dolog ("warning: Misaligned write %d (requested %zd), "
341 "alignment %d\n",
342 rbytes, nread, hw->info.align + 1);
343 }
344 to_grab -= rsamples;
345 wpos = (wpos + rsamples) % hw->samples;
346 break;
347 }
348
349 hw->conv (hw->conv_buf + wpos, buf, nread >> hw->info.shift);
350 wpos = (wpos + chunk) % hw->samples;
351 to_grab -= chunk;
352 }
353
354 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
355 return NULL;
356 }
357
358 esd->wpos = wpos;
359 esd->dead -= incr;
360 esd->incr += incr;
361 }
362
363 exit:
364 audio_pt_unlock (&esd->pt, AUDIO_FUNC);
365 return NULL;
366 }
367
368 static int qesd_run_in (HWVoiceIn *hw)
369 {
370 int live, incr, dead;
371 ESDVoiceIn *esd = (ESDVoiceIn *) hw;
372
373 if (audio_pt_lock (&esd->pt, AUDIO_FUNC)) {
374 return 0;
375 }
376
377 live = audio_pcm_hw_get_live_in (hw);
378 dead = hw->samples - live;
379 incr = audio_MIN (dead, esd->incr);
380 esd->incr -= incr;
381 esd->dead = dead - incr;
382 hw->wpos = esd->wpos;
383 if (esd->dead > 0) {
384 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
385 }
386 else {
387 audio_pt_unlock (&esd->pt, AUDIO_FUNC);
388 }
389 return incr;
390 }
391
392 static int qesd_read (SWVoiceIn *sw, void *buf, int len)
393 {
394 return audio_pcm_sw_read (sw, buf, len);
395 }
396
397 static int qesd_init_in (HWVoiceIn *hw, struct audsettings *as)
398 {
399 ESDVoiceIn *esd = (ESDVoiceIn *) hw;
400 struct audsettings obt_as = *as;
401 int esdfmt = ESD_STREAM | ESD_RECORD;
402
403 esdfmt |= (as->nchannels == 2) ? ESD_STEREO : ESD_MONO;
404 switch (as->fmt) {
405 case AUD_FMT_S8:
406 case AUD_FMT_U8:
407 esdfmt |= ESD_BITS8;
408 obt_as.fmt = AUD_FMT_U8;
409 break;
410
411 case AUD_FMT_S16:
412 case AUD_FMT_U16:
413 esdfmt |= ESD_BITS16;
414 obt_as.fmt = AUD_FMT_S16;
415 break;
416
417 case AUD_FMT_S32:
418 case AUD_FMT_U32:
419 dolog ("Will use 16 instead of 32 bit samples\n");
420 esdfmt |= ESD_BITS16;
421 obt_as.fmt = AUD_FMT_S16;
422 break;
423 }
424 obt_as.endianness = AUDIO_HOST_ENDIANNESS;
425
426 audio_pcm_init_info (&hw->info, &obt_as);
427
428 hw->samples = conf.samples;
429 esd->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
430 if (!esd->pcm_buf) {
431 dolog ("Could not allocate buffer (%d bytes)\n",
432 hw->samples << hw->info.shift);
433 return -1;
434 }
435
436 esd->fd = esd_record_stream (esdfmt, as->freq, conf.adc_host, NULL);
437 if (esd->fd < 0) {
438 qesd_logerr (errno, "esd_record_stream failed\n");
439 goto fail1;
440 }
441
442 if (audio_pt_init (&esd->pt, qesd_thread_in, esd, AUDIO_CAP, AUDIO_FUNC)) {
443 goto fail2;
444 }
445
446 return 0;
447
448 fail2:
449 if (close (esd->fd)) {
450 qesd_logerr (errno, "%s: close on esd socket(%d) failed\n",
451 AUDIO_FUNC, esd->fd);
452 }
453 esd->fd = -1;
454
455 fail1:
456 g_free (esd->pcm_buf);
457 esd->pcm_buf = NULL;
458 return -1;
459 }
460
461 static void qesd_fini_in (HWVoiceIn *hw)
462 {
463 void *ret;
464 ESDVoiceIn *esd = (ESDVoiceIn *) hw;
465
466 audio_pt_lock (&esd->pt, AUDIO_FUNC);
467 esd->done = 1;
468 audio_pt_unlock_and_signal (&esd->pt, AUDIO_FUNC);
469 audio_pt_join (&esd->pt, &ret, AUDIO_FUNC);
470
471 if (esd->fd >= 0) {
472 if (close (esd->fd)) {
473 qesd_logerr (errno, "failed to close esd socket\n");
474 }
475 esd->fd = -1;
476 }
477
478 audio_pt_fini (&esd->pt, AUDIO_FUNC);
479
480 g_free (esd->pcm_buf);
481 esd->pcm_buf = NULL;
482 }
483
484 static int qesd_ctl_in (HWVoiceIn *hw, int cmd, ...)
485 {
486 (void) hw;
487 (void) cmd;
488 return 0;
489 }
490
491 /* common */
492 static void *qesd_audio_init (void)
493 {
494 return &conf;
495 }
496
497 static void qesd_audio_fini (void *opaque)
498 {
499 (void) opaque;
500 ldebug ("esd_fini");
501 }
502
503 struct audio_option qesd_options[] = {
504 {
505 .name = "SAMPLES",
506 .tag = AUD_OPT_INT,
507 .valp = &conf.samples,
508 .descr = "buffer size in samples"
509 },
510 {
511 .name = "DIVISOR",
512 .tag = AUD_OPT_INT,
513 .valp = &conf.divisor,
514 .descr = "threshold divisor"
515 },
516 {
517 .name = "DAC_HOST",
518 .tag = AUD_OPT_STR,
519 .valp = &conf.dac_host,
520 .descr = "playback host"
521 },
522 {
523 .name = "ADC_HOST",
524 .tag = AUD_OPT_STR,
525 .valp = &conf.adc_host,
526 .descr = "capture host"
527 },
528 { /* End of list */ }
529 };
530
531 static struct audio_pcm_ops qesd_pcm_ops = {
532 .init_out = qesd_init_out,
533 .fini_out = qesd_fini_out,
534 .run_out = qesd_run_out,
535 .write = qesd_write,
536 .ctl_out = qesd_ctl_out,
537
538 .init_in = qesd_init_in,
539 .fini_in = qesd_fini_in,
540 .run_in = qesd_run_in,
541 .read = qesd_read,
542 .ctl_in = qesd_ctl_in,
543 };
544
545 struct audio_driver esd_audio_driver = {
546 .name = "esd",
547 .descr = "http://en.wikipedia.org/wiki/Esound",
548 .options = qesd_options,
549 .init = qesd_audio_init,
550 .fini = qesd_audio_fini,
551 .pcm_ops = &qesd_pcm_ops,
552 .can_be_default = 0,
553 .max_voices_out = INT_MAX,
554 .max_voices_in = INT_MAX,
555 .voice_size_out = sizeof (ESDVoiceOut),
556 .voice_size_in = sizeof (ESDVoiceIn)
557 };