alc/context.h

   1 #ifndef ALC_CONTEXT_H
   2 #define ALC_CONTEXT_H
   3
   4 #include <atomic>
   5 #include <memory>
   6 #include <mutex>
   7 #include <stdint.h>
   8 #include <utility>
   9
  10 #include "AL/al.h"
  11 #include "AL/alc.h"
  12 #include "AL/alext.h"
  13
  14 #include "al/listener.h"
  15 #include "almalloc.h"
  16 #include "alnumeric.h"
  17 #include "atomic.h"
  18 #include "core/context.h"
  19 #include "intrusive_ptr.h"
  20 #include "vector.h"
  21
  22 #ifdef ALSOFT_EAX
  23 #include "al/eax_eax_call.h"
  24 #include "al/eax_fx_slot_index.h"
  25 #include "al/eax_fx_slots.h"
  26 #include "al/eax_utils.h"
  27
  28
  29 using EaxContextSharedDirtyFlagsValue = std::uint_least8_t;
  30
  31 struct EaxContextSharedDirtyFlags
  32 {
  33     using EaxIsBitFieldStruct = bool;
  34
  35     EaxContextSharedDirtyFlagsValue primary_fx_slot_id : 1;
  36 }; // EaxContextSharedDirtyFlags
  37
  38
  39 using ContextDirtyFlagsValue = std::uint_least8_t;
  40
  41 struct ContextDirtyFlags
  42 {
  43     using EaxIsBitFieldStruct = bool;
  44
  45     ContextDirtyFlagsValue guidPrimaryFXSlotID : 1;
  46     ContextDirtyFlagsValue flDistanceFactor : 1;
  47     ContextDirtyFlagsValue flAirAbsorptionHF : 1;
  48     ContextDirtyFlagsValue flHFReference : 1;
  49     ContextDirtyFlagsValue flMacroFXFactor : 1;
  50 }; // ContextDirtyFlags
  51
  52
  53 struct EaxAlIsExtensionPresentResult
  54 {
  55     ALboolean is_present;
  56     bool is_return;
  57 }; // EaxAlIsExtensionPresentResult
  58 #endif // ALSOFT_EAX
  59
  60 struct ALeffect;
  61 struct ALeffectslot;
  62 struct ALsource;
  63
  64 using uint = unsigned int;
  65
  66
  67 struct SourceSubList {
  68     uint64_t FreeMask{~0_u64};
  69     ALsource *Sources{nullptr}; /* 64 */
  70
  71     SourceSubList() noexcept = default;
  72     SourceSubList(const SourceSubList&) = delete;
  73     SourceSubList(SourceSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Sources{rhs.Sources}
  74     { rhs.FreeMask = ~0_u64; rhs.Sources = nullptr; }
  75     ~SourceSubList();
  76
  77     SourceSubList& operator=(const SourceSubList&) = delete;
  78     SourceSubList& operator=(SourceSubList&& rhs) noexcept
  79     { std::swap(FreeMask, rhs.FreeMask); std::swap(Sources, rhs.Sources); return *this; }
  80 };
  81
  82 struct EffectSlotSubList {
  83     uint64_t FreeMask{~0_u64};
  84     ALeffectslot *EffectSlots{nullptr}; /* 64 */
  85
  86     EffectSlotSubList() noexcept = default;
  87     EffectSlotSubList(const EffectSlotSubList&) = delete;
  88     EffectSlotSubList(EffectSlotSubList&& rhs) noexcept
  89       : FreeMask{rhs.FreeMask}, EffectSlots{rhs.EffectSlots}
  90     { rhs.FreeMask = ~0_u64; rhs.EffectSlots = nullptr; }
  91     ~EffectSlotSubList();
  92
  93     EffectSlotSubList& operator=(const EffectSlotSubList&) = delete;
  94     EffectSlotSubList& operator=(EffectSlotSubList&& rhs) noexcept
  95     { std::swap(FreeMask, rhs.FreeMask); std::swap(EffectSlots, rhs.EffectSlots); return *this; }
  96 };
  97
  98 struct ALCcontext : public al::intrusive_ref<ALCcontext>, ContextBase {
  99     const al::intrusive_ptr<ALCdevice> mALDevice;
 100
 101     /* Wet buffers used by effect slots. */
 102     al::vector<WetBufferPtr> mWetBuffers;
 103
 104
 105     bool mPropsDirty{true};
 106     bool mDeferUpdates{false};
 107
 108     std::mutex mPropLock;
 109
 110     std::atomic<ALenum> mLastError{AL_NO_ERROR};
 111
 112     DistanceModel mDistanceModel{DistanceModel::Default};
 113     bool mSourceDistanceModel{false};
 114
 115     float mDopplerFactor{1.0f};
 116     float mDopplerVelocity{1.0f};
 117     float mSpeedOfSound{SpeedOfSoundMetersPerSec};
 118     float mAirAbsorptionGainHF{AirAbsorbGainHF};
 119
 120     std::mutex mEventCbLock;
 121     ALEVENTPROCSOFT mEventCb{};
 122     void *mEventParam{nullptr};
 123
 124     ALlistener mListener{};
 125
 126     al::vector<SourceSubList> mSourceList;
 127     ALuint mNumSources{0};
 128     std::mutex mSourceLock;
 129
 130     al::vector<EffectSlotSubList> mEffectSlotList;
 131     ALuint mNumEffectSlots{0u};
 132     std::mutex mEffectSlotLock;
 133
 134     /* Default effect slot */
 135     std::unique_ptr<ALeffectslot> mDefaultSlot;
 136
 137     const char *mExtensionList{nullptr};
 138
 139
 140     ALCcontext(al::intrusive_ptr<ALCdevice> device);
 141     ALCcontext(const ALCcontext&) = delete;
 142     ALCcontext& operator=(const ALCcontext&) = delete;
 143     ~ALCcontext();
 144
 145     void init();
 146     /**
 147      * Removes the context from its device and removes it from being current on
 148      * the running thread or globally. Returns true if other contexts still
 149      * exist on the device.
 150      */
 151     bool deinit();
 152
 153     /**
 154      * Defers/suspends updates for the given context's listener and sources.
 155      * This does *NOT* stop mixing, but rather prevents certain property
 156      * changes from taking effect. mPropLock must be held when called.
 157      */
 158     void deferUpdates() noexcept { mDeferUpdates = true; }
 159
 160     /**
 161      * Resumes update processing after being deferred. mPropLock must be held
 162      * when called.
 163      */
 164     void processUpdates()
 165     {
 166         if(std::exchange(mDeferUpdates, false))
 167             applyAllUpdates();
 168     }
 169
 170     /**
 171      * Applies all pending updates for the context, listener, effect slots, and
 172      * sources.
 173      */
 174     void applyAllUpdates();
 175
 176 #ifdef __USE_MINGW_ANSI_STDIO
 177     [[gnu::format(gnu_printf, 3, 4)]]
 178 #else
 179     [[gnu::format(printf, 3, 4)]]
 180 #endif
 181     void setError(ALenum errorCode, const char *msg, ...);
 182
 183     /* Process-wide current context */
 184     static std::atomic<ALCcontext*> sGlobalContext;
 185
 186 private:
 187     /* Thread-local current context. */
 188     static thread_local ALCcontext *sLocalContext;
 189
 190     /* Thread-local context handling. This handles attempting to release the
 191      * context which may have been left current when the thread is destroyed.
 192      */
 193     class ThreadCtx {
 194     public:
 195         ~ThreadCtx();
 196         void set(ALCcontext *ctx) const noexcept { sLocalContext = ctx; }
 197     };
 198     static thread_local ThreadCtx sThreadContext;
 199
 200 public:
 201     /* HACK: MinGW generates bad code when accessing an extern thread_local
 202      * object. Add a wrapper function for it that only accesses it where it's
 203      * defined.
 204      */
 205 #ifdef __MINGW32__
 206     static ALCcontext *getThreadContext() noexcept;
 207     static void setThreadContext(ALCcontext *context) noexcept;
 208 #else
 209     static ALCcontext *getThreadContext() noexcept { return sLocalContext; }
 210     static void setThreadContext(ALCcontext *context) noexcept { sThreadContext.set(context); }
 211 #endif
 212
 213     /* Default effect that applies to sources that don't have an effect on send 0. */
 214     static ALeffect sDefaultEffect;
 215
 216     DEF_NEWDEL(ALCcontext)
 217
 218 #ifdef ALSOFT_EAX
 219 public:
 220     bool has_eax() const noexcept { return eax_is_initialized_; }
 221
 222     bool eax_is_capable() const noexcept;
 223
 224
 225     void eax_uninitialize() noexcept;
 226
 227
 228     ALenum eax_eax_set(
 229         const GUID* property_set_id,
 230         ALuint property_id,
 231         ALuint property_source_id,
 232         ALvoid* property_value,
 233         ALuint property_value_size);
 234
 235     ALenum eax_eax_get(
 236         const GUID* property_set_id,
 237         ALuint property_id,
 238         ALuint property_source_id,
 239         ALvoid* property_value,
 240         ALuint property_value_size);
 241
 242
 243     void eax_update_filters();
 244
 245     void eax_commit_and_update_sources();
 246
 247
 248     void eax_set_last_error() noexcept;
 249
 250
 251     EaxFxSlotIndex eax_get_previous_primary_fx_slot_index() const noexcept
 252     { return eax_previous_primary_fx_slot_index_; }
 253     EaxFxSlotIndex eax_get_primary_fx_slot_index() const noexcept
 254     { return eax_primary_fx_slot_index_; }
 255
 256     const ALeffectslot& eax_get_fx_slot(EaxFxSlotIndexValue fx_slot_index) const
 257     { return eax_fx_slots_.get(fx_slot_index); }
 258     ALeffectslot& eax_get_fx_slot(EaxFxSlotIndexValue fx_slot_index)
 259     { return eax_fx_slots_.get(fx_slot_index); }
 260
 261
 262 private:
 263     using SourceList = al::vector<SourceSubList>;
 264
 265
 266     struct SourceListIteratorBeginTag{};
 267     struct SourceListIteratorEndTag{};
 268
 269     class SourceListIterator
 270     {
 271     public:
 272         SourceListIterator(
 273             SourceList& sources,
 274             SourceListIteratorBeginTag) noexcept;
 275
 276         SourceListIterator(
 277             SourceList& sources,
 278             SourceListIteratorEndTag) noexcept;
 279
 280         SourceListIterator(
 281             const SourceListIterator& rhs);
 282
 283         SourceListIterator& operator=(
 284             const SourceListIterator& rhs) = delete;
 285
 286         SourceListIterator& operator++();
 287
 288         ALsource& operator*() noexcept;
 289
 290         bool operator==(
 291             const SourceListIterator& rhs) const noexcept;
 292
 293         bool operator!=(
 294             const SourceListIterator& rhs) const noexcept;
 295
 296
 297     private:
 298         SourceList::iterator sub_list_iterator_;
 299         SourceList::iterator sub_list_end_iterator_;
 300         std::uint64_t sub_list_item_index_;
 301     }; // SourceListIterator
 302
 303     class SourceListEnumerator
 304     {
 305     public:
 306         explicit SourceListEnumerator(
 307             SourceList& sources) noexcept;
 308
 309         SourceListEnumerator(
 310             const SourceListEnumerator& rhs) = delete;
 311
 312         SourceListEnumerator& operator=(
 313             const SourceListEnumerator& rhs) = delete;
 314
 315         SourceListIterator begin() noexcept;
 316
 317         SourceListIterator end() noexcept;
 318
 319
 320     private:
 321         SourceList& sources_;
 322     }; // SourceListEnumerator
 323
 324
 325     struct Eax
 326     {
 327         EAX50CONTEXTPROPERTIES context{};
 328     }; // Eax
 329
 330
 331     bool eax_is_initialized_{};
 332     bool eax_is_tried_{};
 333     bool eax_are_legacy_fx_slots_unlocked_{};
 334
 335     long eax_last_error_{};
 336     unsigned long eax_speaker_config_{};
 337
 338     EaxFxSlotIndex eax_previous_primary_fx_slot_index_{};
 339     EaxFxSlotIndex eax_primary_fx_slot_index_{};
 340     EaxFxSlots eax_fx_slots_{};
 341
 342     EaxContextSharedDirtyFlags eax_context_shared_dirty_flags_{};
 343
 344     Eax eax_{};
 345     Eax eax_d_{};
 346     EAXSESSIONPROPERTIES eax_session_{};
 347
 348     ContextDirtyFlags eax_context_dirty_flags_{};
 349
 350     std::string eax_extension_list_{};
 351
 352
 353     [[noreturn]]
 354     static void eax_fail(
 355         const char* message);
 356
 357
 358     void eax_initialize_extensions();
 359
 360     void eax_initialize();
 361
 362
 363     bool eax_has_no_default_effect_slot() const noexcept;
 364
 365     void eax_ensure_no_default_effect_slot() const;
 366
 367     bool eax_has_enough_aux_sends() const noexcept;
 368
 369     void eax_ensure_enough_aux_sends() const;
 370
 371     void eax_ensure_compatibility();
 372
 373
 374     unsigned long eax_detect_speaker_configuration() const;
 375     void eax_update_speaker_configuration();
 376
 377
 378     void eax_set_last_error_defaults() noexcept;
 379
 380     void eax_set_session_defaults() noexcept;
 381
 382     void eax_set_context_defaults() noexcept;
 383
 384     void eax_set_defaults() noexcept;
 385
 386     void eax_initialize_sources();
 387
 388
 389     void eax_unlock_legacy_fx_slots(const EaxEaxCall& eax_call) noexcept;
 390
 391
 392     void eax_dispatch_fx_slot(
 393         const EaxEaxCall& eax_call);
 394
 395     void eax_dispatch_source(
 396         const EaxEaxCall& eax_call);
 397
 398
 399     void eax_get_primary_fx_slot_id(
 400         const EaxEaxCall& eax_call);
 401
 402     void eax_get_distance_factor(
 403         const EaxEaxCall& eax_call);
 404
 405     void eax_get_air_absorption_hf(
 406         const EaxEaxCall& eax_call);
 407
 408     void eax_get_hf_reference(
 409         const EaxEaxCall& eax_call);
 410
 411     void eax_get_last_error(
 412         const EaxEaxCall& eax_call);
 413
 414     void eax_get_speaker_config(
 415         const EaxEaxCall& eax_call);
 416
 417     void eax_get_session(
 418         const EaxEaxCall& eax_call);
 419
 420     void eax_get_macro_fx_factor(
 421         const EaxEaxCall& eax_call);
 422
 423     void eax_get_context_all(
 424         const EaxEaxCall& eax_call);
 425
 426     void eax_get(
 427         const EaxEaxCall& eax_call);
 428
 429
 430     void eax_set_primary_fx_slot_id();
 431
 432     void eax_set_distance_factor();
 433
 434     void eax_set_air_absorbtion_hf();
 435
 436     void eax_set_hf_reference();
 437
 438     void eax_set_macro_fx_factor();
 439
 440     void eax_set_context();
 441
 442     void eax_initialize_fx_slots();
 443
 444
 445     void eax_update_sources();
 446
 447
 448     void eax_validate_primary_fx_slot_id(
 449         const GUID& primary_fx_slot_id);
 450
 451     void eax_validate_distance_factor(
 452         float distance_factor);
 453
 454     void eax_validate_air_absorption_hf(
 455         float air_absorption_hf);
 456
 457     void eax_validate_hf_reference(
 458         float hf_reference);
 459
 460     void eax_validate_speaker_config(
 461         unsigned long speaker_config);
 462
 463     void eax_validate_session_eax_version(
 464         unsigned long eax_version);
 465
 466     void eax_validate_session_max_active_sends(
 467         unsigned long max_active_sends);
 468
 469     void eax_validate_session(
 470         const EAXSESSIONPROPERTIES& eax_session);
 471
 472     void eax_validate_macro_fx_factor(
 473         float macro_fx_factor);
 474
 475     void eax_validate_context_all(
 476         const EAX40CONTEXTPROPERTIES& context_all);
 477
 478     void eax_validate_context_all(
 479         const EAX50CONTEXTPROPERTIES& context_all);
 480
 481
 482     void eax_defer_primary_fx_slot_id(
 483         const GUID& primary_fx_slot_id);
 484
 485     void eax_defer_distance_factor(
 486         float distance_factor);
 487
 488     void eax_defer_air_absorption_hf(
 489         float air_absorption_hf);
 490
 491     void eax_defer_hf_reference(
 492         float hf_reference);
 493
 494     void eax_defer_macro_fx_factor(
 495         float macro_fx_factor);
 496
 497     void eax_defer_context_all(
 498         const EAX40CONTEXTPROPERTIES& context_all);
 499
 500     void eax_defer_context_all(
 501         const EAX50CONTEXTPROPERTIES& context_all);
 502
 503
 504     void eax_defer_context_all(
 505         const EaxEaxCall& eax_call);
 506
 507     void eax_defer_primary_fx_slot_id(
 508         const EaxEaxCall& eax_call);
 509
 510     void eax_defer_distance_factor(
 511         const EaxEaxCall& eax_call);
 512
 513     void eax_defer_air_absorption_hf(
 514         const EaxEaxCall& eax_call);
 515
 516     void eax_defer_hf_reference(
 517         const EaxEaxCall& eax_call);
 518
 519     void eax_set_session(
 520         const EaxEaxCall& eax_call);
 521
 522     void eax_defer_macro_fx_factor(
 523         const EaxEaxCall& eax_call);
 524
 525     void eax_set(
 526         const EaxEaxCall& eax_call);
 527
 528     void eax_apply_deferred();
 529 #endif // ALSOFT_EAX
 530 };
 531
 532 #define SETERR_RETURN(ctx, err, retval, ...) do {                             \
 533     (ctx)->setError((err), __VA_ARGS__);                                      \
 534     return retval;                                                            \
 535 } while(0)
 536
 537
 538 using ContextRef = al::intrusive_ptr<ALCcontext>;
 539
 540 ContextRef GetContextRef(void);
 541
 542 void UpdateContextProps(ALCcontext *context);
 543
 544
 545 extern bool TrapALError;
 546
 547
 548 #ifdef ALSOFT_EAX
 549 ALenum AL_APIENTRY EAXSet(
 550     const GUID* property_set_id,
 551     ALuint property_id,
 552     ALuint property_source_id,
 553     ALvoid* property_value,
 554     ALuint property_value_size) noexcept;
 555
 556 ALenum AL_APIENTRY EAXGet(
 557     const GUID* property_set_id,
 558     ALuint property_id,
 559     ALuint property_source_id,
 560     ALvoid* property_value,
 561     ALuint property_value_size) noexcept;
 562 #endif // ALSOFT_EAX
 563
 564 #endif /* ALC_CONTEXT_H */