Merge remote branch 'qmp/for-anthony' into staging
[qemu.git] / audio / alsaaudio.c
blobf0171f9842a4476c3cb3aa78fb9c7695b8e5ba5f
1 /*
2 * QEMU ALSA audio driver
4 * Copyright (c) 2005 Vassili Karpov (malc)
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include <alsa/asoundlib.h>
25 #include "qemu-common.h"
26 #include "qemu-char.h"
27 #include "audio.h"
29 #if QEMU_GNUC_PREREQ(4, 3)
30 #pragma GCC diagnostic ignored "-Waddress"
31 #endif
33 #define AUDIO_CAP "alsa"
34 #include "audio_int.h"
36 struct pollhlp {
37 snd_pcm_t *handle;
38 struct pollfd *pfds;
39 int count;
40 int mask;
43 typedef struct ALSAVoiceOut {
44 HWVoiceOut hw;
45 int wpos;
46 int pending;
47 void *pcm_buf;
48 snd_pcm_t *handle;
49 struct pollhlp pollhlp;
50 } ALSAVoiceOut;
52 typedef struct ALSAVoiceIn {
53 HWVoiceIn hw;
54 snd_pcm_t *handle;
55 void *pcm_buf;
56 struct pollhlp pollhlp;
57 } ALSAVoiceIn;
59 static struct {
60 int size_in_usec_in;
61 int size_in_usec_out;
62 const char *pcm_name_in;
63 const char *pcm_name_out;
64 unsigned int buffer_size_in;
65 unsigned int period_size_in;
66 unsigned int buffer_size_out;
67 unsigned int period_size_out;
68 unsigned int threshold;
70 int buffer_size_in_overridden;
71 int period_size_in_overridden;
73 int buffer_size_out_overridden;
74 int period_size_out_overridden;
75 int verbose;
76 } conf = {
77 .buffer_size_out = 4096,
78 .period_size_out = 1024,
79 .pcm_name_out = "default",
80 .pcm_name_in = "default",
83 struct alsa_params_req {
84 int freq;
85 snd_pcm_format_t fmt;
86 int nchannels;
87 int size_in_usec;
88 int override_mask;
89 unsigned int buffer_size;
90 unsigned int period_size;
93 struct alsa_params_obt {
94 int freq;
95 audfmt_e fmt;
96 int endianness;
97 int nchannels;
98 snd_pcm_uframes_t samples;
101 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
103 va_list ap;
105 va_start (ap, fmt);
106 AUD_vlog (AUDIO_CAP, fmt, ap);
107 va_end (ap);
109 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
112 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
113 int err,
114 const char *typ,
115 const char *fmt,
119 va_list ap;
121 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
123 va_start (ap, fmt);
124 AUD_vlog (AUDIO_CAP, fmt, ap);
125 va_end (ap);
127 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
130 static void alsa_fini_poll (struct pollhlp *hlp)
132 int i;
133 struct pollfd *pfds = hlp->pfds;
135 if (pfds) {
136 for (i = 0; i < hlp->count; ++i) {
137 qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
139 qemu_free (pfds);
141 hlp->pfds = NULL;
142 hlp->count = 0;
143 hlp->handle = NULL;
146 static void alsa_anal_close1 (snd_pcm_t **handlep)
148 int err = snd_pcm_close (*handlep);
149 if (err) {
150 alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
152 *handlep = NULL;
155 static void alsa_anal_close (snd_pcm_t **handlep, struct pollhlp *hlp)
157 alsa_fini_poll (hlp);
158 alsa_anal_close1 (handlep);
161 static int alsa_recover (snd_pcm_t *handle)
163 int err = snd_pcm_prepare (handle);
164 if (err < 0) {
165 alsa_logerr (err, "Failed to prepare handle %p\n", handle);
166 return -1;
168 return 0;
171 static int alsa_resume (snd_pcm_t *handle)
173 int err = snd_pcm_resume (handle);
174 if (err < 0) {
175 alsa_logerr (err, "Failed to resume handle %p\n", handle);
176 return -1;
178 return 0;
181 static void alsa_poll_handler (void *opaque)
183 int err, count;
184 snd_pcm_state_t state;
185 struct pollhlp *hlp = opaque;
186 unsigned short revents;
188 count = poll (hlp->pfds, hlp->count, 0);
189 if (count < 0) {
190 dolog ("alsa_poll_handler: poll %s\n", strerror (errno));
191 return;
194 if (!count) {
195 return;
198 /* XXX: ALSA example uses initial count, not the one returned by
199 poll, correct? */
200 err = snd_pcm_poll_descriptors_revents (hlp->handle, hlp->pfds,
201 hlp->count, &revents);
202 if (err < 0) {
203 alsa_logerr (err, "snd_pcm_poll_descriptors_revents");
204 return;
207 if (!(revents & hlp->mask)) {
208 if (conf.verbose) {
209 dolog ("revents = %d\n", revents);
211 return;
214 state = snd_pcm_state (hlp->handle);
215 switch (state) {
216 case SND_PCM_STATE_SETUP:
217 alsa_recover (hlp->handle);
218 break;
220 case SND_PCM_STATE_XRUN:
221 alsa_recover (hlp->handle);
222 break;
224 case SND_PCM_STATE_SUSPENDED:
225 alsa_resume (hlp->handle);
226 break;
228 case SND_PCM_STATE_PREPARED:
229 audio_run ("alsa run (prepared)");
230 break;
232 case SND_PCM_STATE_RUNNING:
233 audio_run ("alsa run (running)");
234 break;
236 default:
237 dolog ("Unexpected state %d\n", state);
241 static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
243 int i, count, err;
244 struct pollfd *pfds;
246 count = snd_pcm_poll_descriptors_count (handle);
247 if (count <= 0) {
248 dolog ("Could not initialize poll mode\n"
249 "Invalid number of poll descriptors %d\n", count);
250 return -1;
253 pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
254 if (!pfds) {
255 dolog ("Could not initialize poll mode\n");
256 return -1;
259 err = snd_pcm_poll_descriptors (handle, pfds, count);
260 if (err < 0) {
261 alsa_logerr (err, "Could not initialize poll mode\n"
262 "Could not obtain poll descriptors\n");
263 qemu_free (pfds);
264 return -1;
267 for (i = 0; i < count; ++i) {
268 if (pfds[i].events & POLLIN) {
269 err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,
270 NULL, hlp);
272 if (pfds[i].events & POLLOUT) {
273 if (conf.verbose) {
274 dolog ("POLLOUT %d %d\n", i, pfds[i].fd);
276 err = qemu_set_fd_handler (pfds[i].fd, NULL,
277 alsa_poll_handler, hlp);
279 if (conf.verbose) {
280 dolog ("Set handler events=%#x index=%d fd=%d err=%d\n",
281 pfds[i].events, i, pfds[i].fd, err);
284 if (err) {
285 dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n",
286 pfds[i].events, i, pfds[i].fd, err);
288 while (i--) {
289 qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
291 qemu_free (pfds);
292 return -1;
295 hlp->pfds = pfds;
296 hlp->count = count;
297 hlp->handle = handle;
298 hlp->mask = mask;
299 return 0;
302 static int alsa_poll_out (HWVoiceOut *hw)
304 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
306 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLOUT);
309 static int alsa_poll_in (HWVoiceIn *hw)
311 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
313 return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);
316 static int alsa_write (SWVoiceOut *sw, void *buf, int len)
318 return audio_pcm_sw_write (sw, buf, len);
321 static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt)
323 switch (fmt) {
324 case AUD_FMT_S8:
325 return SND_PCM_FORMAT_S8;
327 case AUD_FMT_U8:
328 return SND_PCM_FORMAT_U8;
330 case AUD_FMT_S16:
331 return SND_PCM_FORMAT_S16_LE;
333 case AUD_FMT_U16:
334 return SND_PCM_FORMAT_U16_LE;
336 case AUD_FMT_S32:
337 return SND_PCM_FORMAT_S32_LE;
339 case AUD_FMT_U32:
340 return SND_PCM_FORMAT_U32_LE;
342 default:
343 dolog ("Internal logic error: Bad audio format %d\n", fmt);
344 #ifdef DEBUG_AUDIO
345 abort ();
346 #endif
347 return SND_PCM_FORMAT_U8;
351 static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
352 int *endianness)
354 switch (alsafmt) {
355 case SND_PCM_FORMAT_S8:
356 *endianness = 0;
357 *fmt = AUD_FMT_S8;
358 break;
360 case SND_PCM_FORMAT_U8:
361 *endianness = 0;
362 *fmt = AUD_FMT_U8;
363 break;
365 case SND_PCM_FORMAT_S16_LE:
366 *endianness = 0;
367 *fmt = AUD_FMT_S16;
368 break;
370 case SND_PCM_FORMAT_U16_LE:
371 *endianness = 0;
372 *fmt = AUD_FMT_U16;
373 break;
375 case SND_PCM_FORMAT_S16_BE:
376 *endianness = 1;
377 *fmt = AUD_FMT_S16;
378 break;
380 case SND_PCM_FORMAT_U16_BE:
381 *endianness = 1;
382 *fmt = AUD_FMT_U16;
383 break;
385 case SND_PCM_FORMAT_S32_LE:
386 *endianness = 0;
387 *fmt = AUD_FMT_S32;
388 break;
390 case SND_PCM_FORMAT_U32_LE:
391 *endianness = 0;
392 *fmt = AUD_FMT_U32;
393 break;
395 case SND_PCM_FORMAT_S32_BE:
396 *endianness = 1;
397 *fmt = AUD_FMT_S32;
398 break;
400 case SND_PCM_FORMAT_U32_BE:
401 *endianness = 1;
402 *fmt = AUD_FMT_U32;
403 break;
405 default:
406 dolog ("Unrecognized audio format %d\n", alsafmt);
407 return -1;
410 return 0;
413 static void alsa_dump_info (struct alsa_params_req *req,
414 struct alsa_params_obt *obt,
415 snd_pcm_format_t obtfmt)
417 dolog ("parameter | requested value | obtained value\n");
418 dolog ("format | %10d | %10d\n", req->fmt, obtfmt);
419 dolog ("channels | %10d | %10d\n",
420 req->nchannels, obt->nchannels);
421 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
422 dolog ("============================================\n");
423 dolog ("requested: buffer size %d period size %d\n",
424 req->buffer_size, req->period_size);
425 dolog ("obtained: samples %ld\n", obt->samples);
428 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
430 int err;
431 snd_pcm_sw_params_t *sw_params;
433 snd_pcm_sw_params_alloca (&sw_params);
435 err = snd_pcm_sw_params_current (handle, sw_params);
436 if (err < 0) {
437 dolog ("Could not fully initialize DAC\n");
438 alsa_logerr (err, "Failed to get current software parameters\n");
439 return;
442 err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
443 if (err < 0) {
444 dolog ("Could not fully initialize DAC\n");
445 alsa_logerr (err, "Failed to set software threshold to %ld\n",
446 threshold);
447 return;
450 err = snd_pcm_sw_params (handle, sw_params);
451 if (err < 0) {
452 dolog ("Could not fully initialize DAC\n");
453 alsa_logerr (err, "Failed to set software parameters\n");
454 return;
458 static int alsa_open (int in, struct alsa_params_req *req,
459 struct alsa_params_obt *obt, snd_pcm_t **handlep)
461 snd_pcm_t *handle;
462 snd_pcm_hw_params_t *hw_params;
463 int err;
464 int size_in_usec;
465 unsigned int freq, nchannels;
466 const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;
467 snd_pcm_uframes_t obt_buffer_size;
468 const char *typ = in ? "ADC" : "DAC";
469 snd_pcm_format_t obtfmt;
471 freq = req->freq;
472 nchannels = req->nchannels;
473 size_in_usec = req->size_in_usec;
475 snd_pcm_hw_params_alloca (&hw_params);
477 err = snd_pcm_open (
478 &handle,
479 pcm_name,
480 in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
481 SND_PCM_NONBLOCK
483 if (err < 0) {
484 alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
485 return -1;
488 err = snd_pcm_hw_params_any (handle, hw_params);
489 if (err < 0) {
490 alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
491 goto err;
494 err = snd_pcm_hw_params_set_access (
495 handle,
496 hw_params,
497 SND_PCM_ACCESS_RW_INTERLEAVED
499 if (err < 0) {
500 alsa_logerr2 (err, typ, "Failed to set access type\n");
501 goto err;
504 err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
505 if (err < 0 && conf.verbose) {
506 alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
509 err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
510 if (err < 0) {
511 alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
512 goto err;
515 err = snd_pcm_hw_params_set_channels_near (
516 handle,
517 hw_params,
518 &nchannels
520 if (err < 0) {
521 alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
522 req->nchannels);
523 goto err;
526 if (nchannels != 1 && nchannels != 2) {
527 alsa_logerr2 (err, typ,
528 "Can not handle obtained number of channels %d\n",
529 nchannels);
530 goto err;
533 if (req->buffer_size) {
534 unsigned long obt;
536 if (size_in_usec) {
537 int dir = 0;
538 unsigned int btime = req->buffer_size;
540 err = snd_pcm_hw_params_set_buffer_time_near (
541 handle,
542 hw_params,
543 &btime,
544 &dir
546 obt = btime;
548 else {
549 snd_pcm_uframes_t bsize = req->buffer_size;
551 err = snd_pcm_hw_params_set_buffer_size_near (
552 handle,
553 hw_params,
554 &bsize
556 obt = bsize;
558 if (err < 0) {
559 alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
560 size_in_usec ? "time" : "size", req->buffer_size);
561 goto err;
564 if ((req->override_mask & 2) && (obt - req->buffer_size))
565 dolog ("Requested buffer %s %u was rejected, using %lu\n",
566 size_in_usec ? "time" : "size", req->buffer_size, obt);
569 if (req->period_size) {
570 unsigned long obt;
572 if (size_in_usec) {
573 int dir = 0;
574 unsigned int ptime = req->period_size;
576 err = snd_pcm_hw_params_set_period_time_near (
577 handle,
578 hw_params,
579 &ptime,
580 &dir
582 obt = ptime;
584 else {
585 int dir = 0;
586 snd_pcm_uframes_t psize = req->period_size;
588 err = snd_pcm_hw_params_set_period_size_near (
589 handle,
590 hw_params,
591 &psize,
592 &dir
594 obt = psize;
597 if (err < 0) {
598 alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
599 size_in_usec ? "time" : "size", req->period_size);
600 goto err;
603 if (((req->override_mask & 1) && (obt - req->period_size)))
604 dolog ("Requested period %s %u was rejected, using %lu\n",
605 size_in_usec ? "time" : "size", req->period_size, obt);
608 err = snd_pcm_hw_params (handle, hw_params);
609 if (err < 0) {
610 alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
611 goto err;
614 err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
615 if (err < 0) {
616 alsa_logerr2 (err, typ, "Failed to get buffer size\n");
617 goto err;
620 err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
621 if (err < 0) {
622 alsa_logerr2 (err, typ, "Failed to get format\n");
623 goto err;
626 if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
627 dolog ("Invalid format was returned %d\n", obtfmt);
628 goto err;
631 err = snd_pcm_prepare (handle);
632 if (err < 0) {
633 alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
634 goto err;
637 if (!in && conf.threshold) {
638 snd_pcm_uframes_t threshold;
639 int bytes_per_sec;
641 bytes_per_sec = freq << (nchannels == 2);
643 switch (obt->fmt) {
644 case AUD_FMT_S8:
645 case AUD_FMT_U8:
646 break;
648 case AUD_FMT_S16:
649 case AUD_FMT_U16:
650 bytes_per_sec <<= 1;
651 break;
653 case AUD_FMT_S32:
654 case AUD_FMT_U32:
655 bytes_per_sec <<= 2;
656 break;
659 threshold = (conf.threshold * bytes_per_sec) / 1000;
660 alsa_set_threshold (handle, threshold);
663 obt->nchannels = nchannels;
664 obt->freq = freq;
665 obt->samples = obt_buffer_size;
667 *handlep = handle;
669 if (conf.verbose &&
670 (obtfmt != req->fmt ||
671 obt->nchannels != req->nchannels ||
672 obt->freq != req->freq)) {
673 dolog ("Audio parameters for %s\n", typ);
674 alsa_dump_info (req, obt, obtfmt);
677 #ifdef DEBUG
678 alsa_dump_info (req, obt, obtfmt);
679 #endif
680 return 0;
682 err:
683 alsa_anal_close1 (&handle);
684 return -1;
687 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
689 snd_pcm_sframes_t avail;
691 avail = snd_pcm_avail_update (handle);
692 if (avail < 0) {
693 if (avail == -EPIPE) {
694 if (!alsa_recover (handle)) {
695 avail = snd_pcm_avail_update (handle);
699 if (avail < 0) {
700 alsa_logerr (avail,
701 "Could not obtain number of available frames\n");
702 return -1;
706 return avail;
709 static void alsa_write_pending (ALSAVoiceOut *alsa)
711 HWVoiceOut *hw = &alsa->hw;
713 while (alsa->pending) {
714 int left_till_end_samples = hw->samples - alsa->wpos;
715 int len = audio_MIN (alsa->pending, left_till_end_samples);
716 char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);
718 while (len) {
719 snd_pcm_sframes_t written;
721 written = snd_pcm_writei (alsa->handle, src, len);
723 if (written <= 0) {
724 switch (written) {
725 case 0:
726 if (conf.verbose) {
727 dolog ("Failed to write %d frames (wrote zero)\n", len);
729 return;
731 case -EPIPE:
732 if (alsa_recover (alsa->handle)) {
733 alsa_logerr (written, "Failed to write %d frames\n",
734 len);
735 return;
737 if (conf.verbose) {
738 dolog ("Recovering from playback xrun\n");
740 continue;
742 case -ESTRPIPE:
743 /* stream is suspended and waiting for an
744 application recovery */
745 if (alsa_resume (alsa->handle)) {
746 alsa_logerr (written, "Failed to write %d frames\n",
747 len);
748 return;
750 if (conf.verbose) {
751 dolog ("Resuming suspended output stream\n");
753 continue;
755 case -EAGAIN:
756 return;
758 default:
759 alsa_logerr (written, "Failed to write %d frames from %p\n",
760 len, src);
761 return;
765 alsa->wpos = (alsa->wpos + written) % hw->samples;
766 alsa->pending -= written;
767 len -= written;
772 static int alsa_run_out (HWVoiceOut *hw, int live)
774 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
775 int decr;
776 snd_pcm_sframes_t avail;
778 avail = alsa_get_avail (alsa->handle);
779 if (avail < 0) {
780 dolog ("Could not get number of available playback frames\n");
781 return 0;
784 decr = audio_MIN (live, avail);
785 decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);
786 alsa->pending += decr;
787 alsa_write_pending (alsa);
788 return decr;
791 static void alsa_fini_out (HWVoiceOut *hw)
793 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
795 ldebug ("alsa_fini\n");
796 alsa_anal_close (&alsa->handle, &alsa->pollhlp);
798 if (alsa->pcm_buf) {
799 qemu_free (alsa->pcm_buf);
800 alsa->pcm_buf = NULL;
804 static int alsa_init_out (HWVoiceOut *hw, struct audsettings *as)
806 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
807 struct alsa_params_req req;
808 struct alsa_params_obt obt;
809 snd_pcm_t *handle;
810 struct audsettings obt_as;
812 req.fmt = aud_to_alsafmt (as->fmt);
813 req.freq = as->freq;
814 req.nchannels = as->nchannels;
815 req.period_size = conf.period_size_out;
816 req.buffer_size = conf.buffer_size_out;
817 req.size_in_usec = conf.size_in_usec_out;
818 req.override_mask =
819 (conf.period_size_out_overridden ? 1 : 0) |
820 (conf.buffer_size_out_overridden ? 2 : 0);
822 if (alsa_open (0, &req, &obt, &handle)) {
823 return -1;
826 obt_as.freq = obt.freq;
827 obt_as.nchannels = obt.nchannels;
828 obt_as.fmt = obt.fmt;
829 obt_as.endianness = obt.endianness;
831 audio_pcm_init_info (&hw->info, &obt_as);
832 hw->samples = obt.samples;
834 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
835 if (!alsa->pcm_buf) {
836 dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
837 hw->samples, 1 << hw->info.shift);
838 alsa_anal_close1 (&handle);
839 return -1;
842 alsa->handle = handle;
843 return 0;
846 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
848 int err;
850 if (pause) {
851 err = snd_pcm_drop (handle);
852 if (err < 0) {
853 alsa_logerr (err, "Could not stop %s\n", typ);
854 return -1;
857 else {
858 err = snd_pcm_prepare (handle);
859 if (err < 0) {
860 alsa_logerr (err, "Could not prepare handle for %s\n", typ);
861 return -1;
865 return 0;
868 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
870 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
872 switch (cmd) {
873 case VOICE_ENABLE:
875 va_list ap;
876 int poll_mode;
878 va_start (ap, cmd);
879 poll_mode = va_arg (ap, int);
880 va_end (ap);
882 ldebug ("enabling voice\n");
883 if (poll_mode && alsa_poll_out (hw)) {
884 poll_mode = 0;
886 hw->poll_mode = poll_mode;
887 return alsa_voice_ctl (alsa->handle, "playback", 0);
890 case VOICE_DISABLE:
891 ldebug ("disabling voice\n");
892 return alsa_voice_ctl (alsa->handle, "playback", 1);
895 return -1;
898 static int alsa_init_in (HWVoiceIn *hw, struct audsettings *as)
900 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
901 struct alsa_params_req req;
902 struct alsa_params_obt obt;
903 snd_pcm_t *handle;
904 struct audsettings obt_as;
906 req.fmt = aud_to_alsafmt (as->fmt);
907 req.freq = as->freq;
908 req.nchannels = as->nchannels;
909 req.period_size = conf.period_size_in;
910 req.buffer_size = conf.buffer_size_in;
911 req.size_in_usec = conf.size_in_usec_in;
912 req.override_mask =
913 (conf.period_size_in_overridden ? 1 : 0) |
914 (conf.buffer_size_in_overridden ? 2 : 0);
916 if (alsa_open (1, &req, &obt, &handle)) {
917 return -1;
920 obt_as.freq = obt.freq;
921 obt_as.nchannels = obt.nchannels;
922 obt_as.fmt = obt.fmt;
923 obt_as.endianness = obt.endianness;
925 audio_pcm_init_info (&hw->info, &obt_as);
926 hw->samples = obt.samples;
928 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
929 if (!alsa->pcm_buf) {
930 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
931 hw->samples, 1 << hw->info.shift);
932 alsa_anal_close1 (&handle);
933 return -1;
936 alsa->handle = handle;
937 return 0;
940 static void alsa_fini_in (HWVoiceIn *hw)
942 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
944 alsa_anal_close (&alsa->handle, &alsa->pollhlp);
946 if (alsa->pcm_buf) {
947 qemu_free (alsa->pcm_buf);
948 alsa->pcm_buf = NULL;
952 static int alsa_run_in (HWVoiceIn *hw)
954 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
955 int hwshift = hw->info.shift;
956 int i;
957 int live = audio_pcm_hw_get_live_in (hw);
958 int dead = hw->samples - live;
959 int decr;
960 struct {
961 int add;
962 int len;
963 } bufs[2] = {
964 { .add = hw->wpos, .len = 0 },
965 { .add = 0, .len = 0 }
967 snd_pcm_sframes_t avail;
968 snd_pcm_uframes_t read_samples = 0;
970 if (!dead) {
971 return 0;
974 avail = alsa_get_avail (alsa->handle);
975 if (avail < 0) {
976 dolog ("Could not get number of captured frames\n");
977 return 0;
980 if (!avail) {
981 snd_pcm_state_t state;
983 state = snd_pcm_state (alsa->handle);
984 switch (state) {
985 case SND_PCM_STATE_PREPARED:
986 avail = hw->samples;
987 break;
988 case SND_PCM_STATE_SUSPENDED:
989 /* stream is suspended and waiting for an application recovery */
990 if (alsa_resume (alsa->handle)) {
991 dolog ("Failed to resume suspended input stream\n");
992 return 0;
994 if (conf.verbose) {
995 dolog ("Resuming suspended input stream\n");
997 break;
998 default:
999 if (conf.verbose) {
1000 dolog ("No frames available and ALSA state is %d\n", state);
1002 return 0;
1006 decr = audio_MIN (dead, avail);
1007 if (!decr) {
1008 return 0;
1011 if (hw->wpos + decr > hw->samples) {
1012 bufs[0].len = (hw->samples - hw->wpos);
1013 bufs[1].len = (decr - (hw->samples - hw->wpos));
1015 else {
1016 bufs[0].len = decr;
1019 for (i = 0; i < 2; ++i) {
1020 void *src;
1021 struct st_sample *dst;
1022 snd_pcm_sframes_t nread;
1023 snd_pcm_uframes_t len;
1025 len = bufs[i].len;
1027 src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
1028 dst = hw->conv_buf + bufs[i].add;
1030 while (len) {
1031 nread = snd_pcm_readi (alsa->handle, src, len);
1033 if (nread <= 0) {
1034 switch (nread) {
1035 case 0:
1036 if (conf.verbose) {
1037 dolog ("Failed to read %ld frames (read zero)\n", len);
1039 goto exit;
1041 case -EPIPE:
1042 if (alsa_recover (alsa->handle)) {
1043 alsa_logerr (nread, "Failed to read %ld frames\n", len);
1044 goto exit;
1046 if (conf.verbose) {
1047 dolog ("Recovering from capture xrun\n");
1049 continue;
1051 case -EAGAIN:
1052 goto exit;
1054 default:
1055 alsa_logerr (
1056 nread,
1057 "Failed to read %ld frames from %p\n",
1058 len,
1061 goto exit;
1065 hw->conv (dst, src, nread, &nominal_volume);
1067 src = advance (src, nread << hwshift);
1068 dst += nread;
1070 read_samples += nread;
1071 len -= nread;
1075 exit:
1076 hw->wpos = (hw->wpos + read_samples) % hw->samples;
1077 return read_samples;
1080 static int alsa_read (SWVoiceIn *sw, void *buf, int size)
1082 return audio_pcm_sw_read (sw, buf, size);
1085 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
1087 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
1089 switch (cmd) {
1090 case VOICE_ENABLE:
1092 va_list ap;
1093 int poll_mode;
1095 va_start (ap, cmd);
1096 poll_mode = va_arg (ap, int);
1097 va_end (ap);
1099 ldebug ("enabling voice\n");
1100 if (poll_mode && alsa_poll_in (hw)) {
1101 poll_mode = 0;
1103 hw->poll_mode = poll_mode;
1105 return alsa_voice_ctl (alsa->handle, "capture", 0);
1108 case VOICE_DISABLE:
1109 ldebug ("disabling voice\n");
1110 if (hw->poll_mode) {
1111 hw->poll_mode = 0;
1112 alsa_fini_poll (&alsa->pollhlp);
1114 return alsa_voice_ctl (alsa->handle, "capture", 1);
1117 return -1;
1120 static void *alsa_audio_init (void)
1122 return &conf;
1125 static void alsa_audio_fini (void *opaque)
1127 (void) opaque;
1130 static struct audio_option alsa_options[] = {
1132 .name = "DAC_SIZE_IN_USEC",
1133 .tag = AUD_OPT_BOOL,
1134 .valp = &conf.size_in_usec_out,
1135 .descr = "DAC period/buffer size in microseconds (otherwise in frames)"
1138 .name = "DAC_PERIOD_SIZE",
1139 .tag = AUD_OPT_INT,
1140 .valp = &conf.period_size_out,
1141 .descr = "DAC period size (0 to go with system default)",
1142 .overriddenp = &conf.period_size_out_overridden
1145 .name = "DAC_BUFFER_SIZE",
1146 .tag = AUD_OPT_INT,
1147 .valp = &conf.buffer_size_out,
1148 .descr = "DAC buffer size (0 to go with system default)",
1149 .overriddenp = &conf.buffer_size_out_overridden
1152 .name = "ADC_SIZE_IN_USEC",
1153 .tag = AUD_OPT_BOOL,
1154 .valp = &conf.size_in_usec_in,
1155 .descr =
1156 "ADC period/buffer size in microseconds (otherwise in frames)"
1159 .name = "ADC_PERIOD_SIZE",
1160 .tag = AUD_OPT_INT,
1161 .valp = &conf.period_size_in,
1162 .descr = "ADC period size (0 to go with system default)",
1163 .overriddenp = &conf.period_size_in_overridden
1166 .name = "ADC_BUFFER_SIZE",
1167 .tag = AUD_OPT_INT,
1168 .valp = &conf.buffer_size_in,
1169 .descr = "ADC buffer size (0 to go with system default)",
1170 .overriddenp = &conf.buffer_size_in_overridden
1173 .name = "THRESHOLD",
1174 .tag = AUD_OPT_INT,
1175 .valp = &conf.threshold,
1176 .descr = "(undocumented)"
1179 .name = "DAC_DEV",
1180 .tag = AUD_OPT_STR,
1181 .valp = &conf.pcm_name_out,
1182 .descr = "DAC device name (for instance dmix)"
1185 .name = "ADC_DEV",
1186 .tag = AUD_OPT_STR,
1187 .valp = &conf.pcm_name_in,
1188 .descr = "ADC device name"
1191 .name = "VERBOSE",
1192 .tag = AUD_OPT_BOOL,
1193 .valp = &conf.verbose,
1194 .descr = "Behave in a more verbose way"
1196 { /* End of list */ }
1199 static struct audio_pcm_ops alsa_pcm_ops = {
1200 .init_out = alsa_init_out,
1201 .fini_out = alsa_fini_out,
1202 .run_out = alsa_run_out,
1203 .write = alsa_write,
1204 .ctl_out = alsa_ctl_out,
1206 .init_in = alsa_init_in,
1207 .fini_in = alsa_fini_in,
1208 .run_in = alsa_run_in,
1209 .read = alsa_read,
1210 .ctl_in = alsa_ctl_in,
1213 struct audio_driver alsa_audio_driver = {
1214 .name = "alsa",
1215 .descr = "ALSA http://www.alsa-project.org",
1216 .options = alsa_options,
1217 .init = alsa_audio_init,
1218 .fini = alsa_audio_fini,
1219 .pcm_ops = &alsa_pcm_ops,
1220 .can_be_default = 1,
1221 .max_voices_out = INT_MAX,
1222 .max_voices_in = INT_MAX,
1223 .voice_size_out = sizeof (ALSAVoiceOut),
1224 .voice_size_in = sizeof (ALSAVoiceIn)