Alc/backends/sdl2.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 2018 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <SDL2/SDL.h>
  25
  26 #include "alMain.h"
  27 #include "alu.h"
  28 #include "threads.h"
  29 #include "compat.h"
  30
  31 #include "backends/base.h"
  32
  33
  34 #ifdef _WIN32
  35 #define DEVNAME_PREFIX "OpenAL Soft on "
  36 #else
  37 #define DEVNAME_PREFIX ""
  38 #endif
  39
  40 typedef struct ALCsdl2Backend {
  41     DERIVE_FROM_TYPE(ALCbackend);
  42
  43     SDL_AudioDeviceID deviceID;
  44     ALsizei frameSize;
  45
  46     ALuint Frequency;
  47     enum DevFmtChannels FmtChans;
  48     enum DevFmtType     FmtType;
  49     ALuint UpdateSize;
  50 } ALCsdl2Backend;
  51
  52 static void ALCsdl2Backend_Construct(ALCsdl2Backend *self, ALCdevice *device);
  53 static void ALCsdl2Backend_Destruct(ALCsdl2Backend *self);
  54 static ALCenum ALCsdl2Backend_open(ALCsdl2Backend *self, const ALCchar *name);
  55 static ALCboolean ALCsdl2Backend_reset(ALCsdl2Backend *self);
  56 static ALCboolean ALCsdl2Backend_start(ALCsdl2Backend *self);
  57 static void ALCsdl2Backend_stop(ALCsdl2Backend *self);
  58 static DECLARE_FORWARD2(ALCsdl2Backend, ALCbackend, ALCenum, captureSamples, void*, ALCuint)
  59 static DECLARE_FORWARD(ALCsdl2Backend, ALCbackend, ALCuint, availableSamples)
  60 static DECLARE_FORWARD(ALCsdl2Backend, ALCbackend, ClockLatency, getClockLatency)
  61 static void ALCsdl2Backend_lock(ALCsdl2Backend *self);
  62 static void ALCsdl2Backend_unlock(ALCsdl2Backend *self);
  63 DECLARE_DEFAULT_ALLOCATORS(ALCsdl2Backend)
  64
  65 DEFINE_ALCBACKEND_VTABLE(ALCsdl2Backend);
  66
  67 static const ALCchar defaultDeviceName[] = DEVNAME_PREFIX "Default Device";
  68
  69 static void ALCsdl2Backend_Construct(ALCsdl2Backend *self, ALCdevice *device)
  70 {
  71     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
  72     SET_VTABLE2(ALCsdl2Backend, ALCbackend, self);
  73
  74     self->deviceID = 0;
  75     self->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->AmbiOrder);
  76     self->Frequency = device->Frequency;
  77     self->FmtChans = device->FmtChans;
  78     self->FmtType = device->FmtType;
  79     self->UpdateSize = device->UpdateSize;
  80 }
  81
  82 static void ALCsdl2Backend_Destruct(ALCsdl2Backend *self)
  83 {
  84     if(self->deviceID)
  85         SDL_CloseAudioDevice(self->deviceID);
  86     self->deviceID = 0;
  87
  88     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
  89 }
  90
  91
  92 static void ALCsdl2Backend_audioCallback(void *ptr, Uint8 *stream, int len)
  93 {
  94     ALCsdl2Backend *self = (ALCsdl2Backend*)ptr;
  95     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
  96
  97     assert((len % self->frameSize) == 0);
  98     aluMixData(device, stream, len / self->frameSize);
  99 }
 100
 101 static ALCenum ALCsdl2Backend_open(ALCsdl2Backend *self, const ALCchar *name)
 102 {
 103     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 104     SDL_AudioSpec want, have;
 105
 106     SDL_zero(want);
 107     SDL_zero(have);
 108
 109     want.freq = device->Frequency;
 110     switch(device->FmtType)
 111     {
 112         case DevFmtUByte: want.format = AUDIO_U8; break;
 113         case DevFmtByte: want.format = AUDIO_S8; break;
 114         case DevFmtUShort: want.format = AUDIO_U16SYS; break;
 115         case DevFmtShort: want.format = AUDIO_S16SYS; break;
 116         case DevFmtUInt: /* fall-through */
 117         case DevFmtInt: want.format = AUDIO_S32SYS; break;
 118         case DevFmtFloat: want.format = AUDIO_F32; break;
 119     }
 120     want.channels = (device->FmtChans == DevFmtMono) ? 1 : 2;
 121     want.samples = device->UpdateSize;
 122     want.callback = ALCsdl2Backend_audioCallback;
 123     want.userdata = self;
 124
 125     /* Passing NULL to SDL_OpenAudioDevice opens a default, which isn't
 126      * necessarily the first in the list.
 127      */
 128     if(!name || strcmp(name, defaultDeviceName) == 0)
 129         self->deviceID = SDL_OpenAudioDevice(NULL, SDL_FALSE, &want, &have,
 130                                              SDL_AUDIO_ALLOW_ANY_CHANGE);
 131     else
 132     {
 133         const size_t prefix_len = strlen(DEVNAME_PREFIX);
 134         if(strncmp(name, DEVNAME_PREFIX, prefix_len) == 0)
 135             self->deviceID = SDL_OpenAudioDevice(name+prefix_len, SDL_FALSE, &want, &have,
 136                                                  SDL_AUDIO_ALLOW_ANY_CHANGE);
 137         else
 138             self->deviceID = SDL_OpenAudioDevice(name, SDL_FALSE, &want, &have,
 139                                                  SDL_AUDIO_ALLOW_ANY_CHANGE);
 140     }
 141     if(self->deviceID == 0)
 142         return ALC_INVALID_VALUE;
 143
 144     device->Frequency = have.freq;
 145     if(have.channels == 1)
 146         device->FmtChans = DevFmtMono;
 147     else if(have.channels == 2)
 148         device->FmtChans = DevFmtStereo;
 149     else
 150     {
 151         ERR("Got unhandled SDL channel count: %d\n", (int)have.channels);
 152         return ALC_INVALID_VALUE;
 153     }
 154     switch(have.format)
 155     {
 156         case AUDIO_U8:     device->FmtType = DevFmtUByte;  break;
 157         case AUDIO_S8:     device->FmtType = DevFmtByte;   break;
 158         case AUDIO_U16SYS: device->FmtType = DevFmtUShort; break;
 159         case AUDIO_S16SYS: device->FmtType = DevFmtShort;  break;
 160         case AUDIO_S32SYS: device->FmtType = DevFmtInt;    break;
 161         case AUDIO_F32SYS: device->FmtType = DevFmtFloat;  break;
 162         default:
 163             ERR("Got unsupported SDL format: 0x%04x\n", have.format);
 164             return ALC_INVALID_VALUE;
 165     }
 166     device->UpdateSize = have.samples;
 167     device->NumUpdates = 2; /* SDL always (tries to) use two periods. */
 168
 169     self->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->AmbiOrder);
 170     self->Frequency = device->Frequency;
 171     self->FmtChans = device->FmtChans;
 172     self->FmtType = device->FmtType;
 173     self->UpdateSize = device->UpdateSize;
 174
 175     alstr_copy_cstr(&device->DeviceName, name ? name : defaultDeviceName);
 176
 177     return ALC_NO_ERROR;
 178 }
 179
 180 static ALCboolean ALCsdl2Backend_reset(ALCsdl2Backend *self)
 181 {
 182     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 183     device->Frequency = self->Frequency;
 184     device->FmtChans = self->FmtChans;
 185     device->FmtType = self->FmtType;
 186     device->UpdateSize = self->UpdateSize;
 187     device->NumUpdates = 2;
 188     SetDefaultWFXChannelOrder(device);
 189     return ALC_TRUE;
 190 }
 191
 192 static ALCboolean ALCsdl2Backend_start(ALCsdl2Backend *self)
 193 {
 194     SDL_PauseAudioDevice(self->deviceID, 0);
 195     return ALC_TRUE;
 196 }
 197
 198 static void ALCsdl2Backend_stop(ALCsdl2Backend *self)
 199 {
 200     SDL_PauseAudioDevice(self->deviceID, 1);
 201 }
 202
 203 static void ALCsdl2Backend_lock(ALCsdl2Backend *self)
 204 {
 205     SDL_LockAudioDevice(self->deviceID);
 206 }
 207
 208 static void ALCsdl2Backend_unlock(ALCsdl2Backend *self)
 209 {
 210     SDL_UnlockAudioDevice(self->deviceID);
 211 }
 212
 213
 214 typedef struct ALCsdl2BackendFactory {
 215     DERIVE_FROM_TYPE(ALCbackendFactory);
 216 } ALCsdl2BackendFactory;
 217 #define ALCsdl2BACKENDFACTORY_INITIALIZER { { GET_VTABLE2(ALCsdl2BackendFactory, ALCbackendFactory) } }
 218
 219 ALCbackendFactory *ALCsdl2BackendFactory_getFactory(void);
 220
 221 static ALCboolean ALCsdl2BackendFactory_init(ALCsdl2BackendFactory *self);
 222 static void ALCsdl2BackendFactory_deinit(ALCsdl2BackendFactory *self);
 223 static ALCboolean ALCsdl2BackendFactory_querySupport(ALCsdl2BackendFactory *self, ALCbackend_Type type);
 224 static void ALCsdl2BackendFactory_probe(ALCsdl2BackendFactory *self, enum DevProbe type);
 225 static ALCbackend* ALCsdl2BackendFactory_createBackend(ALCsdl2BackendFactory *self, ALCdevice *device, ALCbackend_Type type);
 226 DEFINE_ALCBACKENDFACTORY_VTABLE(ALCsdl2BackendFactory);
 227
 228
 229 ALCbackendFactory *ALCsdl2BackendFactory_getFactory(void)
 230 {
 231     static ALCsdl2BackendFactory factory = ALCsdl2BACKENDFACTORY_INITIALIZER;
 232     return STATIC_CAST(ALCbackendFactory, &factory);
 233 }
 234
 235
 236 static ALCboolean ALCsdl2BackendFactory_init(ALCsdl2BackendFactory* UNUSED(self))
 237 {
 238     if(SDL_InitSubSystem(SDL_INIT_AUDIO) == 0)
 239         return AL_TRUE;
 240     return ALC_FALSE;
 241 }
 242
 243 static void ALCsdl2BackendFactory_deinit(ALCsdl2BackendFactory* UNUSED(self))
 244 {
 245     SDL_QuitSubSystem(SDL_INIT_AUDIO);
 246 }
 247
 248 static ALCboolean ALCsdl2BackendFactory_querySupport(ALCsdl2BackendFactory* UNUSED(self), ALCbackend_Type type)
 249 {
 250     if(type == ALCbackend_Playback)
 251         return ALC_TRUE;
 252     return ALC_FALSE;
 253 }
 254
 255 static void ALCsdl2BackendFactory_probe(ALCsdl2BackendFactory* UNUSED(self), enum DevProbe type)
 256 {
 257     int num_devices, i;
 258     al_string name;
 259
 260     if(type != ALL_DEVICE_PROBE)
 261         return;
 262
 263     AL_STRING_INIT(name);
 264     num_devices = SDL_GetNumAudioDevices(SDL_FALSE);
 265
 266     AppendAllDevicesList(defaultDeviceName);
 267     for(i = 0;i < num_devices;++i)
 268     {
 269         alstr_copy_cstr(&name, DEVNAME_PREFIX);
 270         alstr_append_cstr(&name, SDL_GetAudioDeviceName(i, SDL_FALSE));
 271         AppendAllDevicesList(alstr_get_cstr(name));
 272     }
 273     alstr_reset(&name);
 274 }
 275
 276 static ALCbackend* ALCsdl2BackendFactory_createBackend(ALCsdl2BackendFactory* UNUSED(self), ALCdevice *device, ALCbackend_Type type)
 277 {
 278     if(type == ALCbackend_Playback)
 279     {
 280         ALCsdl2Backend *backend;
 281         NEW_OBJ(backend, ALCsdl2Backend)(device);
 282         if(!backend) return NULL;
 283         return STATIC_CAST(ALCbackend, backend);
 284     }
 285
 286     return NULL;
 287 }