* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
+
#include "qemu/osdep.h"
#include <SDL.h>
#include <SDL_thread.h>
-#include "qemu-common.h"
+#include "qemu/module.h"
+#include "qapi/error.h"
#include "audio.h"
#ifndef _WIN32
typedef struct SDLVoiceOut {
HWVoiceOut hw;
- int live;
- int decr;
+ int exit;
+ int initialized;
+ Audiodev *dev;
+ SDL_AudioDeviceID devid;
} SDLVoiceOut;
-static struct SDLAudioState {
+typedef struct SDLVoiceIn {
+ HWVoiceIn hw;
int exit;
int initialized;
- bool driver_created;
Audiodev *dev;
-} glob_sdl;
-typedef struct SDLAudioState SDLAudioState;
+ SDL_AudioDeviceID devid;
+} SDLVoiceIn;
-static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
+static void G_GNUC_PRINTF (1, 2) sdl_logerr (const char *fmt, ...)
{
va_list ap;
case AUDIO_FORMAT_U16:
return AUDIO_U16LSB;
+ case AUDIO_FORMAT_S32:
+ return AUDIO_S32LSB;
+
+ /* no unsigned 32-bit support in SDL */
+
+ case AUDIO_FORMAT_F32:
+ return AUDIO_F32LSB;
+
default:
dolog ("Internal logic error: Bad audio format %d\n", fmt);
#ifdef DEBUG_AUDIO
*fmt = AUDIO_FORMAT_U16;
break;
+ case AUDIO_S32LSB:
+ *endianness = 0;
+ *fmt = AUDIO_FORMAT_S32;
+ break;
+
+ case AUDIO_S32MSB:
+ *endianness = 1;
+ *fmt = AUDIO_FORMAT_S32;
+ break;
+
+ case AUDIO_F32LSB:
+ *endianness = 0;
+ *fmt = AUDIO_FORMAT_F32;
+ break;
+
+ case AUDIO_F32MSB:
+ *endianness = 1;
+ *fmt = AUDIO_FORMAT_F32;
+ break;
+
default:
dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
return -1;
return 0;
}
-static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
+static SDL_AudioDeviceID sdl_open(SDL_AudioSpec *req, SDL_AudioSpec *obt,
+ int rec)
{
- int status;
+ SDL_AudioDeviceID devid;
#ifndef _WIN32
int err;
sigset_t new, old;
err = sigfillset (&new);
if (err) {
dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
- return -1;
+ return 0;
}
err = pthread_sigmask (SIG_BLOCK, &new, &old);
if (err) {
dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
- return -1;
+ return 0;
}
#endif
- status = SDL_OpenAudio (req, obt);
- if (status) {
- sdl_logerr ("SDL_OpenAudio failed\n");
+ devid = SDL_OpenAudioDevice(NULL, rec, req, obt, 0);
+ if (!devid) {
+ sdl_logerr("SDL_OpenAudioDevice for %s failed\n",
+ rec ? "recording" : "playback");
}
#ifndef _WIN32
exit (EXIT_FAILURE);
}
#endif
- return status;
+ return devid;
}
-static void sdl_close (SDLAudioState *s)
+static void sdl_close_out(SDLVoiceOut *sdl)
{
- if (s->initialized) {
- SDL_LockAudio();
- s->exit = 1;
- SDL_UnlockAudio();
- SDL_PauseAudio (1);
- SDL_CloseAudio ();
- s->initialized = 0;
+ if (sdl->initialized) {
+ SDL_LockAudioDevice(sdl->devid);
+ sdl->exit = 1;
+ SDL_UnlockAudioDevice(sdl->devid);
+ SDL_PauseAudioDevice(sdl->devid, 1);
+ sdl->initialized = 0;
+ }
+ if (sdl->devid) {
+ SDL_CloseAudioDevice(sdl->devid);
+ sdl->devid = 0;
}
}
-static void sdl_callback (void *opaque, Uint8 *buf, int len)
+static void sdl_callback_out(void *opaque, Uint8 *buf, int len)
{
SDLVoiceOut *sdl = opaque;
- SDLAudioState *s = &glob_sdl;
HWVoiceOut *hw = &sdl->hw;
- int samples = len >> hw->info.shift;
- int to_mix, decr;
- if (s->exit || !sdl->live) {
- return;
- }
+ if (!sdl->exit) {
- /* dolog ("in callback samples=%d live=%d\n", samples, sdl->live); */
+ /* dolog("callback_out: len=%d avail=%zu\n", len, hw->pending_emul); */
- to_mix = audio_MIN(samples, sdl->live);
- decr = to_mix;
- while (to_mix) {
- int chunk = audio_MIN(to_mix, hw->samples - hw->rpos);
- struct st_sample *src = hw->mix_buf + hw->rpos;
+ while (hw->pending_emul && len) {
+ size_t write_len, start;
- /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
- hw->clip(buf, src, chunk);
- hw->rpos = (hw->rpos + chunk) % hw->samples;
- to_mix -= chunk;
- buf += chunk << hw->info.shift;
- }
- samples -= decr;
- sdl->live -= decr;
- sdl->decr += decr;
+ start = audio_ring_posb(hw->pos_emul, hw->pending_emul,
+ hw->size_emul);
+ assert(start < hw->size_emul);
- /* dolog ("done len=%d\n", len); */
+ write_len = MIN(MIN(hw->pending_emul, len),
+ hw->size_emul - start);
+
+ memcpy(buf, hw->buf_emul + start, write_len);
+ hw->pending_emul -= write_len;
+ len -= write_len;
+ buf += write_len;
+ }
+ }
- /* SDL2 does not clear the remaining buffer for us, so do it on our own */
- if (samples) {
- memset(buf, 0, samples << hw->info.shift);
+ /* clear remaining buffer that we couldn't fill with data */
+ if (len) {
+ audio_pcm_info_clear_buf(&hw->info, buf,
+ len / hw->info.bytes_per_frame);
}
}
-static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
+static void sdl_close_in(SDLVoiceIn *sdl)
{
- return audio_pcm_sw_write (sw, buf, len);
+ if (sdl->initialized) {
+ SDL_LockAudioDevice(sdl->devid);
+ sdl->exit = 1;
+ SDL_UnlockAudioDevice(sdl->devid);
+ SDL_PauseAudioDevice(sdl->devid, 1);
+ sdl->initialized = 0;
+ }
+ if (sdl->devid) {
+ SDL_CloseAudioDevice(sdl->devid);
+ sdl->devid = 0;
+ }
}
-static int sdl_run_out (HWVoiceOut *hw, int live)
+static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
{
- int decr;
- SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
-
- SDL_LockAudio();
+ SDLVoiceIn *sdl = opaque;
+ HWVoiceIn *hw = &sdl->hw;
- if (sdl->decr > live) {
- ldebug ("sdl->decr %d live %d sdl->live %d\n",
- sdl->decr,
- live,
- sdl->live);
+ if (sdl->exit) {
+ return;
}
- decr = audio_MIN (sdl->decr, live);
- sdl->decr -= decr;
+ /* dolog("callback_in: len=%d pending=%zu\n", len, hw->pending_emul); */
- sdl->live = live;
+ while (hw->pending_emul < hw->size_emul && len) {
+ size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
+ hw->size_emul - hw->pending_emul));
- SDL_UnlockAudio();
+ memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
- return decr;
+ hw->pending_emul += read_len;
+ hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
+ len -= read_len;
+ buf += read_len;
+ }
}
-static void sdl_fini_out (HWVoiceOut *hw)
+#define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
+ static ret_type glue(sdl_, name)args_decl \
+ { \
+ ret_type ret; \
+ glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
+ \
+ SDL_LockAudioDevice(sdl->devid); \
+ ret = glue(audio_generic_, name)args; \
+ SDL_UnlockAudioDevice(sdl->devid); \
+ \
+ return ret; \
+ }
+
+#define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir) \
+ static void glue(sdl_, name)args_decl \
+ { \
+ glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw; \
+ \
+ SDL_LockAudioDevice(sdl->devid); \
+ glue(audio_generic_, name)args; \
+ SDL_UnlockAudioDevice(sdl->devid); \
+ }
+
+SDL_WRAPPER_FUNC(buffer_get_free, size_t, (HWVoiceOut *hw), (hw), Out)
+SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
+ (hw, size), Out)
+SDL_WRAPPER_FUNC(put_buffer_out, size_t,
+ (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
+SDL_WRAPPER_FUNC(write, size_t,
+ (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
+SDL_WRAPPER_FUNC(read, size_t, (HWVoiceIn *hw, void *buf, size_t size),
+ (hw, buf, size), In)
+SDL_WRAPPER_FUNC(get_buffer_in, void *, (HWVoiceIn *hw, size_t *size),
+ (hw, size), In)
+SDL_WRAPPER_VOID_FUNC(put_buffer_in, (HWVoiceIn *hw, void *buf, size_t size),
+ (hw, buf, size), In)
+#undef SDL_WRAPPER_FUNC
+#undef SDL_WRAPPER_VOID_FUNC
+
+static void sdl_fini_out(HWVoiceOut *hw)
{
- (void) hw;
+ SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
- sdl_close (&glob_sdl);
+ sdl_close_out(sdl);
}
static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
void *drv_opaque)
{
- SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
- SDLAudioState *s = &glob_sdl;
+ SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
SDL_AudioSpec req, obt;
int endianness;
int err;
AudioFormat effective_fmt;
+ Audiodev *dev = drv_opaque;
+ AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.out;
struct audsettings obt_as;
req.freq = as->freq;
req.format = aud_to_sdlfmt (as->fmt);
req.channels = as->nchannels;
- req.samples = audio_buffer_samples(s->dev->u.sdl.out, as, 11610);
- req.callback = sdl_callback;
+ /* SDL samples are QEMU frames */
+ req.samples = audio_buffer_frames(
+ qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
+ req.callback = sdl_callback_out;
req.userdata = sdl;
- if (sdl_open (&req, &obt)) {
+ sdl->dev = dev;
+ sdl->devid = sdl_open(&req, &obt, 0);
+ if (!sdl->devid) {
return -1;
}
err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
if (err) {
- sdl_close (s);
+ sdl_close_out(sdl);
return -1;
}
obt_as.endianness = endianness;
audio_pcm_init_info (&hw->info, &obt_as);
- hw->samples = obt.samples;
+ hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
+ obt.samples;
- s->initialized = 1;
- s->exit = 0;
- SDL_PauseAudio (0);
+ sdl->initialized = 1;
+ sdl->exit = 0;
return 0;
}
-static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
+static void sdl_enable_out(HWVoiceOut *hw, bool enable)
{
- (void) hw;
+ SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
- switch (cmd) {
- case VOICE_ENABLE:
- SDL_PauseAudio (0);
- break;
+ SDL_PauseAudioDevice(sdl->devid, !enable);
+}
- case VOICE_DISABLE:
- SDL_PauseAudio (1);
- break;
+static void sdl_fini_in(HWVoiceIn *hw)
+{
+ SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
+
+ sdl_close_in(sdl);
+}
+
+static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
+{
+ SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
+ SDL_AudioSpec req, obt;
+ int endianness;
+ int err;
+ AudioFormat effective_fmt;
+ Audiodev *dev = drv_opaque;
+ AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
+ struct audsettings obt_as;
+
+ req.freq = as->freq;
+ req.format = aud_to_sdlfmt(as->fmt);
+ req.channels = as->nchannels;
+ /* SDL samples are QEMU frames */
+ req.samples = audio_buffer_frames(
+ qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
+ req.callback = sdl_callback_in;
+ req.userdata = sdl;
+
+ sdl->dev = dev;
+ sdl->devid = sdl_open(&req, &obt, 1);
+ if (!sdl->devid) {
+ return -1;
}
+
+ err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
+ if (err) {
+ sdl_close_in(sdl);
+ return -1;
+ }
+
+ obt_as.freq = obt.freq;
+ obt_as.nchannels = obt.channels;
+ obt_as.fmt = effective_fmt;
+ obt_as.endianness = endianness;
+
+ audio_pcm_init_info(&hw->info, &obt_as);
+ hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
+ obt.samples;
+ hw->size_emul = hw->samples * hw->info.bytes_per_frame;
+ hw->buf_emul = g_malloc(hw->size_emul);
+ hw->pos_emul = hw->pending_emul = 0;
+
+ sdl->initialized = 1;
+ sdl->exit = 0;
return 0;
}
-static void *sdl_audio_init(Audiodev *dev)
+static void sdl_enable_in(HWVoiceIn *hw, bool enable)
{
- SDLAudioState *s = &glob_sdl;
- if (s->driver_created) {
- sdl_logerr("Can't create multiple sdl backends\n");
- return NULL;
- }
+ SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
+
+ SDL_PauseAudioDevice(sdl->devid, !enable);
+}
+static void *sdl_audio_init(Audiodev *dev, Error **errp)
+{
if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
- sdl_logerr ("SDL failed to initialize audio subsystem\n");
+ error_setg(errp, "SDL failed to initialize audio subsystem");
return NULL;
}
- s->driver_created = true;
- s->dev = dev;
- return s;
+ return dev;
}
static void sdl_audio_fini (void *opaque)
{
- SDLAudioState *s = opaque;
- sdl_close (s);
SDL_QuitSubSystem (SDL_INIT_AUDIO);
- s->driver_created = false;
- s->dev = NULL;
}
static struct audio_pcm_ops sdl_pcm_ops = {
.init_out = sdl_init_out,
.fini_out = sdl_fini_out,
- .run_out = sdl_run_out,
- .write = sdl_write_out,
- .ctl_out = sdl_ctl_out,
+ /* wrapper for audio_generic_write */
+ .write = sdl_write,
+ /* wrapper for audio_generic_buffer_get_free */
+ .buffer_get_free = sdl_buffer_get_free,
+ /* wrapper for audio_generic_get_buffer_out */
+ .get_buffer_out = sdl_get_buffer_out,
+ /* wrapper for audio_generic_put_buffer_out */
+ .put_buffer_out = sdl_put_buffer_out,
+ .enable_out = sdl_enable_out,
+ .init_in = sdl_init_in,
+ .fini_in = sdl_fini_in,
+ /* wrapper for audio_generic_read */
+ .read = sdl_read,
+ /* wrapper for audio_generic_get_buffer_in */
+ .get_buffer_in = sdl_get_buffer_in,
+ /* wrapper for audio_generic_put_buffer_in */
+ .put_buffer_in = sdl_put_buffer_in,
+ .enable_in = sdl_enable_in,
};
static struct audio_driver sdl_audio_driver = {
.fini = sdl_audio_fini,
.pcm_ops = &sdl_pcm_ops,
.can_be_default = 1,
- .max_voices_out = 1,
- .max_voices_in = 0,
- .voice_size_out = sizeof (SDLVoiceOut),
- .voice_size_in = 0
+ .max_voices_out = INT_MAX,
+ .max_voices_in = INT_MAX,
+ .voice_size_out = sizeof(SDLVoiceOut),
+ .voice_size_in = sizeof(SDLVoiceIn),
};
static void register_audio_sdl(void)
projects / mirror_qemu.git / blobdiff