* 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 "audio.h"
#ifndef _WIN32
typedef struct SDLVoiceOut {
HWVoiceOut hw;
- int live;
- int rpos;
- int decr;
} SDLVoiceOut;
-static struct {
- int nb_samples;
-} conf = {
- .nb_samples = 1024
-};
-
static struct SDLAudioState {
int exit;
- SDL_mutex *mutex;
- SDL_sem *sem;
int initialized;
+ bool driver_created;
+ Audiodev *dev;
} glob_sdl;
typedef struct SDLAudioState SDLAudioState;
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)
+static int aud_to_sdlfmt (AudioFormat fmt)
{
switch (fmt) {
- case AUD_FMT_S8:
+ case AUDIO_FORMAT_S8:
return AUDIO_S8;
- case AUD_FMT_U8:
+ case AUDIO_FORMAT_U8:
return AUDIO_U8;
- case AUD_FMT_S16:
+ case AUDIO_FORMAT_S16:
return AUDIO_S16LSB;
- case AUD_FMT_U16:
+ 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
}
}
-static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness)
+static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
{
switch (sdlfmt) {
case AUDIO_S8:
*endianness = 0;
- *fmt = AUD_FMT_S8;
+ *fmt = AUDIO_FORMAT_S8;
break;
case AUDIO_U8:
*endianness = 0;
- *fmt = AUD_FMT_U8;
+ *fmt = AUDIO_FORMAT_U8;
break;
case AUDIO_S16LSB:
*endianness = 0;
- *fmt = AUD_FMT_S16;
+ *fmt = AUDIO_FORMAT_S16;
break;
case AUDIO_U16LSB:
*endianness = 0;
- *fmt = AUD_FMT_U16;
+ *fmt = AUDIO_FORMAT_U16;
break;
case AUDIO_S16MSB:
*endianness = 1;
- *fmt = AUD_FMT_S16;
+ *fmt = AUDIO_FORMAT_S16;
break;
case AUDIO_U16MSB:
*endianness = 1;
- *fmt = AUD_FMT_U16;
+ *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:
static void sdl_close (SDLAudioState *s)
{
if (s->initialized) {
- sdl_lock (s, "sdl_close");
+ SDL_LockAudio();
s->exit = 1;
- sdl_unlock_and_post (s, "sdl_close");
+ SDL_UnlockAudio();
SDL_PauseAudio (1);
SDL_CloseAudio ();
s->initialized = 0;
SDLVoiceOut *sdl = opaque;
SDLAudioState *s = &glob_sdl;
HWVoiceOut *hw = &sdl->hw;
- int samples = len >> hw->info.shift;
if (s->exit) {
return;
}
- while (samples) {
- int to_mix, decr;
-
- /* dolog ("in callback samples=%d\n", samples); */
- sdl_wait (s, "sdl_callback");
- if (s->exit) {
- return;
- }
-
- if (sdl_lock (s, "sdl_callback")) {
- return;
- }
-
- if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
- dolog ("sdl->live=%d hw->samples=%d\n",
- sdl->live, hw->samples);
- return;
- }
+ /* dolog ("in callback samples=%zu live=%zu\n", samples, sdl->live); */
- if (!sdl->live) {
- goto again;
+ while (hw->pending_emul && len) {
+ size_t write_len;
+ ssize_t start = ((ssize_t) hw->pos_emul) - hw->pending_emul;
+ if (start < 0) {
+ start += hw->size_emul;
}
+ assert(start >= 0 && start < hw->size_emul);
- /* dolog ("in callback live=%d\n", live); */
- 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;
-
- /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
- hw->clip (buf, src, chunk);
- sdl->rpos = (sdl->rpos + chunk) % hw->samples;
- to_mix -= chunk;
- buf += chunk << hw->info.shift;
- }
- samples -= decr;
- sdl->live -= decr;
- sdl->decr += decr;
+ write_len = MIN(MIN(hw->pending_emul, len),
+ hw->size_emul - start);
- again:
- if (sdl_unlock (s, "sdl_callback")) {
- return;
- }
+ memcpy(buf, hw->buf_emul + start, write_len);
+ hw->pending_emul -= write_len;
+ len -= write_len;
+ buf += write_len;
}
- /* dolog ("done len=%d\n", len); */
-}
-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;
+ /* clear remaining buffer that we couldn't fill with data */
+ if (len) {
+ memset(buf, 0, len);
}
+}
- if (sdl->decr > live) {
- ldebug ("sdl->decr %d live %d sdl->live %d\n",
- sdl->decr,
- live,
- sdl->live);
+#define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, fail, unlock) \
+ static ret_type glue(sdl_, name)args_decl \
+ { \
+ ret_type ret; \
+ \
+ SDL_LockAudio(); \
+ \
+ ret = glue(audio_generic_, name)args; \
+ \
+ SDL_UnlockAudio(); \
+ return ret; \
}
- decr = audio_MIN (sdl->decr, live);
- sdl->decr -= decr;
+SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
+ (hw, size), *size = 0, sdl_unlock)
+SDL_WRAPPER_FUNC(put_buffer_out, size_t,
+ (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
+ /*nothing*/, sdl_unlock_and_post)
+SDL_WRAPPER_FUNC(write, size_t,
+ (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size),
+ /*nothing*/, sdl_unlock_and_post)
- sdl->live = live - decr;
- hw->rpos = sdl->rpos;
-
- if (sdl->live > 0) {
- sdl_unlock_and_post (s, "sdl_run_out");
- }
- else {
- sdl_unlock (s, "sdl_run_out");
- }
- return decr;
-}
+#undef SDL_WRAPPER_FUNC
static void sdl_fini_out (HWVoiceOut *hw)
{
sdl_close (&glob_sdl);
}
-static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as)
+static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
+ void *drv_opaque)
{
SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
SDLAudioState *s = &glob_sdl;
SDL_AudioSpec req, obt;
int endianness;
int err;
- audfmt_e effective_fmt;
+ AudioFormat effective_fmt;
struct audsettings obt_as;
req.freq = as->freq;
req.format = aud_to_sdlfmt (as->fmt);
req.channels = as->nchannels;
- req.samples = conf.nb_samples;
+ req.samples = audio_buffer_samples(s->dev->u.sdl.out, as, 11610);
req.callback = sdl_callback;
req.userdata = sdl;
return 0;
}
-static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
+static void sdl_enable_out(HWVoiceOut *hw, bool enable)
{
- (void) hw;
-
- switch (cmd) {
- case VOICE_ENABLE:
- SDL_PauseAudio (0);
- break;
-
- case VOICE_DISABLE:
- SDL_PauseAudio (1);
- break;
- }
- return 0;
+ SDL_PauseAudio(!enable);
}
-static void *sdl_audio_init (void)
+static void *sdl_audio_init(Audiodev *dev)
{
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);
+ if (s->driver_created) {
+ sdl_logerr("Can't create multiple sdl backends\n");
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);
+ if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
+ sdl_logerr ("SDL failed to initialize audio subsystem\n");
return NULL;
}
+ s->driver_created = true;
+ s->dev = dev;
return s;
}
{
SDLAudioState *s = opaque;
sdl_close (s);
- SDL_DestroySemaphore (s->sem);
- SDL_DestroyMutex (s->mutex);
SDL_QuitSubSystem (SDL_INIT_AUDIO);
+ s->driver_created = false;
+ s->dev = NULL;
}
-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,
+ /* wrapper for audio_generic_write */
+ .write = sdl_write,
+ /* 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,
};
-struct audio_driver sdl_audio_driver = {
+static 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,
.voice_size_out = sizeof (SDLVoiceOut),
.voice_size_in = 0
};
+
+static void register_audio_sdl(void)
+{
+ audio_driver_register(&sdl_audio_driver);
+}
+type_init(register_audio_sdl);
projects / qemu.git / blobdiff