* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
+
#include "qemu/osdep.h"
#include <alsa/asoundlib.h>
-#include "qemu-common.h"
#include "qemu/main-loop.h"
+#include "qemu/module.h"
#include "audio.h"
#include "trace.h"
#define AUDIO_CAP "alsa"
#include "audio_int.h"
+#define DEBUG_ALSA 0
+
struct pollhlp {
snd_pcm_t *handle;
struct pollfd *pfds;
int count;
int mask;
+ AudioState *s;
};
typedef struct ALSAVoiceOut {
HWVoiceOut hw;
- int wpos;
- int pending;
- void *pcm_buf;
snd_pcm_t *handle;
struct pollhlp pollhlp;
Audiodev *dev;
typedef struct ALSAVoiceIn {
HWVoiceIn hw;
snd_pcm_t *handle;
- void *pcm_buf;
struct pollhlp pollhlp;
Audiodev *dev;
} ALSAVoiceIn;
snd_pcm_uframes_t samples;
};
-static void GCC_FMT_ATTR (2, 3) alsa_logerr (int err, const char *fmt, ...)
+static void G_GNUC_PRINTF (2, 3) alsa_logerr (int err, const char *fmt, ...)
{
va_list ap;
AUD_log (AUDIO_CAP, "Reason: %s\n", snd_strerror (err));
}
-static void GCC_FMT_ATTR (3, 4) alsa_logerr2 (
+static void G_GNUC_PRINTF (3, 4) alsa_logerr2 (
int err,
const char *typ,
const char *fmt,
break;
case SND_PCM_STATE_PREPARED:
- audio_run ("alsa run (prepared)");
+ audio_run(hlp->s, "alsa run (prepared)");
break;
case SND_PCM_STATE_RUNNING:
- audio_run ("alsa run (running)");
+ audio_run(hlp->s, "alsa run (running)");
break;
default:
return -1;
}
- pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
- if (!pfds) {
- dolog ("Could not initialize poll mode\n");
- return -1;
- }
+ pfds = g_new0(struct pollfd, count);
err = snd_pcm_poll_descriptors (handle, pfds, count);
if (err < 0) {
return alsa_poll_helper (alsa->handle, &alsa->pollhlp, POLLIN);
}
-static int alsa_write (SWVoiceOut *sw, void *buf, int len)
-{
- return audio_pcm_sw_write (sw, buf, len);
-}
-
static snd_pcm_format_t aud_to_alsafmt (AudioFormat fmt, int endianness)
{
switch (fmt) {
case AUDIO_FORMAT_S16:
if (endianness) {
return SND_PCM_FORMAT_S16_BE;
- }
- else {
+ } else {
return SND_PCM_FORMAT_S16_LE;
}
case AUDIO_FORMAT_U16:
if (endianness) {
return SND_PCM_FORMAT_U16_BE;
- }
- else {
+ } else {
return SND_PCM_FORMAT_U16_LE;
}
case AUDIO_FORMAT_S32:
if (endianness) {
return SND_PCM_FORMAT_S32_BE;
- }
- else {
+ } else {
return SND_PCM_FORMAT_S32_LE;
}
case AUDIO_FORMAT_U32:
if (endianness) {
return SND_PCM_FORMAT_U32_BE;
- }
- else {
+ } else {
return SND_PCM_FORMAT_U32_LE;
}
+ case AUDIO_FORMAT_F32:
+ if (endianness) {
+ return SND_PCM_FORMAT_FLOAT_BE;
+ } else {
+ return SND_PCM_FORMAT_FLOAT_LE;
+ }
+
default:
dolog ("Internal logic error: Bad audio format %d\n", fmt);
#ifdef DEBUG_AUDIO
*fmt = AUDIO_FORMAT_U32;
break;
+ case SND_PCM_FORMAT_FLOAT_LE:
+ *endianness = 0;
+ *fmt = AUDIO_FORMAT_F32;
+ break;
+
+ case SND_PCM_FORMAT_FLOAT_BE:
+ *endianness = 1;
+ *fmt = AUDIO_FORMAT_F32;
+ break;
+
default:
dolog ("Unrecognized audio format %d\n", alsafmt);
return -1;
snd_pcm_hw_params_t *hw_params;
int err;
unsigned int freq, nchannels;
- const char *pcm_name = apdo->has_dev ? apdo->dev : "default";
+ const char *pcm_name = apdo->dev ?: "default";
snd_pcm_uframes_t obt_buffer_size;
const char *typ = in ? "ADC" : "DAC";
snd_pcm_format_t obtfmt;
goto err;
}
- if (nchannels != 1 && nchannels != 2) {
- alsa_logerr2 (err, typ,
- "Can not handle obtained number of channels %d\n",
- nchannels);
- goto err;
- }
-
if (apdo->buffer_length) {
int dir = 0;
unsigned int btime = apdo->buffer_length;
*handlep = handle;
- if (obtfmt != req->fmt ||
- obt->nchannels != req->nchannels ||
- obt->freq != req->freq) {
+ if (DEBUG_ALSA || obtfmt != req->fmt ||
+ obt->nchannels != req->nchannels || obt->freq != req->freq) {
dolog ("Audio parameters for %s\n", typ);
alsa_dump_info(req, obt, obtfmt, apdo);
}
-#ifdef DEBUG
- alsa_dump_info(req, obt, obtfmt, pdo);
-#endif
return 0;
err:
return -1;
}
-static snd_pcm_sframes_t alsa_get_avail (snd_pcm_t *handle)
+static size_t alsa_buffer_get_free(HWVoiceOut *hw)
{
+ ALSAVoiceOut *alsa = (ALSAVoiceOut *)hw;
snd_pcm_sframes_t avail;
+ size_t alsa_free, generic_free, generic_in_use;
- avail = snd_pcm_avail_update (handle);
+ avail = snd_pcm_avail_update(alsa->handle);
if (avail < 0) {
if (avail == -EPIPE) {
- if (!alsa_recover (handle)) {
- avail = snd_pcm_avail_update (handle);
+ if (!alsa_recover(alsa->handle)) {
+ avail = snd_pcm_avail_update(alsa->handle);
}
}
-
if (avail < 0) {
- alsa_logerr (avail,
- "Could not obtain number of available frames\n");
- return -1;
+ alsa_logerr(avail,
+ "Could not obtain number of available frames\n");
+ avail = 0;
}
}
- return avail;
+ alsa_free = avail * hw->info.bytes_per_frame;
+ generic_free = audio_generic_buffer_get_free(hw);
+ generic_in_use = hw->samples * hw->info.bytes_per_frame - generic_free;
+ if (generic_in_use) {
+ /*
+ * This code can only be reached in the unlikely case that
+ * snd_pcm_avail_update() returned a larger number of frames
+ * than snd_pcm_writei() could write. Make sure that all
+ * remaining bytes in the generic buffer can be written.
+ */
+ alsa_free = alsa_free > generic_in_use ? alsa_free - generic_in_use : 0;
+ }
+
+ return alsa_free;
}
-static void alsa_write_pending (ALSAVoiceOut *alsa)
+static size_t alsa_write(HWVoiceOut *hw, void *buf, size_t len)
{
- HWVoiceOut *hw = &alsa->hw;
-
- while (alsa->pending) {
- int left_till_end_samples = hw->samples - alsa->wpos;
- int len = audio_MIN (alsa->pending, left_till_end_samples);
- char *src = advance (alsa->pcm_buf, alsa->wpos << hw->info.shift);
-
- while (len) {
- snd_pcm_sframes_t written;
-
- written = snd_pcm_writei (alsa->handle, src, len);
-
- if (written <= 0) {
- switch (written) {
- case 0:
- trace_alsa_wrote_zero(len);
- return;
-
- case -EPIPE:
- if (alsa_recover (alsa->handle)) {
- alsa_logerr (written, "Failed to write %d frames\n",
- len);
- return;
- }
- trace_alsa_xrun_out();
- continue;
-
- case -ESTRPIPE:
- /* stream is suspended and waiting for an
- application recovery */
- if (alsa_resume (alsa->handle)) {
- alsa_logerr (written, "Failed to write %d frames\n",
- len);
- return;
- }
- trace_alsa_resume_out();
- continue;
-
- case -EAGAIN:
- return;
-
- default:
- alsa_logerr (written, "Failed to write %d frames from %p\n",
- len, src);
- return;
+ ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
+ size_t pos = 0;
+ size_t len_frames = len / hw->info.bytes_per_frame;
+
+ while (len_frames) {
+ char *src = advance(buf, pos);
+ snd_pcm_sframes_t written;
+
+ written = snd_pcm_writei(alsa->handle, src, len_frames);
+
+ if (written <= 0) {
+ switch (written) {
+ case 0:
+ trace_alsa_wrote_zero(len_frames);
+ return pos;
+
+ case -EPIPE:
+ if (alsa_recover(alsa->handle)) {
+ alsa_logerr(written, "Failed to write %zu frames\n",
+ len_frames);
+ return pos;
}
- }
+ trace_alsa_xrun_out();
+ continue;
+
+ case -ESTRPIPE:
+ /*
+ * stream is suspended and waiting for an application
+ * recovery
+ */
+ if (alsa_resume(alsa->handle)) {
+ alsa_logerr(written, "Failed to write %zu frames\n",
+ len_frames);
+ return pos;
+ }
+ trace_alsa_resume_out();
+ continue;
- alsa->wpos = (alsa->wpos + written) % hw->samples;
- alsa->pending -= written;
- len -= written;
- }
- }
-}
+ case -EAGAIN:
+ return pos;
-static int alsa_run_out (HWVoiceOut *hw, int live)
-{
- ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
- int decr;
- snd_pcm_sframes_t avail;
+ default:
+ alsa_logerr(written, "Failed to write %zu frames from %p\n",
+ len, src);
+ return pos;
+ }
+ }
- avail = alsa_get_avail (alsa->handle);
- if (avail < 0) {
- dolog ("Could not get number of available playback frames\n");
- return 0;
+ pos += written * hw->info.bytes_per_frame;
+ if (written < len_frames) {
+ break;
+ }
+ len_frames -= written;
}
- decr = audio_MIN (live, avail);
- decr = audio_pcm_hw_clip_out (hw, alsa->pcm_buf, decr, alsa->pending);
- alsa->pending += decr;
- alsa_write_pending (alsa);
- return decr;
+ return pos;
}
static void alsa_fini_out (HWVoiceOut *hw)
ldebug ("alsa_fini\n");
alsa_anal_close (&alsa->handle, &alsa->pollhlp);
-
- g_free(alsa->pcm_buf);
- alsa->pcm_buf = NULL;
}
static int alsa_init_out(HWVoiceOut *hw, struct audsettings *as,
audio_pcm_init_info (&hw->info, &obt_as);
hw->samples = obt.samples;
- alsa->pcm_buf = audio_calloc(__func__, obt.samples, 1 << hw->info.shift);
- if (!alsa->pcm_buf) {
- dolog ("Could not allocate DAC buffer (%d samples, each %d bytes)\n",
- hw->samples, 1 << hw->info.shift);
- alsa_anal_close1 (&handle);
- return -1;
- }
-
+ alsa->pollhlp.s = hw->s;
alsa->handle = handle;
alsa->dev = dev;
return 0;
alsa_logerr (err, "Could not stop %s\n", typ);
return -1;
}
- }
- else {
+ } else {
err = snd_pcm_prepare (handle);
if (err < 0) {
alsa_logerr (err, "Could not prepare handle for %s\n", typ);
return 0;
}
-static int alsa_ctl_out (HWVoiceOut *hw, int cmd, ...)
+static void alsa_enable_out(HWVoiceOut *hw, bool enable)
{
ALSAVoiceOut *alsa = (ALSAVoiceOut *) hw;
AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.out;
- switch (cmd) {
- case VOICE_ENABLE:
- {
- bool poll_mode = apdo->try_poll;
+ if (enable) {
+ bool poll_mode = apdo->try_poll;
- ldebug ("enabling voice\n");
- if (poll_mode && alsa_poll_out (hw)) {
- poll_mode = 0;
- }
- hw->poll_mode = poll_mode;
- return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PREPARE);
+ ldebug("enabling voice\n");
+ if (poll_mode && alsa_poll_out(hw)) {
+ poll_mode = 0;
}
-
- case VOICE_DISABLE:
- ldebug ("disabling voice\n");
+ hw->poll_mode = poll_mode;
+ alsa_voice_ctl(alsa->handle, "playback", VOICE_CTL_PREPARE);
+ } else {
+ ldebug("disabling voice\n");
if (hw->poll_mode) {
hw->poll_mode = 0;
- alsa_fini_poll (&alsa->pollhlp);
+ alsa_fini_poll(&alsa->pollhlp);
}
- return alsa_voice_ctl (alsa->handle, "playback", VOICE_CTL_PAUSE);
+ alsa_voice_ctl(alsa->handle, "playback", VOICE_CTL_PAUSE);
}
-
- return -1;
}
static int alsa_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
audio_pcm_init_info (&hw->info, &obt_as);
hw->samples = obt.samples;
- alsa->pcm_buf = audio_calloc(__func__, hw->samples, 1 << hw->info.shift);
- if (!alsa->pcm_buf) {
- dolog ("Could not allocate ADC buffer (%d samples, each %d bytes)\n",
- hw->samples, 1 << hw->info.shift);
- alsa_anal_close1 (&handle);
- return -1;
- }
-
+ alsa->pollhlp.s = hw->s;
alsa->handle = handle;
alsa->dev = dev;
return 0;
ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
alsa_anal_close (&alsa->handle, &alsa->pollhlp);
-
- g_free(alsa->pcm_buf);
- alsa->pcm_buf = NULL;
}
-static int alsa_run_in (HWVoiceIn *hw)
+static size_t alsa_read(HWVoiceIn *hw, void *buf, size_t len)
{
ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
- int hwshift = hw->info.shift;
- int i;
- int live = audio_pcm_hw_get_live_in (hw);
- int dead = hw->samples - live;
- int decr;
- struct {
- int add;
- int len;
- } bufs[2] = {
- { .add = hw->wpos, .len = 0 },
- { .add = 0, .len = 0 }
- };
- snd_pcm_sframes_t avail;
- snd_pcm_uframes_t read_samples = 0;
-
- if (!dead) {
- return 0;
- }
+ size_t pos = 0;
- avail = alsa_get_avail (alsa->handle);
- if (avail < 0) {
- dolog ("Could not get number of captured frames\n");
- return 0;
- }
-
- if (!avail) {
- snd_pcm_state_t state;
-
- state = snd_pcm_state (alsa->handle);
- switch (state) {
- case SND_PCM_STATE_PREPARED:
- avail = hw->samples;
- break;
- case SND_PCM_STATE_SUSPENDED:
- /* stream is suspended and waiting for an application recovery */
- if (alsa_resume (alsa->handle)) {
- dolog ("Failed to resume suspended input stream\n");
- return 0;
- }
- trace_alsa_resume_in();
- break;
- default:
- trace_alsa_no_frames(state);
- return 0;
- }
- }
+ while (len) {
+ void *dst = advance(buf, pos);
+ snd_pcm_sframes_t nread;
- decr = audio_MIN (dead, avail);
- if (!decr) {
- return 0;
- }
+ nread = snd_pcm_readi(
+ alsa->handle, dst, len / hw->info.bytes_per_frame);
- if (hw->wpos + decr > hw->samples) {
- bufs[0].len = (hw->samples - hw->wpos);
- bufs[1].len = (decr - (hw->samples - hw->wpos));
- }
- else {
- bufs[0].len = decr;
- }
+ if (nread <= 0) {
+ switch (nread) {
+ case 0:
+ trace_alsa_read_zero(len);
+ return pos;
- for (i = 0; i < 2; ++i) {
- void *src;
- struct st_sample *dst;
- snd_pcm_sframes_t nread;
- snd_pcm_uframes_t len;
-
- len = bufs[i].len;
-
- src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
- dst = hw->conv_buf + bufs[i].add;
-
- while (len) {
- nread = snd_pcm_readi (alsa->handle, src, len);
-
- if (nread <= 0) {
- switch (nread) {
- case 0:
- trace_alsa_read_zero(len);
- goto exit;
-
- case -EPIPE:
- if (alsa_recover (alsa->handle)) {
- alsa_logerr (nread, "Failed to read %ld frames\n", len);
- goto exit;
- }
- trace_alsa_xrun_in();
- continue;
-
- case -EAGAIN:
- goto exit;
-
- default:
- alsa_logerr (
- nread,
- "Failed to read %ld frames from %p\n",
- len,
- src
- );
- goto exit;
+ case -EPIPE:
+ if (alsa_recover(alsa->handle)) {
+ alsa_logerr(nread, "Failed to read %zu frames\n", len);
+ return pos;
}
- }
-
- hw->conv (dst, src, nread);
+ trace_alsa_xrun_in();
+ continue;
- src = advance (src, nread << hwshift);
- dst += nread;
+ case -EAGAIN:
+ return pos;
- read_samples += nread;
- len -= nread;
+ default:
+ alsa_logerr(nread, "Failed to read %zu frames to %p\n",
+ len, dst);
+ return pos;
+ }
}
- }
- exit:
- hw->wpos = (hw->wpos + read_samples) % hw->samples;
- return read_samples;
-}
+ pos += nread * hw->info.bytes_per_frame;
+ len -= nread * hw->info.bytes_per_frame;
+ }
-static int alsa_read (SWVoiceIn *sw, void *buf, int size)
-{
- return audio_pcm_sw_read (sw, buf, size);
+ return pos;
}
-static int alsa_ctl_in (HWVoiceIn *hw, int cmd, ...)
+static void alsa_enable_in(HWVoiceIn *hw, bool enable)
{
ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
AudiodevAlsaPerDirectionOptions *apdo = alsa->dev->u.alsa.in;
- switch (cmd) {
- case VOICE_ENABLE:
- {
- bool poll_mode = apdo->try_poll;
+ if (enable) {
+ bool poll_mode = apdo->try_poll;
- ldebug ("enabling voice\n");
- if (poll_mode && alsa_poll_in (hw)) {
- poll_mode = 0;
- }
- hw->poll_mode = poll_mode;
-
- return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_START);
+ ldebug("enabling voice\n");
+ if (poll_mode && alsa_poll_in(hw)) {
+ poll_mode = 0;
}
+ hw->poll_mode = poll_mode;
- case VOICE_DISABLE:
+ alsa_voice_ctl(alsa->handle, "capture", VOICE_CTL_START);
+ } else {
ldebug ("disabling voice\n");
if (hw->poll_mode) {
hw->poll_mode = 0;
- alsa_fini_poll (&alsa->pollhlp);
+ alsa_fini_poll(&alsa->pollhlp);
}
- return alsa_voice_ctl (alsa->handle, "capture", VOICE_CTL_PAUSE);
+ alsa_voice_ctl(alsa->handle, "capture", VOICE_CTL_PAUSE);
}
-
- return -1;
}
static void alsa_init_per_direction(AudiodevAlsaPerDirectionOptions *apdo)
}
}
-static void *alsa_audio_init(Audiodev *dev)
+static void *alsa_audio_init(Audiodev *dev, Error **errp)
{
AudiodevAlsaOptions *aopts;
assert(dev->driver == AUDIODEV_DRIVER_ALSA);
alsa_init_per_direction(aopts->in);
alsa_init_per_direction(aopts->out);
- /*
- * need to define them, as otherwise alsa produces no sound
- * doesn't set has_* so alsa_open can identify it wasn't set by the user
- */
+ /* don't set has_* so alsa_open can identify it wasn't set by the user */
if (!dev->u.alsa.out->has_period_length) {
- /* 1024 frames assuming 44100Hz */
- dev->u.alsa.out->period_length = 1024 * 1000000 / 44100;
+ /* 256 frames assuming 44100Hz */
+ dev->u.alsa.out->period_length = 5805;
}
if (!dev->u.alsa.out->has_buffer_length) {
/* 4096 frames assuming 44100Hz */
- dev->u.alsa.out->buffer_length = 4096ll * 1000000 / 44100;
+ dev->u.alsa.out->buffer_length = 92880;
}
- /*
- * OptsVisitor sets unspecified optional fields to zero, but do not depend
- * on it...
- */
if (!dev->u.alsa.in->has_period_length) {
- dev->u.alsa.in->period_length = 0;
+ /* 256 frames assuming 44100Hz */
+ dev->u.alsa.in->period_length = 5805;
}
if (!dev->u.alsa.in->has_buffer_length) {
- dev->u.alsa.in->buffer_length = 0;
+ /* 4096 frames assuming 44100Hz */
+ dev->u.alsa.in->buffer_length = 92880;
}
return dev;
static struct audio_pcm_ops alsa_pcm_ops = {
.init_out = alsa_init_out,
.fini_out = alsa_fini_out,
- .run_out = alsa_run_out,
.write = alsa_write,
- .ctl_out = alsa_ctl_out,
+ .buffer_get_free = alsa_buffer_get_free,
+ .run_buffer_out = audio_generic_run_buffer_out,
+ .enable_out = alsa_enable_out,
.init_in = alsa_init_in,
.fini_in = alsa_fini_in,
- .run_in = alsa_run_in,
.read = alsa_read,
- .ctl_in = alsa_ctl_in,
+ .run_buffer_in = audio_generic_run_buffer_in,
+ .enable_in = alsa_enable_in,
};
static struct audio_driver alsa_audio_driver = {
.init = alsa_audio_init,
.fini = alsa_audio_fini,
.pcm_ops = &alsa_pcm_ops,
- .can_be_default = 1,
.max_voices_out = INT_MAX,
.max_voices_in = INT_MAX,
.voice_size_out = sizeof (ALSAVoiceOut),
projects / mirror_qemu.git / blobdiff