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
24 #include <alsa/asoundlib.h>
25 #include "qemu-common.h"
28 #define AUDIO_CAP "alsa"
29 #include "audio_int.h"
31 typedef struct ALSAVoiceOut {
37 typedef struct ALSAVoiceIn {
46 const char *pcm_name_in;
47 const char *pcm_name_out;
48 unsigned int buffer_size_in;
49 unsigned int period_size_in;
50 unsigned int buffer_size_out;
51 unsigned int period_size_out;
52 unsigned int threshold;
54 int buffer_size_in_overridden;
55 int period_size_in_overridden;
57 int buffer_size_out_overridden;
58 int period_size_out_overridden;
61 .pcm_name_out = "default",
62 .pcm_name_in = "default",
65 struct alsa_params_req {
70 unsigned int buffer_size;
71 unsigned int period_size;
74 struct alsa_params_obt {
79 snd_pcm_uframes_t samples;
82 static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
87 AUD_vlog (AUDIO_CAP, fmt, ap);
90 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
93 static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
102 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ);
105 AUD_vlog (AUDIO_CAP, fmt, ap);
108 AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
111 static void alsa_anal_close (snd_pcm_t **handlep)
113 int err = snd_pcm_close (*handlep);
115 alsa_logerr (err, "Failed to close PCM handle %p\n", *handlep);
120 static int alsa_write (SWVoiceOut *sw, void *buf, int len)
122 return audio_pcm_sw_write (sw, buf, len);
125 static snd_pcm_format_t aud_to_alsafmt (audfmt_e fmt)
129 return SND_PCM_FORMAT_S8;
132 return SND_PCM_FORMAT_U8;
135 return SND_PCM_FORMAT_S16_LE;
138 return SND_PCM_FORMAT_U16_LE;
141 return SND_PCM_FORMAT_S32_LE;
144 return SND_PCM_FORMAT_U32_LE;
147 dolog ("Internal logic error: Bad audio format %d\n", fmt);
151 return SND_PCM_FORMAT_U8;
155 static int alsa_to_audfmt (snd_pcm_format_t alsafmt, audfmt_e *fmt,
159 case SND_PCM_FORMAT_S8:
164 case SND_PCM_FORMAT_U8:
169 case SND_PCM_FORMAT_S16_LE:
174 case SND_PCM_FORMAT_U16_LE:
179 case SND_PCM_FORMAT_S16_BE:
184 case SND_PCM_FORMAT_U16_BE:
189 case SND_PCM_FORMAT_S32_LE:
194 case SND_PCM_FORMAT_U32_LE:
199 case SND_PCM_FORMAT_S32_BE:
204 case SND_PCM_FORMAT_U32_BE:
210 dolog ("Unrecognized audio format %d\n", alsafmt);
217 static void alsa_dump_info (struct alsa_params_req *req,
218 struct alsa_params_obt *obt)
220 dolog ("parameter | requested value | obtained value\n");
221 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt);
222 dolog ("channels | %10d | %10d\n",
223 req->nchannels, obt->nchannels);
224 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq);
225 dolog ("============================================\n");
226 dolog ("requested: buffer size %d period size %d\n",
227 req->buffer_size, req->period_size);
228 dolog ("obtained: samples %ld\n", obt->samples);
231 static void alsa_set_threshold (snd_pcm_t *handle, snd_pcm_uframes_t threshold)
234 snd_pcm_sw_params_t *sw_params;
236 snd_pcm_sw_params_alloca (&sw_params);
238 err = snd_pcm_sw_params_current (handle, sw_params);
240 dolog ("Could not fully initialize DAC\n");
241 alsa_logerr (err, "Failed to get current software parameters\n");
245 err = snd_pcm_sw_params_set_start_threshold (handle, sw_params, threshold);
247 dolog ("Could not fully initialize DAC\n");
248 alsa_logerr (err, "Failed to set software threshold to %ld\n",
253 err = snd_pcm_sw_params (handle, sw_params);
255 dolog ("Could not fully initialize DAC\n");
256 alsa_logerr (err, "Failed to set software parameters\n");
261 static int alsa_open (int in, struct alsa_params_req *req,
262 struct alsa_params_obt *obt, snd_pcm_t **handlep)
265 snd_pcm_hw_params_t *hw_params;
268 unsigned int freq, nchannels;
269 const char *pcm_name = in ? conf.pcm_name_in : conf.pcm_name_out;
270 snd_pcm_uframes_t obt_buffer_size;
271 const char *typ = in ? "ADC" : "DAC";
272 snd_pcm_format_t obtfmt;
275 nchannels = req->nchannels;
276 size_in_usec = req->size_in_usec;
278 snd_pcm_hw_params_alloca (&hw_params);
283 in ? SND_PCM_STREAM_CAPTURE : SND_PCM_STREAM_PLAYBACK,
287 alsa_logerr2 (err, typ, "Failed to open `%s':\n", pcm_name);
291 err = snd_pcm_hw_params_any (handle, hw_params);
293 alsa_logerr2 (err, typ, "Failed to initialize hardware parameters\n");
297 err = snd_pcm_hw_params_set_access (
300 SND_PCM_ACCESS_RW_INTERLEAVED
303 alsa_logerr2 (err, typ, "Failed to set access type\n");
307 err = snd_pcm_hw_params_set_format (handle, hw_params, req->fmt);
308 if (err < 0 && conf.verbose) {
309 alsa_logerr2 (err, typ, "Failed to set format %d\n", req->fmt);
312 err = snd_pcm_hw_params_set_rate_near (handle, hw_params, &freq, 0);
314 alsa_logerr2 (err, typ, "Failed to set frequency %d\n", req->freq);
318 err = snd_pcm_hw_params_set_channels_near (
324 alsa_logerr2 (err, typ, "Failed to set number of channels %d\n",
329 if (nchannels != 1 && nchannels != 2) {
330 alsa_logerr2 (err, typ,
331 "Can not handle obtained number of channels %d\n",
336 if (req->buffer_size) {
341 unsigned int btime = req->buffer_size;
343 err = snd_pcm_hw_params_set_buffer_time_near (
352 snd_pcm_uframes_t bsize = req->buffer_size;
354 err = snd_pcm_hw_params_set_buffer_size_near (
362 alsa_logerr2 (err, typ, "Failed to set buffer %s to %d\n",
363 size_in_usec ? "time" : "size", req->buffer_size);
367 if (obt - req->buffer_size)
368 dolog ("Requested buffer %s %u was rejected, using %lu\n",
369 size_in_usec ? "time" : "size", req->buffer_size, obt);
372 if (req->period_size) {
377 unsigned int ptime = req->period_size;
379 err = snd_pcm_hw_params_set_period_time_near (
388 snd_pcm_uframes_t psize = req->period_size;
390 err = snd_pcm_hw_params_set_buffer_size_near (
399 alsa_logerr2 (err, typ, "Failed to set period %s to %d\n",
400 size_in_usec ? "time" : "size", req->period_size);
404 if (obt - req->period_size)
405 dolog ("Requested period %s %u was rejected, using %lu\n",
406 size_in_usec ? "time" : "size", req->period_size, obt);
409 err = snd_pcm_hw_params (handle, hw_params);
411 alsa_logerr2 (err, typ, "Failed to apply audio parameters\n");
415 err = snd_pcm_hw_params_get_buffer_size (hw_params, &obt_buffer_size);
417 alsa_logerr2 (err, typ, "Failed to get buffer size\n");
421 err = snd_pcm_hw_params_get_format (hw_params, &obtfmt);
423 alsa_logerr2 (err, typ, "Failed to get format\n");
427 if (alsa_to_audfmt (obtfmt, &obt->fmt, &obt->endianness)) {
428 dolog ("Invalid format was returned %d\n", obtfmt);
432 err = snd_pcm_prepare (handle);
434 alsa_logerr2 (err, typ, "Could not prepare handle %p\n", handle);
438 if (!in && conf.threshold) {
439 snd_pcm_uframes_t threshold;
442 bytes_per_sec = freq << (nchannels == 2);
460 threshold = (conf.threshold * bytes_per_sec) / 1000;
461 alsa_set_threshold (handle, threshold);
464 obt->nchannels = nchannels;
466 obt->samples = obt_buffer_size;
471 (obt->fmt != req->fmt ||
472 obt->nchannels != req->nchannels ||
473 obt->freq != req->freq)) {
474 dolog ("Audio paramters for %s\n", typ);
475 alsa_dump_info (req, obt);
479 alsa_dump_info (req, obt);
484 alsa_anal_close (&handle);
488 static int alsa_recover (snd_pcm_t *handle)
490 int err = snd_pcm_prepare (handle);
492 alsa_logerr (err, "Failed to prepare handle %p\n", handle);
498 static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
500 snd_pcm_sframes_t avail;
502 avail = snd_pcm_avail_update (handle);
504 if (avail == -EPIPE) {
505 if (!alsa_recover (handle)) {
506 avail = snd_pcm_avail_update (handle);
512 "Could not obtain number of available frames\n");
520 static int alsa_run_out (HWVoiceOut *hw)
522 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
523 int rpos, live, decr;
527 snd_pcm_sframes_t avail;
529 live = audio_pcm_hw_get_live_out (hw);
534 avail = alsa_get_avail (alsa->handle);
536 dolog ("Could not get number of available playback frames\n");
540 decr = audio_MIN (live, avail);
544 int left_till_end_samples = hw->samples - rpos;
545 int len = audio_MIN (samples, left_till_end_samples);
546 snd_pcm_sframes_t written;
548 src = hw->mix_buf + rpos;
549 dst = advance (alsa->pcm_buf, rpos << hw->info.shift);
551 hw->clip (dst, src, len);
554 written = snd_pcm_writei (alsa->handle, dst, len);
560 dolog ("Failed to write %d frames (wrote zero)\n", len);
565 if (alsa_recover (alsa->handle)) {
566 alsa_logerr (written, "Failed to write %d frames\n",
571 dolog ("Recovering from playback xrun\n");
579 alsa_logerr (written, "Failed to write %d frames to %p\n",
585 rpos = (rpos + written) % hw->samples;
588 dst = advance (dst, written << hw->info.shift);
598 static void alsa_fini_out (HWVoiceOut *hw)
600 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
602 ldebug ("alsa_fini\n");
603 alsa_anal_close (&alsa->handle);
606 qemu_free (alsa->pcm_buf);
607 alsa->pcm_buf = NULL;
611 static int alsa_init_out (HWVoiceOut *hw, audsettings_t *as)
613 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
614 struct alsa_params_req req;
615 struct alsa_params_obt obt;
617 audsettings_t obt_as;
619 req.fmt = aud_to_alsafmt (as->fmt);
621 req.nchannels = as->nchannels;
622 req.period_size = conf.period_size_out;
623 req.buffer_size = conf.buffer_size_out;
624 req.size_in_usec = conf.size_in_usec_in;
626 if (alsa_open (0, &req, &obt, &handle)) {
630 obt_as.freq = obt.freq;
631 obt_as.nchannels = obt.nchannels;
632 obt_as.fmt = obt.fmt;
633 obt_as.endianness = obt.endianness;
635 audio_pcm_init_info (&hw->info, &obt_as);
636 hw->samples = obt.samples;
638 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, obt.samples, 1 << hw->info.shift);
639 if (!alsa->pcm_buf) {
640 dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
641 hw->samples, 1 << hw->info.shift);
642 alsa_anal_close (&handle);
646 alsa->handle = handle;
650 static int alsa_voice_ctl (snd_pcm_t *handle, const char *typ, int pause)
655 err = snd_pcm_drop (handle);
657 alsa_logerr (err, "Could not stop %s\n", typ);
662 err = snd_pcm_prepare (handle);
664 alsa_logerr (err, "Could not prepare handle for %s\n", typ);
672 static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
674 ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
678 ldebug ("enabling voice\n");
679 return alsa_voice_ctl (alsa->handle, "playback", 0);
682 ldebug ("disabling voice\n");
683 return alsa_voice_ctl (alsa->handle, "playback", 1);
689 static int alsa_init_in (HWVoiceIn *hw, audsettings_t *as)
691 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
692 struct alsa_params_req req;
693 struct alsa_params_obt obt;
695 audsettings_t obt_as;
697 req.fmt = aud_to_alsafmt (as->fmt);
699 req.nchannels = as->nchannels;
700 req.period_size = conf.period_size_in;
701 req.buffer_size = conf.buffer_size_in;
702 req.size_in_usec = conf.size_in_usec_in;
704 if (alsa_open (1, &req, &obt, &handle)) {
708 obt_as.freq = obt.freq;
709 obt_as.nchannels = obt.nchannels;
710 obt_as.fmt = obt.fmt;
711 obt_as.endianness = obt.endianness;
713 audio_pcm_init_info (&hw->info, &obt_as);
714 hw->samples = obt.samples;
716 alsa->pcm_buf = audio_calloc (AUDIO_FUNC, hw->samples, 1 << hw->info.shift);
717 if (!alsa->pcm_buf) {
718 dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
719 hw->samples, 1 << hw->info.shift);
720 alsa_anal_close (&handle);
724 alsa->handle = handle;
728 static void alsa_fini_in (HWVoiceIn *hw)
730 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
732 alsa_anal_close (&alsa->handle);
735 qemu_free (alsa->pcm_buf);
736 alsa->pcm_buf = NULL;
740 static int alsa_run_in (HWVoiceIn *hw)
742 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
743 int hwshift = hw->info.shift;
745 int live = audio_pcm_hw_get_live_in (hw);
746 int dead = hw->samples - live;
755 snd_pcm_sframes_t avail;
756 snd_pcm_uframes_t read_samples = 0;
762 avail = alsa_get_avail (alsa->handle);
764 dolog ("Could not get number of captured frames\n");
768 if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
772 decr = audio_MIN (dead, avail);
777 if (hw->wpos + decr > hw->samples) {
778 bufs[0].len = (hw->samples - hw->wpos);
779 bufs[1].len = (decr - (hw->samples - hw->wpos));
785 for (i = 0; i < 2; ++i) {
788 snd_pcm_sframes_t nread;
789 snd_pcm_uframes_t len;
793 src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
794 dst = hw->conv_buf + bufs[i].add;
797 nread = snd_pcm_readi (alsa->handle, src, len);
803 dolog ("Failed to read %ld frames (read zero)\n", len);
808 if (alsa_recover (alsa->handle)) {
809 alsa_logerr (nread, "Failed to read %ld frames\n", len);
813 dolog ("Recovering from capture xrun\n");
823 "Failed to read %ld frames from %p\n",
831 hw->conv (dst, src, nread, &nominal_volume);
833 src = advance (src, nread << hwshift);
836 read_samples += nread;
842 hw->wpos = (hw->wpos + read_samples) % hw->samples;
846 static int alsa_read (SWVoiceIn *sw, void *buf, int size)
848 return audio_pcm_sw_read (sw, buf, size);
851 static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
853 ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
857 ldebug ("enabling voice\n");
858 return alsa_voice_ctl (alsa->handle, "capture", 0);
861 ldebug ("disabling voice\n");
862 return alsa_voice_ctl (alsa->handle, "capture", 1);
868 static void *alsa_audio_init (void)
873 static void alsa_audio_fini (void *opaque)
878 static struct audio_option alsa_options[] = {
879 {"DAC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_out,
880 "DAC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
881 {"DAC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_out,
882 "DAC period size (0 to go with system default)",
883 &conf.period_size_out_overridden, 0},
884 {"DAC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_out,
885 "DAC buffer size (0 to go with system default)",
886 &conf.buffer_size_out_overridden, 0},
888 {"ADC_SIZE_IN_USEC", AUD_OPT_BOOL, &conf.size_in_usec_in,
889 "ADC period/buffer size in microseconds (otherwise in frames)", NULL, 0},
890 {"ADC_PERIOD_SIZE", AUD_OPT_INT, &conf.period_size_in,
891 "ADC period size (0 to go with system default)",
892 &conf.period_size_in_overridden, 0},
893 {"ADC_BUFFER_SIZE", AUD_OPT_INT, &conf.buffer_size_in,
894 "ADC buffer size (0 to go with system default)",
895 &conf.buffer_size_in_overridden, 0},
897 {"THRESHOLD", AUD_OPT_INT, &conf.threshold,
898 "(undocumented)", NULL, 0},
900 {"DAC_DEV", AUD_OPT_STR, &conf.pcm_name_out,
901 "DAC device name (for instance dmix)", NULL, 0},
903 {"ADC_DEV", AUD_OPT_STR, &conf.pcm_name_in,
904 "ADC device name", NULL, 0},
906 {"VERBOSE", AUD_OPT_BOOL, &conf.verbose,
907 "Behave in a more verbose way", NULL, 0},
909 {NULL, 0, NULL, NULL, NULL, 0}
912 static struct audio_pcm_ops alsa_pcm_ops = {
926 struct audio_driver alsa_audio_driver = {
927 INIT_FIELD (name = ) "alsa",
928 INIT_FIELD (descr = ) "ALSA http://www.alsa-project.org",
929 INIT_FIELD (options = ) alsa_options,
930 INIT_FIELD (init = ) alsa_audio_init,
931 INIT_FIELD (fini = ) alsa_audio_fini,
932 INIT_FIELD (pcm_ops = ) &alsa_pcm_ops,
933 INIT_FIELD (can_be_default = ) 1,
934 INIT_FIELD (max_voices_out = ) INT_MAX,
935 INIT_FIELD (max_voices_in = ) INT_MAX,
936 INIT_FIELD (voice_size_out = ) sizeof (ALSAVoiceOut),
937 INIT_FIELD (voice_size_in = ) sizeof (ALSAVoiceIn)