src/device.cpp

   1
   2 #include "config.h"
   3
   4 #include "device.h"
   5
   6 #include <string.h>
   7
   8 #include <stdexcept>
   9 #include <algorithm>
  10
  11 #include "alc.h"
  12 #include "alext.h"
  13
  14 #include "devicemanager.h"
  15 #include "context.h"
  16 #include "buffer.h"
  17
  18
  19 namespace alure
  20 {
  21
  22 template<typename T>
  23 static inline void LoadALCFunc(ALCdevice *device, T **func, const char *name)
  24 { *func = reinterpret_cast<T*>(alcGetProcAddress(device, name)); }
  25
  26
  27 static void LoadPauseDevice(ALDevice *device)
  28 {
  29     LoadALCFunc(device->getDevice(), &device->alcDevicePauseSOFT, "alcDevicePauseSOFT");
  30     LoadALCFunc(device->getDevice(), &device->alcDeviceResumeSOFT, "alcDeviceResumeSOFT");
  31 }
  32
  33 static void LoadHrtf(ALDevice *device)
  34 {
  35     LoadALCFunc(device->getDevice(), &device->alcGetStringiSOFT, "alcGetStringiSOFT");
  36     LoadALCFunc(device->getDevice(), &device->alcResetDeviceSOFT, "alcResetDeviceSOFT");
  37 }
  38
  39 static void LoadNothing(ALDevice*) { }
  40
  41 static const struct {
  42     enum ALCExtension extension;
  43     const char name[32];
  44     void (&loader)(ALDevice*);
  45 } ALCExtensionList[] = {
  46     { EXT_thread_local_context, "ALC_EXT_thread_local_context", LoadNothing },
  47     { SOFT_device_pause, "ALC_SOFT_pause_device", LoadPauseDevice },
  48     { SOFT_HRTF, "ALC_SOFT_HRTF", LoadHrtf },
  49 };
  50
  51
  52 void ALDevice::setupExts()
  53 {
  54     std::fill(std::begin(mHasExt), std::end(mHasExt), false);
  55     for(const auto &entry : ALCExtensionList)
  56     {
  57         mHasExt[entry.extension] = alcIsExtensionPresent(mDevice, entry.name);
  58         if(mHasExt[entry.extension]) entry.loader(this);
  59     }
  60 }
  61
  62
  63 ALDevice::ALDevice(ALCdevice* device)
  64   : mDevice(device), alcDevicePauseSOFT(nullptr), alcDeviceResumeSOFT(nullptr)
  65 {
  66     setupExts();
  67 }
  68
  69 ALDevice::~ALDevice()
  70 {
  71 }
  72
  73
  74 void ALDevice::removeContext(ALContext *ctx)
  75 {
  76     auto iter = std::find_if(mContexts.begin(), mContexts.end(),
  77         [ctx](const UniquePtr<ALContext> &entry) -> bool
  78         { return entry.get() == ctx; }
  79     );
  80     if(iter != mContexts.end()) mContexts.erase(iter);
  81 }
  82
  83
  84 String ALDevice::getName(PlaybackName type) const
  85 {
  86     if(type == PlaybackName::Full && !alcIsExtensionPresent(mDevice, "ALC_ENUMERATE_ALL_EXT"))
  87         type = PlaybackName::Basic;
  88     alcGetError(mDevice);
  89     const ALCchar *name = alcGetString(mDevice, (ALenum)type);
  90     if(alcGetError(mDevice) != ALC_NO_ERROR || !name)
  91         name = alcGetString(mDevice, (ALenum)PlaybackName::Basic);
  92     return name ? String(name) : String();
  93 }
  94
  95 bool ALDevice::queryExtension(const String &name) const
  96 {
  97     return alcIsExtensionPresent(mDevice, name.c_str());
  98 }
  99
 100 ALCuint ALDevice::getALCVersion() const
 101 {
 102     ALCint major=-1, minor=-1;
 103     alcGetIntegerv(mDevice, ALC_MAJOR_VERSION, 1, &major);
 104     alcGetIntegerv(mDevice, ALC_MINOR_VERSION, 1, &minor);
 105     if(major < 0 || minor < 0)
 106         throw std::runtime_error("ALC version error");
 107     return MakeVersion(
 108         (ALCushort)std::min<ALCint>(major, std::numeric_limits<ALCushort>::max()),
 109         (ALCushort)std::min<ALCint>(minor, std::numeric_limits<ALCushort>::max())
 110     );
 111 }
 112
 113 ALCuint ALDevice::getEFXVersion() const
 114 {
 115     if(!alcIsExtensionPresent(mDevice, "ALC_EXT_EFX"))
 116         return 0;
 117
 118     ALCint major=-1, minor=-1;
 119     alcGetIntegerv(mDevice, ALC_EFX_MAJOR_VERSION, 1, &major);
 120     alcGetIntegerv(mDevice, ALC_EFX_MINOR_VERSION, 1, &minor);
 121     if(major < 0 || minor < 0)
 122         throw std::runtime_error("EFX version error");
 123     return MakeVersion(
 124         (ALCushort)std::min<ALCint>(major, std::numeric_limits<ALCushort>::max()),
 125         (ALCushort)std::min<ALCint>(minor, std::numeric_limits<ALCushort>::max())
 126     );
 127 }
 128
 129 ALCuint ALDevice::getFrequency() const
 130 {
 131     ALCint freq = -1;
 132     alcGetIntegerv(mDevice, ALC_FREQUENCY, 1, &freq);
 133     if(freq < 0)
 134         throw std::runtime_error("Frequency error");
 135     return freq;
 136 }
 137
 138 ALCuint ALDevice::getMaxAuxiliarySends() const
 139 {
 140     if(!alcIsExtensionPresent(mDevice, "ALC_EXT_EFX"))
 141         return 0;
 142
 143     ALCint sends=-1;
 144     alcGetIntegerv(mDevice, ALC_MAX_AUXILIARY_SENDS, 1, &sends);
 145     if(sends < 0)
 146         throw std::runtime_error("Max auxiliary sends error");
 147     return sends;
 148 }
 149
 150
 151 Vector<String> ALDevice::enumerateHRTFNames() const
 152 {
 153     if(!hasExtension(SOFT_HRTF))
 154         throw std::runtime_error("ALC_SOFT_HRTF not supported");
 155
 156     ALCint num_hrtfs = -1;
 157     alcGetIntegerv(mDevice, ALC_NUM_HRTF_SPECIFIERS_SOFT, 1, &num_hrtfs);
 158     if(num_hrtfs < 0)
 159         throw std::runtime_error("HRTF specifier count error");
 160
 161     Vector<String> hrtfs;
 162     hrtfs.reserve(num_hrtfs);
 163     for(int i = 0;i < num_hrtfs;++i)
 164         hrtfs.emplace_back(alcGetStringiSOFT(mDevice, ALC_HRTF_SPECIFIER_SOFT, i));
 165     return hrtfs;
 166 }
 167
 168 bool ALDevice::isHRTFEnabled() const
 169 {
 170     if(!hasExtension(SOFT_HRTF))
 171         throw std::runtime_error("ALC_SOFT_HRTF not supported");
 172
 173     ALCint hrtf_state = -1;
 174     alcGetIntegerv(mDevice, ALC_HRTF_SOFT, 1, &hrtf_state);
 175     if(hrtf_state == -1)
 176         throw std::runtime_error("HRTF state error");
 177     return hrtf_state != ALC_FALSE;
 178 }
 179
 180 String ALDevice::getCurrentHRTF() const
 181 {
 182     if(!hasExtension(SOFT_HRTF))
 183         throw std::runtime_error("ALC_SOFT_HRTF not supported");
 184     return String(alcGetString(mDevice, ALC_HRTF_SPECIFIER_SOFT));
 185 }
 186
 187 void ALDevice::reset(ArrayView<AttributePair> attributes)
 188 {
 189     if(!hasExtension(SOFT_HRTF))
 190         throw std::runtime_error("ALC_SOFT_HRTF not supported");
 191     auto do_reset = [this, &attributes]() -> ALCboolean
 192     {
 193         if(attributes.empty())
 194         {
 195             /* No explicit attributes. */
 196             return alcResetDeviceSOFT(mDevice, nullptr);
 197         }
 198         auto attr_end = std::find_if(attributes.begin(), attributes.end(),
 199             [](const AttributePair &attr) -> bool
 200             { return std::get<0>(attr) == 0; }
 201         );
 202         if(attr_end == attributes.end())
 203         {
 204             /* Attribute list was not properly terminated. Copy the attribute
 205              * list and add the 0 sentinel.
 206              */
 207             Vector<AttributePair> attrs;
 208             attrs.reserve(attributes.size());
 209             std::copy(attributes.begin(), attributes.end(), std::back_inserter(attrs));
 210             attrs.push_back({0, 0});
 211             return alcResetDeviceSOFT(mDevice, &std::get<0>(attrs.front()));
 212         }
 213         return alcResetDeviceSOFT(mDevice, &std::get<0>(attributes.front()));
 214     };
 215     if(!do_reset())
 216         throw std::runtime_error("Device reset error");
 217 }
 218
 219
 220 Context ALDevice::createContext(ArrayView<AttributePair> attributes)
 221 {
 222     ALCcontext *ctx = [this, &attributes]() -> ALCcontext*
 223     {
 224         if(attributes.empty())
 225         {
 226             /* No explicit attributes. */
 227             return alcCreateContext(mDevice, nullptr);
 228         }
 229         auto attr_end = std::find_if(attributes.begin(), attributes.end(),
 230             [](const AttributePair &attr) -> bool
 231             { return std::get<0>(attr) == 0; }
 232         );
 233         if(attr_end == attributes.end())
 234         {
 235             /* Attribute list was not properly terminated. Copy the attribute
 236              * list and add the 0 sentinel.
 237              */
 238             Vector<AttributePair> attrs;
 239             attrs.reserve(attributes.size());
 240             std::copy(attributes.begin(), attributes.end(), std::back_inserter(attrs));
 241             attrs.push_back({0, 0});
 242             return alcCreateContext(mDevice, &std::get<0>(attrs.front()));
 243         }
 244         return alcCreateContext(mDevice, &std::get<0>(attributes.front()));
 245     }();
 246     if(!ctx) throw std::runtime_error("Failed to create context");
 247
 248     mContexts.emplace_back(MakeUnique<ALContext>(ctx, this));
 249     return Context(mContexts.back().get());
 250 }
 251
 252
 253 void ALDevice::pauseDSP()
 254 {
 255     if(!hasExtension(SOFT_device_pause))
 256        throw std::runtime_error("ALC_SOFT_pause_device not supported");
 257     alcDevicePauseSOFT(mDevice);
 258 }
 259
 260 void ALDevice::resumeDSP()
 261 {
 262     if(hasExtension(SOFT_device_pause))
 263         alcDeviceResumeSOFT(mDevice);
 264 }
 265
 266
 267 void ALDevice::close()
 268 {
 269     if(!mContexts.empty())
 270         throw std::runtime_error("Trying to close device with contexts");
 271
 272     if(alcCloseDevice(mDevice) == ALC_FALSE)
 273         throw std::runtime_error("Failed to close device");
 274     mDevice = 0;
 275
 276     ALDeviceManager::get().removeDevice(this);
 277 }
 278
 279
 280 DECL_THUNK1(String, Device, getName, const, PlaybackName)
 281 DECL_THUNK1(bool, Device, queryExtension, const, const String&)
 282 DECL_THUNK0(ALCuint, Device, getALCVersion, const)
 283 DECL_THUNK0(ALCuint, Device, getEFXVersion, const)
 284 DECL_THUNK0(ALCuint, Device, getFrequency, const)
 285 DECL_THUNK0(ALCuint, Device, getMaxAuxiliarySends, const)
 286 DECL_THUNK0(Vector<String>, Device, enumerateHRTFNames, const)
 287 DECL_THUNK0(bool, Device, isHRTFEnabled, const)
 288 DECL_THUNK0(String, Device, getCurrentHRTF, const)
 289 DECL_THUNK1(void, Device, reset,, ArrayView<AttributePair>)
 290 DECL_THUNK1(Context, Device, createContext,, ArrayView<AttributePair>)
 291 DECL_THUNK0(void, Device, pauseDSP,)
 292 DECL_THUNK0(void, Device, resumeDSP,)
 293 void Device::close()
 294 {
 295     pImpl->close();
 296     pImpl = nullptr;
 297 }
 298
 299 }