/* * QEMU SDL audio driver * * Copyright (c) 2004-2005 Vassili Karpov (malc) * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include <SDL.h> #include <SDL_thread.h> #include "qemu-common.h" #include "audio.h" #ifndef _WIN32 #ifdef __sun__ #define _POSIX_PTHREAD_SEMANTICS 1 #elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) #include <pthread.h> #endif #include <signal.h> #endif #define AUDIO_CAP "sdl" #include "audio_int.h" typedef struct SDLVoiceOut { HWVoiceOut hw; int live; int decr; int pending; } SDLVoiceOut; static struct { int nb_samples; } conf = { .nb_samples = 1024 }; static struct SDLAudioState { int exit; SDL_mutex *mutex; SDL_sem *sem; int initialized; } glob_sdl; typedef struct SDLAudioState SDLAudioState; static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...) { va_list ap; va_start (ap, fmt); AUD_vlog (AUDIO_CAP, fmt, ap); va_end (ap); AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ()); } static int sdl_lock (SDLAudioState *s, const char *forfn) { if (SDL_LockMutex (s->mutex)) { sdl_logerr ("SDL_LockMutex for %s failed\n", forfn); return -1; } return 0; } static int sdl_unlock (SDLAudioState *s, const char *forfn) { if (SDL_UnlockMutex (s->mutex)) { sdl_logerr ("SDL_UnlockMutex for %s failed\n", forfn); return -1; } return 0; } static int sdl_post (SDLAudioState *s, const char *forfn) { if (SDL_SemPost (s->sem)) { sdl_logerr ("SDL_SemPost for %s failed\n", forfn); return -1; } return 0; } static int sdl_wait (SDLAudioState *s, const char *forfn) { if (SDL_SemWait (s->sem)) { sdl_logerr ("SDL_SemWait for %s failed\n", forfn); return -1; } return 0; } static int sdl_unlock_and_post (SDLAudioState *s, const char *forfn) { if (sdl_unlock (s, forfn)) { return -1; } return sdl_post (s, forfn); } static int aud_to_sdlfmt (audfmt_e fmt, int *shift) { switch (fmt) { case AUD_FMT_S8: *shift = 0; return AUDIO_S8; case AUD_FMT_U8: *shift = 0; return AUDIO_U8; case AUD_FMT_S16: *shift = 1; return AUDIO_S16LSB; case AUD_FMT_U16: *shift = 1; return AUDIO_U16LSB; default: dolog ("Internal logic error: Bad audio format %d\n", fmt); #ifdef DEBUG_AUDIO abort (); #endif return AUDIO_U8; } } static int sdl_to_audfmt (int sdlfmt, audfmt_e *fmt, int *endianess) { switch (sdlfmt) { case AUDIO_S8: *endianess = 0; *fmt = AUD_FMT_S8; break; case AUDIO_U8: *endianess = 0; *fmt = AUD_FMT_U8; break; case AUDIO_S16LSB: *endianess = 0; *fmt = AUD_FMT_S16; break; case AUDIO_U16LSB: *endianess = 0; *fmt = AUD_FMT_U16; break; case AUDIO_S16MSB: *endianess = 1; *fmt = AUD_FMT_S16; break; case AUDIO_U16MSB: *endianess = 1; *fmt = AUD_FMT_U16; break; default: dolog ("Unrecognized SDL audio format %d\n", sdlfmt); return -1; } return 0; } static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt) { int status; #ifndef _WIN32 sigset_t new, old; /* Make sure potential threads created by SDL don't hog signals. */ sigfillset (&new); pthread_sigmask (SIG_BLOCK, &new, &old); #endif status = SDL_OpenAudio (req, obt); if (status) { sdl_logerr ("SDL_OpenAudio failed\n"); } #ifndef _WIN32 pthread_sigmask (SIG_SETMASK, &old, NULL); #endif return status; } static void sdl_close (SDLAudioState *s) { if (s->initialized) { sdl_lock (s, "sdl_close"); s->exit = 1; sdl_unlock_and_post (s, "sdl_close"); SDL_PauseAudio (1); SDL_CloseAudio (); s->initialized = 0; } } static void sdl_callback (void *opaque, Uint8 *buf, int len) { SDLVoiceOut *sdl = opaque; SDLAudioState *s = &glob_sdl; HWVoiceOut *hw = &sdl->hw; int samples = len >> hw->info.shift; if (sdl_lock (s, "sdl_callback")) { return; } if (s->exit) { return; } while (samples) { int to_mix, decr; while (!sdl->pending) { if (sdl_unlock (s, "sdl_callback")) { return; } sdl_wait (s, "sdl_callback"); if (s->exit) { return; } if (sdl_lock (s, "sdl_callback")) { return; } sdl->pending += sdl->live; sdl->live = 0; } to_mix = audio_MIN (samples, sdl->pending); decr = audio_pcm_hw_clip_out (hw, buf, to_mix, 0); buf += decr << hw->info.shift; samples -= decr; sdl->decr += decr; sdl->pending -= decr; } if (sdl_unlock (s, "sdl_callback")) { return; } } static int sdl_write_out (SWVoiceOut *sw, void *buf, int len) { return audio_pcm_sw_write (sw, buf, len); } static int sdl_run_out (HWVoiceOut *hw, int live) { int decr; SDLVoiceOut *sdl = (SDLVoiceOut *) hw; SDLAudioState *s = &glob_sdl; if (sdl_lock (s, "sdl_run_out")) { return 0; } sdl->live = live; decr = sdl->decr; sdl->decr = 0; if (sdl->live > 0) { sdl_unlock_and_post (s, "sdl_run_out"); } else { sdl_unlock (s, "sdl_run_out"); } return decr; } static void sdl_fini_out (HWVoiceOut *hw) { (void) hw; sdl_close (&glob_sdl); } static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as) { SDLVoiceOut *sdl = (SDLVoiceOut *) hw; SDLAudioState *s = &glob_sdl; SDL_AudioSpec req, obt; int shift; int endianess; int err; audfmt_e effective_fmt; struct audsettings obt_as; shift <<= as->nchannels == 2; req.freq = as->freq; req.format = aud_to_sdlfmt (as->fmt, &shift); req.channels = as->nchannels; req.samples = conf.nb_samples; req.callback = sdl_callback; req.userdata = sdl; if (sdl_open (&req, &obt)) { return -1; } err = sdl_to_audfmt (obt.format, &effective_fmt, &endianess); if (err) { sdl_close (s); return -1; } obt_as.freq = obt.freq; obt_as.nchannels = obt.channels; obt_as.fmt = effective_fmt; obt_as.endianness = endianess; audio_pcm_init_info (&hw->info, &obt_as); hw->samples = obt.samples; s->initialized = 1; s->exit = 0; SDL_PauseAudio (0); return 0; } static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...) { (void) hw; switch (cmd) { case VOICE_ENABLE: SDL_PauseAudio (0); break; case VOICE_DISABLE: SDL_PauseAudio (1); break; } return 0; } static void *sdl_audio_init (void) { SDLAudioState *s = &glob_sdl; if (SDL_InitSubSystem (SDL_INIT_AUDIO)) { sdl_logerr ("SDL failed to initialize audio subsystem\n"); return NULL; } s->mutex = SDL_CreateMutex (); if (!s->mutex) { sdl_logerr ("Failed to create SDL mutex\n"); SDL_QuitSubSystem (SDL_INIT_AUDIO); return NULL; } s->sem = SDL_CreateSemaphore (0); if (!s->sem) { sdl_logerr ("Failed to create SDL semaphore\n"); SDL_DestroyMutex (s->mutex); SDL_QuitSubSystem (SDL_INIT_AUDIO); return NULL; } return s; } static void sdl_audio_fini (void *opaque) { SDLAudioState *s = opaque; sdl_close (s); SDL_DestroySemaphore (s->sem); SDL_DestroyMutex (s->mutex); SDL_QuitSubSystem (SDL_INIT_AUDIO); } static struct audio_option sdl_options[] = { { .name = "SAMPLES", .tag = AUD_OPT_INT, .valp = &conf.nb_samples, .descr = "Size of SDL buffer in samples" }, { /* End of list */ } }; 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, }; struct audio_driver sdl_audio_driver = { .name = "sdl", .descr = "SDL http://www.libsdl.org", .options = sdl_options, .init = sdl_audio_init, .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 };