alc/events.cpp

   1
   2 #include "config.h"
   3
   4 #include "events.h"
   5
   6 #include "alspan.h"
   7 #include "core/logging.h"
   8 #include "device.h"
   9
  10
  11 namespace {
  12
  13 ALCenum EnumFromEventType(const alc::EventType type)
  14 {
  15     switch(type)
  16     {
  17     case alc::EventType::DefaultDeviceChanged: return ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT;
  18     case alc::EventType::DeviceAdded: return ALC_EVENT_TYPE_DEVICE_ADDED_SOFT;
  19     case alc::EventType::DeviceRemoved: return ALC_EVENT_TYPE_DEVICE_REMOVED_SOFT;
  20     case alc::EventType::Count: break;
  21     }
  22     throw std::runtime_error{"Invalid EventType: "+std::to_string(al::to_underlying(type))};
  23 }
  24
  25 } // namespace
  26
  27 namespace alc {
  28
  29 std::optional<alc::EventType> GetEventType(ALCenum type)
  30 {
  31     switch(type)
  32     {
  33     case ALC_EVENT_TYPE_DEFAULT_DEVICE_CHANGED_SOFT: return alc::EventType::DefaultDeviceChanged;
  34     case ALC_EVENT_TYPE_DEVICE_ADDED_SOFT: return alc::EventType::DeviceAdded;
  35     case ALC_EVENT_TYPE_DEVICE_REMOVED_SOFT: return alc::EventType::DeviceRemoved;
  36     }
  37     return std::nullopt;
  38 }
  39
  40 void Event(EventType eventType, DeviceType deviceType, ALCdevice *device, std::string_view message) noexcept
  41 {
  42     auto eventlock = std::unique_lock{EventMutex};
  43     if(EventCallback && EventsEnabled.test(al::to_underlying(eventType)))
  44         EventCallback(EnumFromEventType(eventType), al::to_underlying(deviceType), device,
  45             static_cast<ALCsizei>(message.length()), message.data(), EventUserPtr);
  46 }
  47
  48 } // namespace alc
  49
  50 FORCE_ALIGN ALCboolean ALC_APIENTRY alcEventControlSOFT(ALCsizei count, const ALCenum *events,
  51     ALCboolean enable) noexcept
  52 {
  53     if(enable != ALC_FALSE && enable != ALC_TRUE)
  54     {
  55         alcSetError(nullptr, ALC_INVALID_ENUM);
  56         return ALC_FALSE;
  57     }
  58     if(count < 0)
  59     {
  60         alcSetError(nullptr, ALC_INVALID_VALUE);
  61         return ALC_FALSE;
  62     }
  63     if(count == 0)
  64         return ALC_TRUE;
  65     if(!events)
  66     {
  67         alcSetError(nullptr, ALC_INVALID_VALUE);
  68         return ALC_FALSE;
  69     }
  70
  71     alc::EventBitSet eventSet{0};
  72     for(ALCenum type : al::span{events, static_cast<ALCuint>(count)})
  73     {
  74         auto etype = alc::GetEventType(type);
  75         if(!etype)
  76         {
  77             WARN("Invalid event type: 0x%04x\n", type);
  78             alcSetError(nullptr, ALC_INVALID_ENUM);
  79             return ALC_FALSE;
  80         }
  81         eventSet.set(al::to_underlying(*etype));
  82     }
  83
  84     auto eventlock = std::unique_lock{alc::EventMutex};
  85     if(enable) alc::EventsEnabled |= eventSet;
  86     else alc::EventsEnabled &= ~eventSet;
  87     return ALC_TRUE;
  88 }
  89
  90 FORCE_ALIGN void ALC_APIENTRY alcEventCallbackSOFT(ALCEVENTPROCTYPESOFT callback, void *userParam) noexcept
  91 {
  92     auto eventlock = std::unique_lock{alc::EventMutex};
  93     alc::EventCallback = callback;
  94     alc::EventUserPtr = userParam;
  95 }