src/context.h

   1 #ifndef CONTEXT_H
   2 #define CONTEXT_H
   3
   4 #include <condition_variable>
   5 #include <unordered_map>
   6 #include <stdexcept>
   7 #include <thread>
   8 #include <mutex>
   9 #include <stack>
  10 #include <queue>
  11 #include <set>
  12 #if __cplusplus >= 201703L
  13 #include <variant>
  14 #else
  15 #include "mpark/variant.hpp"
  16 #endif
  17
  18 #include "main.h"
  19
  20 #include "device.h"
  21 #include "source.h"
  22
  23
  24 #define F_PI (3.14159265358979323846f)
  25
  26 #if !(__cplusplus >= 201703L)
  27 namespace std {
  28 using mpark::variant;
  29 using mpark::get;
  30 using mpark::get_if;
  31 using mpark::holds_alternative;
  32 } // namespace std
  33 #endif
  34
  35 namespace alure {
  36
  37 enum class AL {
  38     EXT_EFX,
  39
  40     EXT_FLOAT32,
  41     EXT_MCFORMATS,
  42     EXT_BFORMAT,
  43
  44     EXT_MULAW,
  45     EXT_MULAW_MCFORMATS,
  46     EXT_MULAW_BFORMAT,
  47
  48     SOFT_loop_points,
  49     SOFT_source_latency,
  50     SOFT_source_resampler,
  51     SOFT_source_spatialize,
  52
  53     EXT_disconnect,
  54
  55     EXT_SOURCE_RADIUS,
  56     EXT_STEREO_ANGLES,
  57
  58     EXTENSION_MAX
  59 };
  60
  61 // Batches OpenAL updates while the object is alive, if batching isn't already
  62 // in progress.
  63 class Batcher {
  64     ALCcontext *mContext;
  65
  66 public:
  67     Batcher(ALCcontext *context) : mContext(context) { }
  68     Batcher(Batcher&& rhs) : mContext(rhs.mContext) { rhs.mContext = nullptr; }
  69     Batcher(const Batcher&) = delete;
  70     ~Batcher()
  71     {
  72         if(mContext)
  73             alcProcessContext(mContext);
  74     }
  75
  76     Batcher& operator=(Batcher&&) = delete;
  77     Batcher& operator=(const Batcher&) = delete;
  78 };
  79
  80
  81 class ListenerImpl {
  82     ContextImpl *const mContext;
  83
  84 public:
  85     ListenerImpl(ContextImpl *ctx) : mContext(ctx) { }
  86
  87     void setGain(ALfloat gain);
  88
  89     void set3DParameters(const Vector3 &position, const Vector3 &velocity, const std::pair<Vector3,Vector3> &orientation);
  90
  91     void setPosition(ALfloat x, ALfloat y, ALfloat z);
  92     void setPosition(const ALfloat *pos);
  93
  94     void setVelocity(ALfloat x, ALfloat y, ALfloat z);
  95     void setVelocity(const ALfloat *vel);
  96
  97     void setOrientation(ALfloat x1, ALfloat y1, ALfloat z1, ALfloat x2, ALfloat y2, ALfloat z2);
  98     void setOrientation(const ALfloat *at, const ALfloat *up);
  99     void setOrientation(const ALfloat *ori);
 100
 101     void setMetersPerUnit(ALfloat m_u);
 102 };
 103
 104
 105 using DecoderOrExceptT = std::variant<SharedPtr<Decoder>,std::runtime_error>;
 106 using BufferOrExceptT = std::variant<Buffer,std::runtime_error>;
 107
 108 class ContextImpl {
 109     static ContextImpl *sCurrentCtx;
 110     static thread_local ContextImpl *sThreadCurrentCtx;
 111
 112 public:
 113     static void MakeCurrent(ContextImpl *context);
 114     static ContextImpl *GetCurrent()
 115     {
 116         auto thrd_ctx = sThreadCurrentCtx;
 117         return thrd_ctx ? thrd_ctx : sCurrentCtx;
 118     }
 119
 120     static void MakeThreadCurrent(ContextImpl *context);
 121     static ContextImpl *GetThreadCurrent() { return sThreadCurrentCtx; }
 122
 123     static std::atomic<uint64_t> sContextSetCount;
 124     mutable uint64_t mContextSetCounter;
 125
 126 private:
 127     ListenerImpl mListener;
 128     ALCcontext *mContext;
 129     std::stack<ALuint> mSourceIds;
 130
 131     struct PendingFuture { BufferImpl *mBuffer;  SharedFuture<Buffer> mFuture; };
 132     struct PendingSource { SourceImpl *mSource;  SharedFuture<Buffer> mFuture; };
 133
 134     DeviceImpl *const mDevice;
 135     Vector<PendingFuture> mFutureBuffers;
 136     Vector<UniquePtr<BufferImpl>> mBuffers;
 137     Vector<UniquePtr<SourceGroupImpl>> mSourceGroups;
 138     std::deque<SourceImpl> mAllSources;
 139     Vector<SourceImpl*> mFreeSources;
 140
 141     Vector<PendingSource> mPendingSources;
 142     Vector<SourceImpl*> mFadingSources;
 143     Vector<SourceBufferUpdateEntry> mPlaySources;
 144     Vector<SourceStreamUpdateEntry> mStreamSources;
 145
 146     Vector<SourceImpl*> mStreamingSources;
 147     std::mutex mSourceStreamMutex;
 148
 149     std::atomic<std::chrono::milliseconds> mWakeInterval;
 150     std::mutex mWakeMutex;
 151     std::condition_variable mWakeThread;
 152
 153     SharedPtr<MessageHandler> mMessage;
 154
 155     struct PendingBuffer {
 156         BufferImpl *mBuffer{nullptr};
 157         SharedPtr<Decoder> mDecoder;
 158         ALenum mFormat{0};
 159         ALuint mFrames{0};
 160         Promise<Buffer> mPromise;
 161
 162         std::atomic<PendingBuffer*> mNext{nullptr};
 163
 164         PendingBuffer() = default;
 165         PendingBuffer(BufferImpl *buffer, SharedPtr<Decoder> decoder, ALenum format, ALuint frames,
 166                       Promise<Buffer> promise)
 167           : mBuffer(buffer), mDecoder(std::move(decoder)), mFormat(format), mFrames(frames)
 168           , mPromise(std::move(promise)), mNext(nullptr)
 169         { }
 170     };
 171     std::atomic<PendingBuffer*> mPendingCurrent;
 172     PendingBuffer *mPendingTail;
 173     PendingBuffer *mPendingHead;
 174
 175     std::atomic<bool> mQuitThread;
 176     std::thread mThread;
 177     void backgroundProc();
 178
 179     size_t mRefs;
 180
 181     Vector<String> mResamplers;
 182
 183     Bitfield<static_cast<size_t>(AL::EXTENSION_MAX)> mHasExt;
 184
 185     std::once_flag mSetExts;
 186     void setupExts();
 187
 188     DecoderOrExceptT findDecoder(StringView name);
 189     BufferOrExceptT doCreateBuffer(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder);
 190     BufferOrExceptT doCreateBufferAsync(StringView name, Vector<UniquePtr<BufferImpl>>::iterator iter, SharedPtr<Decoder> decoder, Promise<Buffer> promise);
 191
 192     bool mIsConnected : 1;
 193     bool mIsBatching : 1;
 194
 195 public:
 196     ContextImpl(ALCcontext *context, DeviceImpl *device);
 197     ~ContextImpl();
 198
 199     ALCcontext *getALCcontext() const { return mContext; }
 200     long addRef() { return ++mRefs; }
 201     long decRef() { return --mRefs; }
 202
 203     bool hasExtension(AL ext) const { return mHasExt[static_cast<size_t>(ext)]; }
 204
 205     LPALGETSTRINGISOFT alGetStringiSOFT;
 206     LPALGETSOURCEI64VSOFT alGetSourcei64vSOFT;
 207     LPALGETSOURCEDVSOFT alGetSourcedvSOFT;
 208
 209     LPALGENEFFECTS alGenEffects;
 210     LPALDELETEEFFECTS alDeleteEffects;
 211     LPALISEFFECT alIsEffect;
 212     LPALEFFECTI alEffecti;
 213     LPALEFFECTIV alEffectiv;
 214     LPALEFFECTF alEffectf;
 215     LPALEFFECTFV alEffectfv;
 216     LPALGETEFFECTI alGetEffecti;
 217     LPALGETEFFECTIV alGetEffectiv;
 218     LPALGETEFFECTF alGetEffectf;
 219     LPALGETEFFECTFV alGetEffectfv;
 220
 221     LPALGENFILTERS alGenFilters;
 222     LPALDELETEFILTERS alDeleteFilters;
 223     LPALISFILTER alIsFilter;
 224     LPALFILTERI alFilteri;
 225     LPALFILTERIV alFilteriv;
 226     LPALFILTERF alFilterf;
 227     LPALFILTERFV alFilterfv;
 228     LPALGETFILTERI alGetFilteri;
 229     LPALGETFILTERIV alGetFilteriv;
 230     LPALGETFILTERF alGetFilterf;
 231     LPALGETFILTERFV alGetFilterfv;
 232
 233     LPALGENAUXILIARYEFFECTSLOTS alGenAuxiliaryEffectSlots;
 234     LPALDELETEAUXILIARYEFFECTSLOTS alDeleteAuxiliaryEffectSlots;
 235     LPALISAUXILIARYEFFECTSLOT alIsAuxiliaryEffectSlot;
 236     LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti;
 237     LPALAUXILIARYEFFECTSLOTIV alAuxiliaryEffectSlotiv;
 238     LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf;
 239     LPALAUXILIARYEFFECTSLOTFV alAuxiliaryEffectSlotfv;
 240     LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti;
 241     LPALGETAUXILIARYEFFECTSLOTIV alGetAuxiliaryEffectSlotiv;
 242     LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf;
 243     LPALGETAUXILIARYEFFECTSLOTFV alGetAuxiliaryEffectSlotfv;
 244
 245     ALuint getSourceId(ALuint maxprio);
 246     void insertSourceId(ALuint id) { mSourceIds.push(id); }
 247
 248     void addPendingSource(SourceImpl *source, SharedFuture<Buffer> future);
 249     void removePendingSource(SourceImpl *source);
 250     bool isPendingSource(const SourceImpl *source) const;
 251     void addFadingSource(SourceImpl *source);
 252     void removeFadingSource(SourceImpl *source);
 253     void addPlayingSource(SourceImpl *source, ALuint id);
 254     void addPlayingSource(SourceImpl *source);
 255     void removePlayingSource(SourceImpl *source);
 256
 257     void addStream(SourceImpl *source);
 258     void removeStream(SourceImpl *source);
 259     void removeStreamNoLock(SourceImpl *source);
 260
 261     void freeSource(SourceImpl *source) { mFreeSources.push_back(source); }
 262     void freeSourceGroup(SourceGroupImpl *group);
 263
 264     Batcher getBatcher()
 265     {
 266         if(mIsBatching)
 267             return Batcher(nullptr);
 268         alcSuspendContext(mContext);
 269         return Batcher(mContext);
 270     }
 271
 272     std::unique_lock<std::mutex> getSourceStreamLock()
 273     { return std::unique_lock<std::mutex>(mSourceStreamMutex); }
 274
 275     template<typename R, typename... Args>
 276     void send(R MessageHandler::* func, Args&&... args)
 277     { if(mMessage.get()) (mMessage.get()->*func)(std::forward<Args>(args)...); }
 278
 279     Device getDevice() { return Device(mDevice); }
 280
 281     void destroy();
 282
 283     void startBatch();
 284     void endBatch();
 285
 286     Listener getListener() { return Listener(&mListener); }
 287
 288     SharedPtr<MessageHandler> setMessageHandler(SharedPtr<MessageHandler>&& handler);
 289     SharedPtr<MessageHandler> getMessageHandler() const { return mMessage; }
 290
 291     void setAsyncWakeInterval(std::chrono::milliseconds interval);
 292     std::chrono::milliseconds getAsyncWakeInterval() const { return mWakeInterval.load(); }
 293
 294     SharedPtr<Decoder> createDecoder(StringView name);
 295
 296     bool isSupported(ChannelConfig channels, SampleType type) const;
 297
 298     ArrayView<String> getAvailableResamplers();
 299     ALsizei getDefaultResamplerIndex() const;
 300
 301     Buffer getBuffer(StringView name);
 302     SharedFuture<Buffer> getBufferAsync(StringView name);
 303     void precacheBuffersAsync(ArrayView<StringView> names);
 304     Buffer createBufferFrom(StringView name, SharedPtr<Decoder>&& decoder);
 305     SharedFuture<Buffer> createBufferAsyncFrom(StringView name, SharedPtr<Decoder>&& decoder);
 306     Buffer findBuffer(StringView name);
 307     SharedFuture<Buffer> findBufferAsync(StringView name);
 308     void removeBuffer(StringView name);
 309     void removeBuffer(Buffer buffer) { removeBuffer(buffer.getName()); }
 310
 311     Source createSource();
 312
 313     AuxiliaryEffectSlot createAuxiliaryEffectSlot();
 314
 315     Effect createEffect();
 316
 317     SourceGroup createSourceGroup(StringView name);
 318     SourceGroup getSourceGroup(StringView name);
 319
 320     void setDopplerFactor(ALfloat factor);
 321
 322     void setSpeedOfSound(ALfloat speed);
 323
 324     void setDistanceModel(DistanceModel model);
 325
 326     void update();
 327 };
 328
 329
 330 inline void CheckContext(const ContextImpl *ctx)
 331 {
 332     auto count = ContextImpl::sContextSetCount.load(std::memory_order_acquire);
 333     if(UNLIKELY(count != ctx->mContextSetCounter))
 334     {
 335         if(UNLIKELY(ctx != ContextImpl::GetCurrent()))
 336             throw std::runtime_error("Called context is not current");
 337         ctx->mContextSetCounter = count;
 338     }
 339 }
 340
 341 inline void CheckContexts(const ContextImpl *ctx0, const ContextImpl *ctx1)
 342 {
 343     if(UNLIKELY(ctx0 != ctx1))
 344         throw std::runtime_error("Mismatched object contexts");
 345 }
 346
 347
 348 } // namespace alure
 349
 350 #endif /* CONTEXT_H */