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 #include <SDL.h>
  25 #include <SDL_thread.h>
  26 #include "qemu-common.h"
  27 #include "audio.h"
  28
  29 #ifndef _WIN32
  30 #ifdef __sun__
  31 #define _POSIX_PTHREAD_SEMANTICS 1
  32 #elif defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
  33 #include <pthread.h>
  34 #endif
  35 #endif
  36
  37 #define AUDIO_CAP "sdl"
  38 #include "audio_int.h"
  39
  40 typedef struct SDLVoiceOut {
  41     HWVoiceOut hw;
  42     int live;
  43     int rpos;
  44     int decr;
  45 } SDLVoiceOut;
  46
  47 static struct {
  48     int nb_samples;
  49 } conf = {
  50     .nb_samples = 1024
  51 };
  52
  53 static struct SDLAudioState {
  54     int exit;
  55     SDL_mutex *mutex;
  56     SDL_sem *sem;
  57     int initialized;
  58 } glob_sdl;
  59 typedef struct SDLAudioState SDLAudioState;
  60
  61 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
  62 {
  63     va_list ap;
  64
  65     va_start (ap, fmt);
  66     AUD_vlog (AUDIO_CAP, fmt, ap);
  67     va_end (ap);
  68
  69     AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
  70 }
  71
  72 static int sdl_lock (SDLAudioState *s, const char *forfn)
  73 {
  74     if (SDL_LockMutex (s->mutex)) {
  75         sdl_logerr ("SDL_LockMutex for %s failed\n", forfn);
  76         return -1;
  77     }
  78     return 0;
  79 }
  80
  81 static int sdl_unlock (SDLAudioState *s, const char *forfn)
  82 {
  83     if (SDL_UnlockMutex (s->mutex)) {
  84         sdl_logerr ("SDL_UnlockMutex for %s failed\n", forfn);
  85         return -1;
  86     }
  87     return 0;
  88 }
  89
  90 static int sdl_post (SDLAudioState *s, const char *forfn)
  91 {
  92     if (SDL_SemPost (s->sem)) {
  93         sdl_logerr ("SDL_SemPost for %s failed\n", forfn);
  94         return -1;
  95     }
  96     return 0;
  97 }
  98
  99 static int sdl_wait (SDLAudioState *s, const char *forfn)
 100 {
 101     if (SDL_SemWait (s->sem)) {
 102         sdl_logerr ("SDL_SemWait for %s failed\n", forfn);
 103         return -1;
 104     }
 105     return 0;
 106 }
 107
 108 static int sdl_unlock_and_post (SDLAudioState *s, const char *forfn)
 109 {
 110     if (sdl_unlock (s, forfn)) {
 111         return -1;
 112     }
 113
 114     return sdl_post (s, forfn);
 115 }
 116
 117 static int aud_to_sdlfmt (audfmt_e fmt)
 118 {
 119     switch (fmt) {
 120     case AUD_FMT_S8:
 121         return AUDIO_S8;
 122
 123     case AUD_FMT_U8:
 124         return AUDIO_U8;
 125
 126     case AUD_FMT_S16:
 127         return AUDIO_S16LSB;
 128
 129     case AUD_FMT_U16:
 130         return AUDIO_U16LSB;
 131
 132     default:
 133         dolog ("Internal logic error: Bad audio format %d\n", fmt);
 134 #ifdef DEBUG_AUDIO
 135         abort ();
 136 #endif
 137         return AUDIO_U8;
 138     }
 139 }
 140
 141 static int sdl_to_audfmt(int sdlfmt, audfmt_e *fmt, int *endianness)
 142 {
 143     switch (sdlfmt) {
 144     case AUDIO_S8:
 145         *endianness = 0;
 146         *fmt = AUD_FMT_S8;
 147         break;
 148
 149     case AUDIO_U8:
 150         *endianness = 0;
 151         *fmt = AUD_FMT_U8;
 152         break;
 153
 154     case AUDIO_S16LSB:
 155         *endianness = 0;
 156         *fmt = AUD_FMT_S16;
 157         break;
 158
 159     case AUDIO_U16LSB:
 160         *endianness = 0;
 161         *fmt = AUD_FMT_U16;
 162         break;
 163
 164     case AUDIO_S16MSB:
 165         *endianness = 1;
 166         *fmt = AUD_FMT_S16;
 167         break;
 168
 169     case AUDIO_U16MSB:
 170         *endianness = 1;
 171         *fmt = AUD_FMT_U16;
 172         break;
 173
 174     default:
 175         dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
 176         return -1;
 177     }
 178
 179     return 0;
 180 }
 181
 182 static int sdl_open (SDL_AudioSpec *req, SDL_AudioSpec *obt)
 183 {
 184     int status;
 185 #ifndef _WIN32
 186     int err;
 187     sigset_t new, old;
 188
 189     /* Make sure potential threads created by SDL don't hog signals.  */
 190     err = sigfillset (&new);
 191     if (err) {
 192         dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
 193         return -1;
 194     }
 195     err = pthread_sigmask (SIG_BLOCK, &new, &old);
 196     if (err) {
 197         dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
 198         return -1;
 199     }
 200 #endif
 201
 202     status = SDL_OpenAudio (req, obt);
 203     if (status) {
 204         sdl_logerr ("SDL_OpenAudio failed\n");
 205     }
 206
 207 #ifndef _WIN32
 208     err = pthread_sigmask (SIG_SETMASK, &old, NULL);
 209     if (err) {
 210         dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
 211                strerror (errno));
 212         /* We have failed to restore original signal mask, all bets are off,
 213            so exit the process */
 214         exit (EXIT_FAILURE);
 215     }
 216 #endif
 217     return status;
 218 }
 219
 220 static void sdl_close (SDLAudioState *s)
 221 {
 222     if (s->initialized) {
 223         sdl_lock (s, "sdl_close");
 224         s->exit = 1;
 225         sdl_unlock_and_post (s, "sdl_close");
 226         SDL_PauseAudio (1);
 227         SDL_CloseAudio ();
 228         s->initialized = 0;
 229     }
 230 }
 231
 232 static void sdl_callback (void *opaque, Uint8 *buf, int len)
 233 {
 234     SDLVoiceOut *sdl = opaque;
 235     SDLAudioState *s = &glob_sdl;
 236     HWVoiceOut *hw = &sdl->hw;
 237     int samples = len >> hw->info.shift;
 238
 239     if (s->exit) {
 240         return;
 241     }
 242
 243     while (samples) {
 244         int to_mix, decr;
 245
 246         /* dolog ("in callback samples=%d\n", samples); */
 247         sdl_wait (s, "sdl_callback");
 248         if (s->exit) {
 249             return;
 250         }
 251
 252         if (sdl_lock (s, "sdl_callback")) {
 253             return;
 254         }
 255
 256         if (audio_bug (AUDIO_FUNC, sdl->live < 0 || sdl->live > hw->samples)) {
 257             dolog ("sdl->live=%d hw->samples=%d\n",
 258                    sdl->live, hw->samples);
 259             return;
 260         }
 261
 262         if (!sdl->live) {
 263             goto again;
 264         }
 265
 266         /* dolog ("in callback live=%d\n", live); */
 267         to_mix = audio_MIN (samples, sdl->live);
 268         decr = to_mix;
 269         while (to_mix) {
 270             int chunk = audio_MIN (to_mix, hw->samples - hw->rpos);
 271             struct st_sample *src = hw->mix_buf + hw->rpos;
 272
 273             /* dolog ("in callback to_mix %d, chunk %d\n", to_mix, chunk); */
 274             hw->clip (buf, src, chunk);
 275             sdl->rpos = (sdl->rpos + chunk) % hw->samples;
 276             to_mix -= chunk;
 277             buf += chunk << hw->info.shift;
 278         }
 279         samples -= decr;
 280         sdl->live -= decr;
 281         sdl->decr += decr;
 282
 283     again:
 284         if (sdl_unlock (s, "sdl_callback")) {
 285             return;
 286         }
 287     }
 288     /* dolog ("done len=%d\n", len); */
 289 }
 290
 291 static int sdl_write_out (SWVoiceOut *sw, void *buf, int len)
 292 {
 293     return audio_pcm_sw_write (sw, buf, len);
 294 }
 295
 296 static int sdl_run_out (HWVoiceOut *hw, int live)
 297 {
 298     int decr;
 299     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
 300     SDLAudioState *s = &glob_sdl;
 301
 302     if (sdl_lock (s, "sdl_run_out")) {
 303         return 0;
 304     }
 305
 306     if (sdl->decr > live) {
 307         ldebug ("sdl->decr %d live %d sdl->live %d\n",
 308                 sdl->decr,
 309                 live,
 310                 sdl->live);
 311     }
 312
 313     decr = audio_MIN (sdl->decr, live);
 314     sdl->decr -= decr;
 315
 316     sdl->live = live - decr;
 317     hw->rpos = sdl->rpos;
 318
 319     if (sdl->live > 0) {
 320         sdl_unlock_and_post (s, "sdl_run_out");
 321     }
 322     else {
 323         sdl_unlock (s, "sdl_run_out");
 324     }
 325     return decr;
 326 }
 327
 328 static void sdl_fini_out (HWVoiceOut *hw)
 329 {
 330     (void) hw;
 331
 332     sdl_close (&glob_sdl);
 333 }
 334
 335 static int sdl_init_out (HWVoiceOut *hw, struct audsettings *as)
 336 {
 337     SDLVoiceOut *sdl = (SDLVoiceOut *) hw;
 338     SDLAudioState *s = &glob_sdl;
 339     SDL_AudioSpec req, obt;
 340     int endianness;
 341     int err;
 342     audfmt_e effective_fmt;
 343     struct audsettings obt_as;
 344
 345     req.freq = as->freq;
 346     req.format = aud_to_sdlfmt (as->fmt);
 347     req.channels = as->nchannels;
 348     req.samples = conf.nb_samples;
 349     req.callback = sdl_callback;
 350     req.userdata = sdl;
 351
 352     if (sdl_open (&req, &obt)) {
 353         return -1;
 354     }
 355
 356     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
 357     if (err) {
 358         sdl_close (s);
 359         return -1;
 360     }
 361
 362     obt_as.freq = obt.freq;
 363     obt_as.nchannels = obt.channels;
 364     obt_as.fmt = effective_fmt;
 365     obt_as.endianness = endianness;
 366
 367     audio_pcm_init_info (&hw->info, &obt_as);
 368     hw->samples = obt.samples;
 369
 370     s->initialized = 1;
 371     s->exit = 0;
 372     SDL_PauseAudio (0);
 373     return 0;
 374 }
 375
 376 static int sdl_ctl_out (HWVoiceOut *hw, int cmd, ...)
 377 {
 378     (void) hw;
 379
 380     switch (cmd) {
 381     case VOICE_ENABLE:
 382         SDL_PauseAudio (0);
 383         break;
 384
 385     case VOICE_DISABLE:
 386         SDL_PauseAudio (1);
 387         break;
 388     }
 389     return 0;
 390 }
 391
 392 static void *sdl_audio_init (void)
 393 {
 394     SDLAudioState *s = &glob_sdl;
 395
 396     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
 397         sdl_logerr ("SDL failed to initialize audio subsystem\n");
 398         return NULL;
 399     }
 400
 401     s->mutex = SDL_CreateMutex ();
 402     if (!s->mutex) {
 403         sdl_logerr ("Failed to create SDL mutex\n");
 404         SDL_QuitSubSystem (SDL_INIT_AUDIO);
 405         return NULL;
 406     }
 407
 408     s->sem = SDL_CreateSemaphore (0);
 409     if (!s->sem) {
 410         sdl_logerr ("Failed to create SDL semaphore\n");
 411         SDL_DestroyMutex (s->mutex);
 412         SDL_QuitSubSystem (SDL_INIT_AUDIO);
 413         return NULL;
 414     }
 415
 416     return s;
 417 }
 418
 419 static void sdl_audio_fini (void *opaque)
 420 {
 421     SDLAudioState *s = opaque;
 422     sdl_close (s);
 423     SDL_DestroySemaphore (s->sem);
 424     SDL_DestroyMutex (s->mutex);
 425     SDL_QuitSubSystem (SDL_INIT_AUDIO);
 426 }
 427
 428 static struct audio_option sdl_options[] = {
 429     {
 430         .name  = "SAMPLES",
 431         .tag   = AUD_OPT_INT,
 432         .valp  = &conf.nb_samples,
 433         .descr = "Size of SDL buffer in samples"
 434     },
 435     { /* End of list */ }
 436 };
 437
 438 static struct audio_pcm_ops sdl_pcm_ops = {
 439     .init_out = sdl_init_out,
 440     .fini_out = sdl_fini_out,
 441     .run_out  = sdl_run_out,
 442     .write    = sdl_write_out,
 443     .ctl_out  = sdl_ctl_out,
 444 };
 445
 446 struct audio_driver sdl_audio_driver = {
 447     .name           = "sdl",
 448     .descr          = "SDL http://www.libsdl.org",
 449     .options        = sdl_options,
 450     .init           = sdl_audio_init,
 451     .fini           = sdl_audio_fini,
 452     .pcm_ops        = &sdl_pcm_ops,
 453     .can_be_default = 1,
 454     .max_voices_out = 1,
 455     .max_voices_in  = 0,
 456     .voice_size_out = sizeof (SDLVoiceOut),
 457     .voice_size_in  = 0
 458 };