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