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 exit;
  45     int initialized;
  46     Audiodev *dev;
  47     SDL_AudioDeviceID devid;
  48 } SDLVoiceOut;
  49
  50 typedef struct SDLVoiceIn {
  51     HWVoiceIn hw;
  52     int exit;
  53     int initialized;
  54     Audiodev *dev;
  55     SDL_AudioDeviceID devid;
  56 } SDLVoiceIn;
  57
  58 static void GCC_FMT_ATTR (1, 2) sdl_logerr (const char *fmt, ...)
  59 {
  60     va_list ap;
  61
  62     va_start (ap, fmt);
  63     AUD_vlog (AUDIO_CAP, fmt, ap);
  64     va_end (ap);
  65
  66     AUD_log (AUDIO_CAP, "Reason: %s\n", SDL_GetError ());
  67 }
  68
  69 static int aud_to_sdlfmt (AudioFormat fmt)
  70 {
  71     switch (fmt) {
  72     case AUDIO_FORMAT_S8:
  73         return AUDIO_S8;
  74
  75     case AUDIO_FORMAT_U8:
  76         return AUDIO_U8;
  77
  78     case AUDIO_FORMAT_S16:
  79         return AUDIO_S16LSB;
  80
  81     case AUDIO_FORMAT_U16:
  82         return AUDIO_U16LSB;
  83
  84     case AUDIO_FORMAT_S32:
  85         return AUDIO_S32LSB;
  86
  87     /* no unsigned 32-bit support in SDL */
  88
  89     case AUDIO_FORMAT_F32:
  90         return AUDIO_F32LSB;
  91
  92     default:
  93         dolog ("Internal logic error: Bad audio format %d\n", fmt);
  94 #ifdef DEBUG_AUDIO
  95         abort ();
  96 #endif
  97         return AUDIO_U8;
  98     }
  99 }
 100
 101 static int sdl_to_audfmt(int sdlfmt, AudioFormat *fmt, int *endianness)
 102 {
 103     switch (sdlfmt) {
 104     case AUDIO_S8:
 105         *endianness = 0;
 106         *fmt = AUDIO_FORMAT_S8;
 107         break;
 108
 109     case AUDIO_U8:
 110         *endianness = 0;
 111         *fmt = AUDIO_FORMAT_U8;
 112         break;
 113
 114     case AUDIO_S16LSB:
 115         *endianness = 0;
 116         *fmt = AUDIO_FORMAT_S16;
 117         break;
 118
 119     case AUDIO_U16LSB:
 120         *endianness = 0;
 121         *fmt = AUDIO_FORMAT_U16;
 122         break;
 123
 124     case AUDIO_S16MSB:
 125         *endianness = 1;
 126         *fmt = AUDIO_FORMAT_S16;
 127         break;
 128
 129     case AUDIO_U16MSB:
 130         *endianness = 1;
 131         *fmt = AUDIO_FORMAT_U16;
 132         break;
 133
 134     case AUDIO_S32LSB:
 135         *endianness = 0;
 136         *fmt = AUDIO_FORMAT_S32;
 137         break;
 138
 139     case AUDIO_S32MSB:
 140         *endianness = 1;
 141         *fmt = AUDIO_FORMAT_S32;
 142         break;
 143
 144     case AUDIO_F32LSB:
 145         *endianness = 0;
 146         *fmt = AUDIO_FORMAT_F32;
 147         break;
 148
 149     case AUDIO_F32MSB:
 150         *endianness = 1;
 151         *fmt = AUDIO_FORMAT_F32;
 152         break;
 153
 154     default:
 155         dolog ("Unrecognized SDL audio format %d\n", sdlfmt);
 156         return -1;
 157     }
 158
 159     return 0;
 160 }
 161
 162 static SDL_AudioDeviceID sdl_open(SDL_AudioSpec *req, SDL_AudioSpec *obt,
 163                                   int rec)
 164 {
 165     SDL_AudioDeviceID devid;
 166 #ifndef _WIN32
 167     int err;
 168     sigset_t new, old;
 169
 170     /* Make sure potential threads created by SDL don't hog signals.  */
 171     err = sigfillset (&new);
 172     if (err) {
 173         dolog ("sdl_open: sigfillset failed: %s\n", strerror (errno));
 174         return 0;
 175     }
 176     err = pthread_sigmask (SIG_BLOCK, &new, &old);
 177     if (err) {
 178         dolog ("sdl_open: pthread_sigmask failed: %s\n", strerror (err));
 179         return 0;
 180     }
 181 #endif
 182
 183     devid = SDL_OpenAudioDevice(NULL, rec, req, obt, 0);
 184     if (!devid) {
 185         sdl_logerr("SDL_OpenAudioDevice for %s failed\n",
 186                    rec ? "recording" : "playback");
 187     }
 188
 189 #ifndef _WIN32
 190     err = pthread_sigmask (SIG_SETMASK, &old, NULL);
 191     if (err) {
 192         dolog ("sdl_open: pthread_sigmask (restore) failed: %s\n",
 193                strerror (errno));
 194         /* We have failed to restore original signal mask, all bets are off,
 195            so exit the process */
 196         exit (EXIT_FAILURE);
 197     }
 198 #endif
 199     return devid;
 200 }
 201
 202 static void sdl_close_out(SDLVoiceOut *sdl)
 203 {
 204     if (sdl->initialized) {
 205         SDL_LockAudioDevice(sdl->devid);
 206         sdl->exit = 1;
 207         SDL_UnlockAudioDevice(sdl->devid);
 208         SDL_PauseAudioDevice(sdl->devid, 1);
 209         sdl->initialized = 0;
 210     }
 211     if (sdl->devid) {
 212         SDL_CloseAudioDevice(sdl->devid);
 213         sdl->devid = 0;
 214     }
 215 }
 216
 217 static void sdl_callback_out(void *opaque, Uint8 *buf, int len)
 218 {
 219     SDLVoiceOut *sdl = opaque;
 220     HWVoiceOut *hw = &sdl->hw;
 221
 222     if (!sdl->exit) {
 223
 224         /* dolog("callback_out: len=%d avail=%zu\n", len, hw->pending_emul); */
 225
 226         while (hw->pending_emul && len) {
 227             size_t write_len, start;
 228
 229             start = audio_ring_posb(hw->pos_emul, hw->pending_emul,
 230                                     hw->size_emul);
 231             assert(start < hw->size_emul);
 232
 233             write_len = MIN(MIN(hw->pending_emul, len),
 234                             hw->size_emul - start);
 235
 236             memcpy(buf, hw->buf_emul + start, write_len);
 237             hw->pending_emul -= write_len;
 238             len -= write_len;
 239             buf += write_len;
 240         }
 241     }
 242
 243     /* clear remaining buffer that we couldn't fill with data */
 244     if (len) {
 245         audio_pcm_info_clear_buf(&hw->info, buf,
 246                                  len / hw->info.bytes_per_frame);
 247     }
 248 }
 249
 250 static void sdl_close_in(SDLVoiceIn *sdl)
 251 {
 252     if (sdl->initialized) {
 253         SDL_LockAudioDevice(sdl->devid);
 254         sdl->exit = 1;
 255         SDL_UnlockAudioDevice(sdl->devid);
 256         SDL_PauseAudioDevice(sdl->devid, 1);
 257         sdl->initialized = 0;
 258     }
 259     if (sdl->devid) {
 260         SDL_CloseAudioDevice(sdl->devid);
 261         sdl->devid = 0;
 262     }
 263 }
 264
 265 static void sdl_callback_in(void *opaque, Uint8 *buf, int len)
 266 {
 267     SDLVoiceIn *sdl = opaque;
 268     HWVoiceIn *hw = &sdl->hw;
 269
 270     if (sdl->exit) {
 271         return;
 272     }
 273
 274     /* dolog("callback_in: len=%d pending=%zu\n", len, hw->pending_emul); */
 275
 276     while (hw->pending_emul < hw->size_emul && len) {
 277         size_t read_len = MIN(len, MIN(hw->size_emul - hw->pos_emul,
 278                                        hw->size_emul - hw->pending_emul));
 279
 280         memcpy(hw->buf_emul + hw->pos_emul, buf, read_len);
 281
 282         hw->pending_emul += read_len;
 283         hw->pos_emul = (hw->pos_emul + read_len) % hw->size_emul;
 284         len -= read_len;
 285         buf += read_len;
 286     }
 287 }
 288
 289 #define SDL_WRAPPER_FUNC(name, ret_type, args_decl, args, dir) \
 290     static ret_type glue(sdl_, name)args_decl                  \
 291     {                                                          \
 292         ret_type ret;                                          \
 293         glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw;  \
 294                                                                \
 295         SDL_LockAudioDevice(sdl->devid);                       \
 296         ret = glue(audio_generic_, name)args;                  \
 297         SDL_UnlockAudioDevice(sdl->devid);                     \
 298                                                                \
 299         return ret;                                            \
 300     }
 301
 302 #define SDL_WRAPPER_VOID_FUNC(name, args_decl, args, dir)      \
 303     static void glue(sdl_, name)args_decl                      \
 304     {                                                          \
 305         glue(SDLVoice, dir) *sdl = (glue(SDLVoice, dir) *)hw;  \
 306                                                                \
 307         SDL_LockAudioDevice(sdl->devid);                       \
 308         glue(audio_generic_, name)args;                        \
 309         SDL_UnlockAudioDevice(sdl->devid);                     \
 310     }
 311
 312 SDL_WRAPPER_FUNC(buffer_get_free, size_t, (HWVoiceOut *hw), (hw), Out)
 313 SDL_WRAPPER_FUNC(get_buffer_out, void *, (HWVoiceOut *hw, size_t *size),
 314                  (hw, size), Out)
 315 SDL_WRAPPER_FUNC(put_buffer_out, size_t,
 316                  (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
 317 SDL_WRAPPER_FUNC(write, size_t,
 318                  (HWVoiceOut *hw, void *buf, size_t size), (hw, buf, size), Out)
 319 SDL_WRAPPER_FUNC(read, size_t, (HWVoiceIn *hw, void *buf, size_t size),
 320                  (hw, buf, size), In)
 321 SDL_WRAPPER_FUNC(get_buffer_in, void *, (HWVoiceIn *hw, size_t *size),
 322                  (hw, size), In)
 323 SDL_WRAPPER_VOID_FUNC(put_buffer_in, (HWVoiceIn *hw, void *buf, size_t size),
 324                       (hw, buf, size), In)
 325 #undef SDL_WRAPPER_FUNC
 326 #undef SDL_WRAPPER_VOID_FUNC
 327
 328 static void sdl_fini_out(HWVoiceOut *hw)
 329 {
 330     SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
 331
 332     sdl_close_out(sdl);
 333 }
 334
 335 static int sdl_init_out(HWVoiceOut *hw, struct audsettings *as,
 336                         void *drv_opaque)
 337 {
 338     SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
 339     SDL_AudioSpec req, obt;
 340     int endianness;
 341     int err;
 342     AudioFormat effective_fmt;
 343     Audiodev *dev = drv_opaque;
 344     AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.out;
 345     struct audsettings obt_as;
 346
 347     req.freq = as->freq;
 348     req.format = aud_to_sdlfmt (as->fmt);
 349     req.channels = as->nchannels;
 350     /* SDL samples are QEMU frames */
 351     req.samples = audio_buffer_frames(
 352         qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
 353     req.callback = sdl_callback_out;
 354     req.userdata = sdl;
 355
 356     sdl->dev = dev;
 357     sdl->devid = sdl_open(&req, &obt, 0);
 358     if (!sdl->devid) {
 359         return -1;
 360     }
 361
 362     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
 363     if (err) {
 364         sdl_close_out(sdl);
 365         return -1;
 366     }
 367
 368     obt_as.freq = obt.freq;
 369     obt_as.nchannels = obt.channels;
 370     obt_as.fmt = effective_fmt;
 371     obt_as.endianness = endianness;
 372
 373     audio_pcm_init_info (&hw->info, &obt_as);
 374     hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
 375         obt.samples;
 376
 377     sdl->initialized = 1;
 378     sdl->exit = 0;
 379     return 0;
 380 }
 381
 382 static void sdl_enable_out(HWVoiceOut *hw, bool enable)
 383 {
 384     SDLVoiceOut *sdl = (SDLVoiceOut *)hw;
 385
 386     SDL_PauseAudioDevice(sdl->devid, !enable);
 387 }
 388
 389 static void sdl_fini_in(HWVoiceIn *hw)
 390 {
 391     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
 392
 393     sdl_close_in(sdl);
 394 }
 395
 396 static int sdl_init_in(HWVoiceIn *hw, audsettings *as, void *drv_opaque)
 397 {
 398     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
 399     SDL_AudioSpec req, obt;
 400     int endianness;
 401     int err;
 402     AudioFormat effective_fmt;
 403     Audiodev *dev = drv_opaque;
 404     AudiodevSdlPerDirectionOptions *spdo = dev->u.sdl.in;
 405     struct audsettings obt_as;
 406
 407     req.freq = as->freq;
 408     req.format = aud_to_sdlfmt(as->fmt);
 409     req.channels = as->nchannels;
 410     /* SDL samples are QEMU frames */
 411     req.samples = audio_buffer_frames(
 412         qapi_AudiodevSdlPerDirectionOptions_base(spdo), as, 11610);
 413     req.callback = sdl_callback_in;
 414     req.userdata = sdl;
 415
 416     sdl->dev = dev;
 417     sdl->devid = sdl_open(&req, &obt, 1);
 418     if (!sdl->devid) {
 419         return -1;
 420     }
 421
 422     err = sdl_to_audfmt(obt.format, &effective_fmt, &endianness);
 423     if (err) {
 424         sdl_close_in(sdl);
 425         return -1;
 426     }
 427
 428     obt_as.freq = obt.freq;
 429     obt_as.nchannels = obt.channels;
 430     obt_as.fmt = effective_fmt;
 431     obt_as.endianness = endianness;
 432
 433     audio_pcm_init_info(&hw->info, &obt_as);
 434     hw->samples = (spdo->has_buffer_count ? spdo->buffer_count : 4) *
 435         obt.samples;
 436     hw->size_emul = hw->samples * hw->info.bytes_per_frame;
 437     hw->buf_emul = g_malloc(hw->size_emul);
 438     hw->pos_emul = hw->pending_emul = 0;
 439
 440     sdl->initialized = 1;
 441     sdl->exit = 0;
 442     return 0;
 443 }
 444
 445 static void sdl_enable_in(HWVoiceIn *hw, bool enable)
 446 {
 447     SDLVoiceIn *sdl = (SDLVoiceIn *)hw;
 448
 449     SDL_PauseAudioDevice(sdl->devid, !enable);
 450 }
 451
 452 static void *sdl_audio_init(Audiodev *dev)
 453 {
 454     if (SDL_InitSubSystem (SDL_INIT_AUDIO)) {
 455         sdl_logerr ("SDL failed to initialize audio subsystem\n");
 456         return NULL;
 457     }
 458
 459     return dev;
 460 }
 461
 462 static void sdl_audio_fini (void *opaque)
 463 {
 464     SDL_QuitSubSystem (SDL_INIT_AUDIO);
 465 }
 466
 467 static struct audio_pcm_ops sdl_pcm_ops = {
 468     .init_out = sdl_init_out,
 469     .fini_out = sdl_fini_out,
 470   /* wrapper for audio_generic_write */
 471     .write    = sdl_write,
 472   /* wrapper for audio_generic_buffer_get_free */
 473     .buffer_get_free = sdl_buffer_get_free,
 474   /* wrapper for audio_generic_get_buffer_out */
 475     .get_buffer_out = sdl_get_buffer_out,
 476   /* wrapper for audio_generic_put_buffer_out */
 477     .put_buffer_out = sdl_put_buffer_out,
 478     .enable_out = sdl_enable_out,
 479     .init_in = sdl_init_in,
 480     .fini_in = sdl_fini_in,
 481   /* wrapper for audio_generic_read */
 482     .read = sdl_read,
 483   /* wrapper for audio_generic_get_buffer_in */
 484     .get_buffer_in = sdl_get_buffer_in,
 485   /* wrapper for audio_generic_put_buffer_in */
 486     .put_buffer_in = sdl_put_buffer_in,
 487     .enable_in = sdl_enable_in,
 488 };
 489
 490 static struct audio_driver sdl_audio_driver = {
 491     .name           = "sdl",
 492     .descr          = "SDL http://www.libsdl.org",
 493     .init           = sdl_audio_init,
 494     .fini           = sdl_audio_fini,
 495     .pcm_ops        = &sdl_pcm_ops,
 496     .can_be_default = 1,
 497     .max_voices_out = INT_MAX,
 498     .max_voices_in  = INT_MAX,
 499     .voice_size_out = sizeof(SDLVoiceOut),
 500     .voice_size_in  = sizeof(SDLVoiceIn),
 501 };
 502
 503 static void register_audio_sdl(void)
 504 {
 505     audio_driver_register(&sdl_audio_driver);
 506 }
 507 type_init(register_audio_sdl);