OpenAL32/event.cpp

   1
   2 #include "config.h"
   3
   4 #include <algorithm>
   5
   6 #include "AL/alc.h"
   7 #include "AL/al.h"
   8 #include "AL/alext.h"
   9
  10 #include "alMain.h"
  11 #include "alcontext.h"
  12 #include "alError.h"
  13 #include "alAuxEffectSlot.h"
  14 #include "ringbuffer.h"
  15 #include "threads.h"
  16
  17
  18 static int EventThread(ALCcontext *context)
  19 {
  20     bool quitnow{false};
  21     while(LIKELY(!quitnow))
  22     {
  23         AsyncEvent evt;
  24         if(ll_ringbuffer_read(context->AsyncEvents, &evt, 1) == 0)
  25         {
  26             alsem_wait(&context->EventSem);
  27             continue;
  28         }
  29
  30         std::lock_guard<std::mutex> _{context->EventCbLock};
  31         do {
  32             quitnow = evt.EnumType == EventType_KillThread;
  33             if(UNLIKELY(quitnow)) break;
  34
  35             if(evt.EnumType == EventType_ReleaseEffectState)
  36             {
  37                 evt.u.mEffectState->DecRef();
  38                 continue;
  39             }
  40
  41             ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_acquire)};
  42             if(context->EventCb && (enabledevts&evt.EnumType) == evt.EnumType)
  43                 context->EventCb(evt.u.user.type, evt.u.user.id, evt.u.user.param,
  44                     (ALsizei)strlen(evt.u.user.msg), evt.u.user.msg, context->EventParam
  45                 );
  46         } while(ll_ringbuffer_read(context->AsyncEvents, &evt, 1) != 0);
  47     }
  48     return 0;
  49 }
  50
  51 void StartEventThrd(ALCcontext *ctx)
  52 {
  53     try {
  54         ctx->EventThread = std::thread(EventThread, ctx);
  55     }
  56     catch(std::exception& e) {
  57         ERR("Failed to start event thread: %s\n", e.what());
  58     }
  59     catch(...) {
  60         ERR("Failed to start event thread! Expect problems.\n");
  61     }
  62 }
  63
  64 void StopEventThrd(ALCcontext *ctx)
  65 {
  66     static constexpr AsyncEvent kill_evt = ASYNC_EVENT(EventType_KillThread);
  67     while(ll_ringbuffer_write(ctx->AsyncEvents, &kill_evt, 1) == 0)
  68         althrd_yield();
  69     alsem_post(&ctx->EventSem);
  70     if(ctx->EventThread.joinable())
  71         ctx->EventThread.join();
  72 }
  73
  74 AL_API void AL_APIENTRY alEventControlSOFT(ALsizei count, const ALenum *types, ALboolean enable)
  75 {
  76     ContextRef context{GetContextRef()};
  77     if(UNLIKELY(!context)) return;
  78
  79     if(count < 0) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "Controlling %d events", count);
  80     if(count == 0) return;
  81     if(!types) SETERR_RETURN(context.get(), AL_INVALID_VALUE,, "NULL pointer");
  82
  83     ALbitfieldSOFT flags{0};
  84     const ALenum *types_end = types+count;
  85     auto bad_type = std::find_if_not(types, types_end,
  86         [&flags](ALenum type) noexcept -> bool
  87         {
  88             if(type == AL_EVENT_TYPE_BUFFER_COMPLETED_SOFT)
  89                 flags |= EventType_BufferCompleted;
  90             else if(type == AL_EVENT_TYPE_SOURCE_STATE_CHANGED_SOFT)
  91                 flags |= EventType_SourceStateChange;
  92             else if(type == AL_EVENT_TYPE_ERROR_SOFT)
  93                 flags |= EventType_Error;
  94             else if(type == AL_EVENT_TYPE_PERFORMANCE_SOFT)
  95                 flags |= EventType_Performance;
  96             else if(type == AL_EVENT_TYPE_DEPRECATED_SOFT)
  97                 flags |= EventType_Deprecated;
  98             else if(type == AL_EVENT_TYPE_DISCONNECTED_SOFT)
  99                 flags |= EventType_Disconnected;
 100             else
 101                 return false;
 102             return true;
 103         }
 104     );
 105     if(bad_type != types_end)
 106         SETERR_RETURN(context.get(), AL_INVALID_ENUM,, "Invalid event type 0x%04x", *bad_type);
 107
 108     if(enable)
 109     {
 110         ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
 111         while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts|flags,
 112             std::memory_order_acq_rel, std::memory_order_acquire) == 0)
 113         {
 114             /* enabledevts is (re-)filled with the current value on failure, so
 115              * just try again.
 116              */
 117         }
 118     }
 119     else
 120     {
 121         ALbitfieldSOFT enabledevts{context->EnabledEvts.load(std::memory_order_relaxed)};
 122         while(context->EnabledEvts.compare_exchange_weak(enabledevts, enabledevts&~flags,
 123             std::memory_order_acq_rel, std::memory_order_acquire) == 0)
 124         {
 125         }
 126         /* Wait to ensure the event handler sees the changed flags before
 127          * returning.
 128          */
 129         std::lock_guard<std::mutex>{context->EventCbLock};
 130     }
 131 }
 132
 133 AL_API void AL_APIENTRY alEventCallbackSOFT(ALEVENTPROCSOFT callback, void *userParam)
 134 {
 135     ContextRef context{GetContextRef()};
 136     if(UNLIKELY(!context)) return;
 137
 138     std::lock_guard<almtx_t> _{context->PropLock};
 139     std::lock_guard<std::mutex> __{context->EventCbLock};
 140     context->EventCb = callback;
 141     context->EventParam = userParam;
 142 }