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