Alc/alcontext.h

   1 #ifndef ALCONTEXT_H
   2 #define ALCONTEXT_H
   3
   4 #include <mutex>
   5 #include <atomic>
   6 #include <memory>
   7 #include <thread>
   8
   9 #include "AL/al.h"
  10 #include "AL/alc.h"
  11 #include "AL/alext.h"
  12 #include "inprogext.h"
  13
  14 #include "atomic.h"
  15 #include "vector.h"
  16 #include "threads.h"
  17 #include "almalloc.h"
  18
  19 #include "alListener.h"
  20
  21
  22 struct ALsource;
  23 struct ALeffectslot;
  24 struct ALcontextProps;
  25 struct ALlistenerProps;
  26 struct ALvoiceProps;
  27 struct ALeffectslotProps;
  28 struct ALvoice;
  29 struct ALeffectslotArray;
  30 struct ll_ringbuffer;
  31
  32 enum class DistanceModel {
  33     InverseClamped  = AL_INVERSE_DISTANCE_CLAMPED,
  34     LinearClamped   = AL_LINEAR_DISTANCE_CLAMPED,
  35     ExponentClamped = AL_EXPONENT_DISTANCE_CLAMPED,
  36     Inverse  = AL_INVERSE_DISTANCE,
  37     Linear   = AL_LINEAR_DISTANCE,
  38     Exponent = AL_EXPONENT_DISTANCE,
  39     Disable  = AL_NONE,
  40
  41     Default = InverseClamped
  42 };
  43
  44 struct SourceSubList {
  45     uint64_t FreeMask{0u};
  46     ALsource *Sources{nullptr}; /* 64 */
  47 };
  48
  49 /* Effect slots are rather large, and apps aren't likely to have more than one
  50  * or two (let alone 64), so hold them individually.
  51  */
  52 using ALeffectslotPtr = std::unique_ptr<ALeffectslot>;
  53
  54 struct ALCcontext_struct {
  55     RefCount ref{1u};
  56
  57     al::vector<SourceSubList> SourceList;
  58     ALuint NumSources{0};
  59     almtx_t SourceLock;
  60
  61     al::vector<ALeffectslotPtr> EffectSlotList;
  62     almtx_t EffectSlotLock;
  63
  64     ATOMIC(ALenum) LastError{AL_NO_ERROR};
  65
  66     DistanceModel mDistanceModel{DistanceModel::Default};
  67     ALboolean SourceDistanceModel{AL_FALSE};
  68
  69     ALfloat DopplerFactor{1.0f};
  70     ALfloat DopplerVelocity{1.0f};
  71     ALfloat SpeedOfSound{};
  72     ALfloat MetersPerUnit{1.0f};
  73
  74     std::atomic_flag PropsClean{true};
  75     std::atomic<bool> DeferUpdates{false};
  76
  77     almtx_t PropLock;
  78
  79     /* Counter for the pre-mixing updates, in 31.1 fixed point (lowest bit
  80      * indicates if updates are currently happening).
  81      */
  82     RefCount UpdateCount{0u};
  83     ATOMIC(ALenum) HoldUpdates{AL_FALSE};
  84
  85     ALfloat GainBoost{1.0f};
  86
  87     ATOMIC(ALcontextProps*) Update{nullptr};
  88
  89     /* Linked lists of unused property containers, free to use for future
  90      * updates.
  91      */
  92     ATOMIC(ALcontextProps*) FreeContextProps{nullptr};
  93     ATOMIC(ALlistenerProps*) FreeListenerProps{nullptr};
  94     ATOMIC(ALvoiceProps*) FreeVoiceProps{nullptr};
  95     ATOMIC(ALeffectslotProps*) FreeEffectslotProps{nullptr};
  96
  97     ALvoice **Voices{nullptr};
  98     ALsizei VoiceCount{0};
  99     ALsizei MaxVoices{0};
 100
 101     ATOMIC(ALeffectslotArray*) ActiveAuxSlots{nullptr};
 102
 103     std::thread EventThread;
 104     alsem_t EventSem;
 105     ll_ringbuffer *AsyncEvents{nullptr};
 106     ATOMIC(ALbitfieldSOFT) EnabledEvts{0u};
 107     std::mutex EventCbLock;
 108     ALEVENTPROCSOFT EventCb{};
 109     void *EventParam{nullptr};
 110
 111     /* Default effect slot */
 112     std::unique_ptr<ALeffectslot> DefaultSlot;
 113
 114     ALCdevice *const Device;
 115     const ALCchar *ExtensionList{nullptr};
 116
 117     ATOMIC(ALCcontext*) next{nullptr};
 118
 119     ALlistener Listener{};
 120
 121
 122     ALCcontext_struct(ALCdevice *device);
 123     ALCcontext_struct(const ALCcontext_struct&) = delete;
 124     ALCcontext_struct& operator=(const ALCcontext_struct&) = delete;
 125     ~ALCcontext_struct();
 126
 127     DEF_NEWDEL(ALCcontext)
 128 };
 129
 130 ALCcontext *GetContextRef(void);
 131 void ALCcontext_DecRef(ALCcontext *context);
 132
 133 void UpdateContextProps(ALCcontext *context);
 134
 135 void ALCcontext_DeferUpdates(ALCcontext *context);
 136 void ALCcontext_ProcessUpdates(ALCcontext *context);
 137
 138
 139 /* Simple RAII context reference. Takes the reference of the provided
 140  * ALCcontext, and decrements it when leaving scope. Movable (transfer
 141  * reference) but not copyable (no new references).
 142  */
 143 class ContextRef {
 144     ALCcontext *mCtx{nullptr};
 145
 146     void reset() noexcept
 147     {
 148         if(mCtx)
 149             ALCcontext_DecRef(mCtx);
 150         mCtx = nullptr;
 151     }
 152
 153 public:
 154     ContextRef() noexcept = default;
 155     ContextRef(ContextRef&& rhs) noexcept : mCtx{rhs.mCtx}
 156     { rhs.mCtx = nullptr; }
 157     explicit ContextRef(ALCcontext *ctx) noexcept : mCtx(ctx) { }
 158     ~ContextRef() { reset(); }
 159
 160     ContextRef& operator=(const ContextRef&) = delete;
 161     ContextRef& operator=(ContextRef&& rhs) noexcept
 162     {
 163         reset();
 164         mCtx = rhs.mCtx;
 165         rhs.mCtx = nullptr;
 166         return *this;
 167     }
 168
 169     operator bool() const noexcept { return mCtx != nullptr; }
 170
 171     ALCcontext* operator->() noexcept { return mCtx; }
 172     ALCcontext* get() noexcept { return mCtx; }
 173
 174     ALCcontext* release() noexcept
 175     {
 176         ALCcontext *ret{mCtx};
 177         mCtx = nullptr;
 178         return ret;
 179     }
 180 };
 181
 182
 183 struct ALcontextProps {
 184     ALfloat DopplerFactor;
 185     ALfloat DopplerVelocity;
 186     ALfloat SpeedOfSound;
 187     ALboolean SourceDistanceModel;
 188     DistanceModel mDistanceModel;
 189     ALfloat MetersPerUnit;
 190
 191     ATOMIC(struct ALcontextProps*) next;
 192 };
 193
 194 #endif /* ALCONTEXT_H */