src/context.h

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