audio/sdlaudio.c

   1 /*
   2  * QEMU SDL audio driver
   3  *
   4  * Copyright (c) 2004-2005 Vassili Karpov (malc)
   5  *
   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:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  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
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include <SDL.h>
  27 #include <SDL_thread.h>
  28 #include "qemu/module.h"
  29 #include "audio.h"
  30
  31 #ifndef _WIN32
  32 #ifdef __sun__
  33 #define _POSIX_PTHREAD_SEMANTICS 1
  34 #elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
  35 #include <pthread.h>
  36 #endif
  37 #endif
  38
  39 #define AUDIO_CAP "sdl"
  40 #include "audio_int.h"
  41
  42 typedef struct SDLVoiceOut {
  43     HWVoiceOut hw;
  44     int live;
  45     int decr;
  46 } SDLVoiceOut;
  47
  48 static struct SDLAudioState {
  49     int exit;
  50     int initialized;
  51     bool driver_created;
  52     Audiodev *dev;
  53 } glob_sdl;
  54 typedef struct SDLAudioState SDLAudioState;
  55
  56 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
  57 {
  58     va_list ap;
  59
  60     va_start (ap, fmt);
  61     AUD_vlog (AUDIO_CAP, fmt, ap);
  62     va_end (ap);
  63
  64     AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
  65 }
  66
  67 static int aud_to_sdlfmt (AudioFormat fmt)
  68 {
  69     switch (fmt) {
  70     case AUDIO_FORMAT_S8:
  71         return AUDIO_S8;
  72
  73     case AUDIO_FORMAT_U8:
  74         return AUDIO_U8;
  75
  76     case AUDIO_FORMAT_S16:
  77         return AUDIO_S16LSB;
  78
  79     case AUDIO_FORMAT_U16:
  80         return AUDIO_U16LSB;
  81
  82     default:
  83         dolog ("Internal logic error: Bad audio format %d\n", fmt);
  84 #ifdef DEBUG_AUDIO
  85         abort ();
  86 #endif
  87         return AUDIO_U8;
  88     }
  89 }
  90
  91 static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
  92 {
  93     switch (sdlfmt) {
  94     case AUDIO_S8:
  95         *endianness = 0;
  96         *fmt = AUDIO_FORMAT_S8;
  97         break;
  98
  99     case AUDIO_U8:
 100         *endianness = 0;
 101         *fmt = AUDIO_FORMAT_U8;
 102         break;
 103
 104     case AUDIO_S16LSB:
 105         *endianness = 0;
 106         *fmt = AUDIO_FORMAT_S16;
 107         break;
 108
 109     case AUDIO_U16LSB:
 110         *endianness = 0;
 111         *fmt = AUDIO_FORMAT_U16;
 112         break;
 113
 114     case AUDIO_S16MSB:
 115         *endianness = 1;
 116         *fmt = AUDIO_FORMAT_S16;
 117         break;
 118
 119     case AUDIO_U16MSB:
 120         *endianness = 1;
 121         *fmt = AUDIO_FORMAT_U16;
 122         break;
 123
 124     default:
 125         dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
 126         return -1;
 127     }
 128
 129     return 0;
 130 }
 131
 132 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
 133 {
 134     int status;
 135 #ifndef _WIN32
 136     int err;
 137     sigset_t new, old;
 138
 139     /* Make sure potential threads created by SDL don't hog signals.  */
 140     err = sigfillset (&new);
 141     if (err) {
 142         dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
 143         return -1;
 144     }
 145     err = pthread_sigmask (SIG_BLOCK, &new, &old);
 146     if (err) {
 147         dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
 148         return -1;
 149     }
 150 #endif
 151
 152     status = SDL_OpenAudio (req, obt);
 153     if (status) {
 154         sdl_logerr ("SDL_OpenAudio failed\n");
 155     }
 156
 157 #ifndef _WIN32
 158     err = pthread_sigmask (SIG_SETMASK, &old, NULL);
 159     if (err) {
 160         dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
 161                strerror (errno));
 162         /* We have failed to restore original signal mask, all bets are off,
 163            so exit the process */
 164         exit (EXIT_FAILURE);
 165     }
 166 #endif
 167     return status;
 168 }
 169
 170 static void sdl_close (SDLAudioState *s)
 171 {
 172     if (s->initialized) {
 173         SDL_LockAudio();
 174         s->exit = 1;
 175         SDL_UnlockAudio();
 176         SDL_PauseAudio (1);
 177         SDL_CloseAudio ();
 178         s->initialized = 0;
 179     }
 180 }
 181
 182 static void sdl_callback (void *opaque, Uint8 *buf, int len)
 183 {
 184     SDLVoiceOut *sdl = opaque;
 185     SDLAudioState *s = &glob_sdl;
 186     HWVoiceOut *hw = &sdl->hw;
 187     int samples = len >> hw->info.shift;
 188     int to_mix, decr;
 189
 190     if (s->exit || !sdl->live) {
 191         return;
 192     }
 193
 194     /* dolog ("in callback samples=%d live=%d\n", samples, sdl->live); */
 195
 196     to_mix = audio_MIN(samples, sdl->live);
 197     decr = to_mix;
 198     while (to_mix) {
 199         int chunk = audio_MIN(to_mix, hw->samples - hw->rpos);
 200         struct st_sample *src = hw->mix_buf + hw->rpos;
 201
 202         /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
 203         hw->clip(buf, src, chunk);
 204         hw->rpos = (hw->rpos + chunk) % hw->samples;
 205         to_mix -= chunk;
 206         buf += chunk << hw->info.shift;
 207     }
 208     samples -= decr;
 209     sdl->live -= decr;
 210     sdl->decr += decr;
 211
 212     /* dolog ("done len=%d\n", len); */
 213
 214     /* SDL2 does not clear the remaining buffer for us, so do it on our own */
 215     if (samples) {
 216         memset(buf, 0, samples << hw->info.shift);
 217     }
 218 }
 219
 220 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
 221 {
 222     return audio_pcm_sw_write (sw, buf, len);
 223 }
 224
 225 static int sdl_run_out (HWVoiceOut *hw, int live)
 226 {
 227     int decr;
 228     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
 229
 230     SDL_LockAudio();
 231
 232     if (sdl->decr > live) {
 233         ldebug ("sdl->decr %d live %d sdl->live %d\n",
 234                 sdl->decr,
 235                 live,
 236                 sdl->live);
 237     }
 238
 239     decr = audio_MIN (sdl->decr, live);
 240     sdl->decr -= decr;
 241
 242     sdl->live = live;
 243
 244     SDL_UnlockAudio();
 245
 246     return decr;
 247 }
 248
 249 static void sdl_fini_out (HWVoiceOut *hw)
 250 {
 251     (void) hw;
 252
 253     sdl_close (&glob_sdl);
 254 }
 255
 256 static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
 257                         void *drv_opaque)
 258 {
 259     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
 260     SDLAudioState *s = &glob_sdl;
 261     SDL_AudioSpec req, obt;
 262     int endianness;
 263     int err;
 264     AudioFormat effective_fmt;
 265     struct audsettings obt_as;
 266
 267     req.freq = as->freq;
 268     req.format = aud_to_sdlfmt (as->fmt);
 269     req.channels = as->nchannels;
 270     req.samples = audio_buffer_samples(s->dev->u.sdl.out, as, 11610);
 271     req.callback = sdl_callback;
 272     req.userdata = sdl;
 273
 274     if (sdl_open (&req, &obt)) {
 275         return -1;
 276     }
 277
 278     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
 279     if (err) {
 280         sdl_close (s);
 281         return -1;
 282     }
 283
 284     obt_as.freq = obt.freq;
 285     obt_as.nchannels = obt.channels;
 286     obt_as.fmt = effective_fmt;
 287     obt_as.endianness = endianness;
 288
 289     audio_pcm_init_info (&hw->info, &obt_as);
 290     hw->samples = obt.samples;
 291
 292     s->initialized = 1;
 293     s->exit = 0;
 294     SDL_PauseAudio (0);
 295     return 0;
 296 }
 297
 298 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
 299 {
 300     (void) hw;
 301
 302     switch (cmd) {
 303     case VOICE_ENABLE:
 304         SDL_PauseAudio (0);
 305         break;
 306
 307     case VOICE_DISABLE:
 308         SDL_PauseAudio (1);
 309         break;
 310     }
 311     return 0;
 312 }
 313
 314 static void *sdl_audio_init(Audiodev *dev)
 315 {
 316     SDLAudioState *s = &glob_sdl;
 317     if (s->driver_created) {
 318         sdl_logerr("Can't create multiple sdl backends\n");
 319         return NULL;
 320     }
 321
 322     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
 323         sdl_logerr ("SDL failed to initialize audio subsystem\n");
 324         return NULL;
 325     }
 326
 327     s->driver_created = true;
 328     s->dev = dev;
 329     return s;
 330 }
 331
 332 static void sdl_audio_fini (void *opaque)
 333 {
 334     SDLAudioState *s = opaque;
 335     sdl_close (s);
 336     SDL_QuitSubSystem (SDL_INIT_AUDIO);
 337     s->driver_created = false;
 338     s->dev = NULL;
 339 }
 340
 341 static struct audio_pcm_ops sdl_pcm_ops = {
 342     .init_out = sdl_init_out,
 343     .fini_out = sdl_fini_out,
 344     .run_out  = sdl_run_out,
 345     .write    = sdl_write_out,
 346     .ctl_out  = sdl_ctl_out,
 347 };
 348
 349 static struct audio_driver sdl_audio_driver = {
 350     .name           = "sdl",
 351     .descr          = "SDL http://www.libsdl.org",
 352     .init           = sdl_audio_init,
 353     .fini           = sdl_audio_fini,
 354     .pcm_ops        = &sdl_pcm_ops,
 355     .can_be_default = 1,
 356     .max_voices_out = 1,
 357     .max_voices_in  = 0,
 358     .voice_size_out = sizeof (SDLVoiceOut),
 359     .voice_size_in  = 0
 360 };
 361
 362 static void register_audio_sdl(void)
 363 {
 364     audio_driver_register(&sdl_audio_driver);
 365 }
 366 type_init(register_audio_sdl);