Alc/backends/sdl2.cpp

   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 "backends/sdl2.h"
  24
  25 #include <stdlib.h>
  26 #include <SDL2/SDL.h>
  27
  28 #include <string>
  29
  30 #include "alMain.h"
  31 #include "alu.h"
  32 #include "threads.h"
  33 #include "compat.h"
  34
  35
  36 #ifdef _WIN32
  37 #define DEVNAME_PREFIX "OpenAL Soft on "
  38 #else
  39 #define DEVNAME_PREFIX ""
  40 #endif
  41
  42 struct ALCsdl2Backend final : public ALCbackend {
  43     SDL_AudioDeviceID deviceID;
  44     ALsizei frameSize;
  45
  46     ALuint Frequency;
  47     enum DevFmtChannels FmtChans;
  48     enum DevFmtType     FmtType;
  49     ALuint UpdateSize;
  50 };
  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     new (self) ALCsdl2Backend{};
  72     ALCbackend_Construct(STATIC_CAST(ALCbackend, self), device);
  73     SET_VTABLE2(ALCsdl2Backend, ALCbackend, self);
  74
  75     self->deviceID = 0;
  76     self->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->mAmbiOrder);
  77     self->Frequency = device->Frequency;
  78     self->FmtChans = device->FmtChans;
  79     self->FmtType = device->FmtType;
  80     self->UpdateSize = device->UpdateSize;
  81 }
  82
  83 static void ALCsdl2Backend_Destruct(ALCsdl2Backend *self)
  84 {
  85     if(self->deviceID)
  86         SDL_CloseAudioDevice(self->deviceID);
  87     self->deviceID = 0;
  88
  89     ALCbackend_Destruct(STATIC_CAST(ALCbackend, self));
  90     self->~ALCsdl2Backend();
  91 }
  92
  93
  94 static void ALCsdl2Backend_audioCallback(void *ptr, Uint8 *stream, int len)
  95 {
  96     ALCsdl2Backend *self = static_cast<ALCsdl2Backend*>(ptr);
  97     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
  98
  99     assert((len % self->frameSize) == 0);
 100     aluMixData(device, stream, len / self->frameSize);
 101 }
 102
 103 static ALCenum ALCsdl2Backend_open(ALCsdl2Backend *self, const ALCchar *name)
 104 {
 105     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 106     SDL_AudioSpec want, have;
 107
 108     SDL_zero(want);
 109     SDL_zero(have);
 110
 111     want.freq = device->Frequency;
 112     switch(device->FmtType)
 113     {
 114         case DevFmtUByte: want.format = AUDIO_U8; break;
 115         case DevFmtByte: want.format = AUDIO_S8; break;
 116         case DevFmtUShort: want.format = AUDIO_U16SYS; break;
 117         case DevFmtShort: want.format = AUDIO_S16SYS; break;
 118         case DevFmtUInt: /* fall-through */
 119         case DevFmtInt: want.format = AUDIO_S32SYS; break;
 120         case DevFmtFloat: want.format = AUDIO_F32; break;
 121     }
 122     want.channels = (device->FmtChans == DevFmtMono) ? 1 : 2;
 123     want.samples = device->UpdateSize;
 124     want.callback = ALCsdl2Backend_audioCallback;
 125     want.userdata = self;
 126
 127     /* Passing nullptr to SDL_OpenAudioDevice opens a default, which isn't
 128      * necessarily the first in the list.
 129      */
 130     if(!name || strcmp(name, defaultDeviceName) == 0)
 131         self->deviceID = SDL_OpenAudioDevice(nullptr, SDL_FALSE, &want, &have,
 132                                              SDL_AUDIO_ALLOW_ANY_CHANGE);
 133     else
 134     {
 135         const size_t prefix_len = strlen(DEVNAME_PREFIX);
 136         if(strncmp(name, DEVNAME_PREFIX, prefix_len) == 0)
 137             self->deviceID = SDL_OpenAudioDevice(name+prefix_len, SDL_FALSE, &want, &have,
 138                                                  SDL_AUDIO_ALLOW_ANY_CHANGE);
 139         else
 140             self->deviceID = SDL_OpenAudioDevice(name, SDL_FALSE, &want, &have,
 141                                                  SDL_AUDIO_ALLOW_ANY_CHANGE);
 142     }
 143     if(self->deviceID == 0)
 144         return ALC_INVALID_VALUE;
 145
 146     device->Frequency = have.freq;
 147     if(have.channels == 1)
 148         device->FmtChans = DevFmtMono;
 149     else if(have.channels == 2)
 150         device->FmtChans = DevFmtStereo;
 151     else
 152     {
 153         ERR("Got unhandled SDL channel count: %d\n", (int)have.channels);
 154         return ALC_INVALID_VALUE;
 155     }
 156     switch(have.format)
 157     {
 158         case AUDIO_U8:     device->FmtType = DevFmtUByte;  break;
 159         case AUDIO_S8:     device->FmtType = DevFmtByte;   break;
 160         case AUDIO_U16SYS: device->FmtType = DevFmtUShort; break;
 161         case AUDIO_S16SYS: device->FmtType = DevFmtShort;  break;
 162         case AUDIO_S32SYS: device->FmtType = DevFmtInt;    break;
 163         case AUDIO_F32SYS: device->FmtType = DevFmtFloat;  break;
 164         default:
 165             ERR("Got unsupported SDL format: 0x%04x\n", have.format);
 166             return ALC_INVALID_VALUE;
 167     }
 168     device->UpdateSize = have.samples;
 169     device->NumUpdates = 2; /* SDL always (tries to) use two periods. */
 170
 171     self->frameSize = FrameSizeFromDevFmt(device->FmtChans, device->FmtType, device->mAmbiOrder);
 172     self->Frequency = device->Frequency;
 173     self->FmtChans = device->FmtChans;
 174     self->FmtType = device->FmtType;
 175     self->UpdateSize = device->UpdateSize;
 176
 177     device->DeviceName = name ? name : defaultDeviceName;
 178     return ALC_NO_ERROR;
 179 }
 180
 181 static ALCboolean ALCsdl2Backend_reset(ALCsdl2Backend *self)
 182 {
 183     ALCdevice *device = STATIC_CAST(ALCbackend, self)->mDevice;
 184     device->Frequency = self->Frequency;
 185     device->FmtChans = self->FmtChans;
 186     device->FmtType = self->FmtType;
 187     device->UpdateSize = self->UpdateSize;
 188     device->NumUpdates = 2;
 189     SetDefaultWFXChannelOrder(device);
 190     return ALC_TRUE;
 191 }
 192
 193 static ALCboolean ALCsdl2Backend_start(ALCsdl2Backend *self)
 194 {
 195     SDL_PauseAudioDevice(self->deviceID, 0);
 196     return ALC_TRUE;
 197 }
 198
 199 static void ALCsdl2Backend_stop(ALCsdl2Backend *self)
 200 {
 201     SDL_PauseAudioDevice(self->deviceID, 1);
 202 }
 203
 204 static void ALCsdl2Backend_lock(ALCsdl2Backend *self)
 205 {
 206     SDL_LockAudioDevice(self->deviceID);
 207 }
 208
 209 static void ALCsdl2Backend_unlock(ALCsdl2Backend *self)
 210 {
 211     SDL_UnlockAudioDevice(self->deviceID);
 212 }
 213
 214
 215 BackendFactory &SDL2BackendFactory::getFactory()
 216 {
 217     static SDL2BackendFactory factory{};
 218     return factory;
 219 }
 220
 221 bool SDL2BackendFactory::init()
 222 {
 223     return (SDL_InitSubSystem(SDL_INIT_AUDIO) == 0);
 224 }
 225
 226 void SDL2BackendFactory::deinit()
 227 {
 228     SDL_QuitSubSystem(SDL_INIT_AUDIO);
 229 }
 230
 231 bool SDL2BackendFactory::querySupport(ALCbackend_Type type)
 232 {
 233     return (type == ALCbackend_Playback);
 234 }
 235
 236 void SDL2BackendFactory::probe(enum DevProbe type, std::string *outnames)
 237 {
 238     if(type != ALL_DEVICE_PROBE)
 239         return;
 240
 241     int num_devices{SDL_GetNumAudioDevices(SDL_FALSE)};
 242
 243     /* Includes null char. */
 244     outnames->append(defaultDeviceName, sizeof(defaultDeviceName));
 245     for(int i{0};i < num_devices;++i)
 246     {
 247         std::string name{DEVNAME_PREFIX};
 248         name += SDL_GetAudioDeviceName(i, SDL_FALSE);
 249         if(!name.empty())
 250             outnames->append(name.c_str(), name.length()+1);
 251     }
 252 }
 253
 254 ALCbackend *SDL2BackendFactory::createBackend(ALCdevice *device, ALCbackend_Type type)
 255 {
 256     if(type == ALCbackend_Playback)
 257     {
 258         ALCsdl2Backend *backend;
 259         NEW_OBJ(backend, ALCsdl2Backend)(device);
 260         if(!backend) return nullptr;
 261         return STATIC_CAST(ALCbackend, backend);
 262     }
 263
 264     return nullptr;
 265 }