alc/context.cpp

   1
   2 #include "config.h"
   3
   4 #include "context.h"
   5
   6 #include <algorithm>
   7 #include <functional>
   8 #include <limits>
   9 #include <numeric>
  10 #include <stddef.h>
  11 #include <stdexcept>
  12
  13 #include "AL/efx.h"
  14
  15 #include "al/auxeffectslot.h"
  16 #include "al/source.h"
  17 #include "al/effect.h"
  18 #include "al/event.h"
  19 #include "al/listener.h"
  20 #include "albit.h"
  21 #include "alc/alu.h"
  22 #include "core/async_event.h"
  23 #include "core/device.h"
  24 #include "core/effectslot.h"
  25 #include "core/logging.h"
  26 #include "core/voice.h"
  27 #include "core/voice_change.h"
  28 #include "device.h"
  29 #include "ringbuffer.h"
  30 #include "vecmat.h"
  31
  32 #ifdef ALSOFT_EAX
  33 #include <cassert>
  34 #include <cstring>
  35
  36 #include "alstring.h"
  37 #include "al/eax_exception.h"
  38 #include "al/eax_globals.h"
  39 #endif // ALSOFT_EAX
  40
  41 namespace {
  42
  43 using namespace std::placeholders;
  44
  45 using voidp = void*;
  46
  47 /* Default context extensions */
  48 constexpr ALchar alExtList[] =
  49     "AL_EXT_ALAW "
  50     "AL_EXT_BFORMAT "
  51     "AL_EXT_DOUBLE "
  52     "AL_EXT_EXPONENT_DISTANCE "
  53     "AL_EXT_FLOAT32 "
  54     "AL_EXT_IMA4 "
  55     "AL_EXT_LINEAR_DISTANCE "
  56     "AL_EXT_MCFORMATS "
  57     "AL_EXT_MULAW "
  58     "AL_EXT_MULAW_BFORMAT "
  59     "AL_EXT_MULAW_MCFORMATS "
  60     "AL_EXT_OFFSET "
  61     "AL_EXT_source_distance_model "
  62     "AL_EXT_SOURCE_RADIUS "
  63     "AL_EXT_STEREO_ANGLES "
  64     "AL_LOKI_quadriphonic "
  65     "AL_SOFT_bformat_ex "
  66     "AL_SOFTX_bformat_hoa "
  67     "AL_SOFT_block_alignment "
  68     "AL_SOFT_callback_buffer "
  69     "AL_SOFTX_convolution_reverb "
  70     "AL_SOFT_deferred_updates "
  71     "AL_SOFT_direct_channels "
  72     "AL_SOFT_direct_channels_remix "
  73     "AL_SOFT_effect_target "
  74     "AL_SOFT_events "
  75     "AL_SOFT_gain_clamp_ex "
  76     "AL_SOFTX_hold_on_disconnect "
  77     "AL_SOFT_loop_points "
  78     "AL_SOFTX_map_buffer "
  79     "AL_SOFT_MSADPCM "
  80     "AL_SOFT_source_latency "
  81     "AL_SOFT_source_length "
  82     "AL_SOFT_source_resampler "
  83     "AL_SOFT_source_spatialize "
  84     "AL_SOFT_UHJ";
  85
  86 } // namespace
  87
  88
  89 std::atomic<ALCcontext*> ALCcontext::sGlobalContext{nullptr};
  90
  91 thread_local ALCcontext *ALCcontext::sLocalContext{nullptr};
  92 ALCcontext::ThreadCtx::~ThreadCtx()
  93 {
  94     if(ALCcontext *ctx{ALCcontext::sLocalContext})
  95     {
  96         const bool result{ctx->releaseIfNoDelete()};
  97         ERR("Context %p current for thread being destroyed%s!\n", voidp{ctx},
  98             result ? "" : ", leak detected");
  99     }
 100 }
 101 thread_local ALCcontext::ThreadCtx ALCcontext::sThreadContext;
 102
 103 ALeffect ALCcontext::sDefaultEffect;
 104
 105
 106 #ifdef __MINGW32__
 107 ALCcontext *ALCcontext::getThreadContext() noexcept
 108 { return sLocalContext; }
 109 void ALCcontext::setThreadContext(ALCcontext *context) noexcept
 110 { sThreadContext.set(context); }
 111 #endif
 112
 113 ALCcontext::ALCcontext(al::intrusive_ptr<ALCdevice> device)
 114   : ContextBase{device.get()}, mALDevice{std::move(device)}
 115 {
 116 }
 117
 118 ALCcontext::~ALCcontext()
 119 {
 120     TRACE("Freeing context %p\n", voidp{this});
 121
 122     size_t count{std::accumulate(mSourceList.cbegin(), mSourceList.cend(), size_t{0u},
 123         [](size_t cur, const SourceSubList &sublist) noexcept -> size_t
 124         { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); })};
 125     if(count > 0)
 126         WARN("%zu Source%s not deleted\n", count, (count==1)?"":"s");
 127     mSourceList.clear();
 128     mNumSources = 0;
 129
 130 #ifdef ALSOFT_EAX
 131     eax_uninitialize();
 132 #endif // ALSOFT_EAX
 133
 134     mDefaultSlot = nullptr;
 135     count = std::accumulate(mEffectSlotList.cbegin(), mEffectSlotList.cend(), size_t{0u},
 136         [](size_t cur, const EffectSlotSubList &sublist) noexcept -> size_t
 137         { return cur + static_cast<uint>(al::popcount(~sublist.FreeMask)); });
 138     if(count > 0)
 139         WARN("%zu AuxiliaryEffectSlot%s not deleted\n", count, (count==1)?"":"s");
 140     mEffectSlotList.clear();
 141     mNumEffectSlots = 0;
 142 }
 143
 144 void ALCcontext::init()
 145 {
 146     if(sDefaultEffect.type != AL_EFFECT_NULL && mDevice->Type == DeviceType::Playback)
 147     {
 148         mDefaultSlot = std::make_unique<ALeffectslot>();
 149         aluInitEffectPanning(&mDefaultSlot->mSlot, this);
 150     }
 151
 152     EffectSlotArray *auxslots;
 153     if(!mDefaultSlot)
 154         auxslots = EffectSlot::CreatePtrArray(0);
 155     else
 156     {
 157         auxslots = EffectSlot::CreatePtrArray(1);
 158         (*auxslots)[0] = &mDefaultSlot->mSlot;
 159         mDefaultSlot->mState = SlotState::Playing;
 160     }
 161     mActiveAuxSlots.store(auxslots, std::memory_order_relaxed);
 162
 163     allocVoiceChanges();
 164     {
 165         VoiceChange *cur{mVoiceChangeTail};
 166         while(VoiceChange *next{cur->mNext.load(std::memory_order_relaxed)})
 167             cur = next;
 168         mCurrentVoiceChange.store(cur, std::memory_order_relaxed);
 169     }
 170
 171     mExtensionList = alExtList;
 172
 173 #ifdef ALSOFT_EAX
 174     eax_initialize_extensions();
 175 #endif // ALSOFT_EAX
 176
 177     mParams.Position = alu::Vector{0.0f, 0.0f, 0.0f, 1.0f};
 178     mParams.Matrix = alu::Matrix::Identity();
 179     mParams.Velocity = alu::Vector{};
 180     mParams.Gain = mListener.Gain;
 181     mParams.MetersPerUnit = mListener.mMetersPerUnit;
 182     mParams.AirAbsorptionGainHF = mAirAbsorptionGainHF;
 183     mParams.DopplerFactor = mDopplerFactor;
 184     mParams.SpeedOfSound = mSpeedOfSound * mDopplerVelocity;
 185     mParams.SourceDistanceModel = mSourceDistanceModel;
 186     mParams.mDistanceModel = mDistanceModel;
 187
 188
 189     mAsyncEvents = RingBuffer::Create(511, sizeof(AsyncEvent), false);
 190     StartEventThrd(this);
 191
 192
 193     allocVoices(256);
 194     mActiveVoiceCount.store(64, std::memory_order_relaxed);
 195 }
 196
 197 bool ALCcontext::deinit()
 198 {
 199     if(sLocalContext == this)
 200     {
 201         WARN("%p released while current on thread\n", voidp{this});
 202         sThreadContext.set(nullptr);
 203         release();
 204     }
 205
 206     ALCcontext *origctx{this};
 207     if(sGlobalContext.compare_exchange_strong(origctx, nullptr))
 208         release();
 209
 210     bool ret{};
 211     /* First make sure this context exists in the device's list. */
 212     auto *oldarray = mDevice->mContexts.load(std::memory_order_acquire);
 213     if(auto toremove = static_cast<size_t>(std::count(oldarray->begin(), oldarray->end(), this)))
 214     {
 215         using ContextArray = al::FlexArray<ContextBase*>;
 216         auto alloc_ctx_array = [](const size_t count) -> ContextArray*
 217         {
 218             if(count == 0) return &DeviceBase::sEmptyContextArray;
 219             return ContextArray::Create(count).release();
 220         };
 221         auto *newarray = alloc_ctx_array(oldarray->size() - toremove);
 222
 223         /* Copy the current/old context handles to the new array, excluding the
 224          * given context.
 225          */
 226         std::copy_if(oldarray->begin(), oldarray->end(), newarray->begin(),
 227             std::bind(std::not_equal_to<>{}, _1, this));
 228
 229         /* Store the new context array in the device. Wait for any current mix
 230          * to finish before deleting the old array.
 231          */
 232         mDevice->mContexts.store(newarray);
 233         if(oldarray != &DeviceBase::sEmptyContextArray)
 234         {
 235             mDevice->waitForMix();
 236             delete oldarray;
 237         }
 238
 239         ret = !newarray->empty();
 240     }
 241     else
 242         ret = !oldarray->empty();
 243
 244     StopEventThrd(this);
 245
 246     return ret;
 247 }
 248
 249 void ALCcontext::applyAllUpdates()
 250 {
 251     /* Tell the mixer to stop applying updates, then wait for any active
 252      * updating to finish, before providing updates.
 253      */
 254     mHoldUpdates.store(true, std::memory_order_release);
 255     while((mUpdateCount.load(std::memory_order_acquire)&1) != 0) {
 256         /* busy-wait */
 257     }
 258
 259 #ifdef ALSOFT_EAX
 260     eax_apply_deferred();
 261 #endif
 262     if(std::exchange(mPropsDirty, false))
 263         UpdateContextProps(this);
 264     UpdateAllEffectSlotProps(this);
 265     UpdateAllSourceProps(this);
 266
 267     /* Now with all updates declared, let the mixer continue applying them so
 268      * they all happen at once.
 269      */
 270     mHoldUpdates.store(false, std::memory_order_release);
 271 }
 272
 273 #ifdef ALSOFT_EAX
 274 namespace {
 275
 276 class ContextException :
 277     public EaxException
 278 {
 279 public:
 280     explicit ContextException(
 281         const char* message)
 282         :
 283         EaxException{"EAX_CONTEXT", message}
 284     {
 285     }
 286 }; // ContextException
 287
 288
 289 template<typename F>
 290 void ForEachSource(ALCcontext *context, F func)
 291 {
 292     for(auto &sublist : context->mSourceList)
 293     {
 294         uint64_t usemask{~sublist.FreeMask};
 295         while(usemask)
 296         {
 297             const int idx{al::countr_zero(usemask)};
 298             usemask &= ~(1_u64 << idx);
 299
 300             func(sublist.Sources[idx]);
 301         }
 302     }
 303 }
 304
 305 } // namespace
 306
 307
 308 bool ALCcontext::eax_is_capable() const noexcept
 309 {
 310     return eax_has_enough_aux_sends();
 311 }
 312
 313 void ALCcontext::eax_uninitialize() noexcept
 314 {
 315     if (!eax_is_initialized_)
 316     {
 317         return;
 318     }
 319
 320     eax_is_initialized_ = true;
 321     eax_is_tried_ = false;
 322
 323     eax_fx_slots_.uninitialize();
 324 }
 325
 326 ALenum ALCcontext::eax_eax_set(
 327     const GUID* property_set_id,
 328     ALuint property_id,
 329     ALuint property_source_id,
 330     ALvoid* property_value,
 331     ALuint property_value_size)
 332 {
 333     eax_initialize();
 334
 335     const auto eax_call = create_eax_call(
 336         false,
 337         property_set_id,
 338         property_id,
 339         property_source_id,
 340         property_value,
 341         property_value_size
 342     );
 343
 344     eax_unlock_legacy_fx_slots(eax_call);
 345
 346     switch (eax_call.get_property_set_id())
 347     {
 348         case EaxEaxCallPropertySetId::context:
 349             eax_set(eax_call);
 350             break;
 351
 352         case EaxEaxCallPropertySetId::fx_slot:
 353         case EaxEaxCallPropertySetId::fx_slot_effect:
 354             eax_dispatch_fx_slot(eax_call);
 355             break;
 356
 357         case EaxEaxCallPropertySetId::source:
 358             eax_dispatch_source(eax_call);
 359             break;
 360
 361         default:
 362             eax_fail("Unsupported property set id.");
 363     }
 364
 365     static constexpr auto deferred_flag = 0x80000000u;
 366     if(!(property_id&deferred_flag) && !mDeferUpdates)
 367         applyAllUpdates();
 368
 369     return AL_NO_ERROR;
 370 }
 371
 372 ALenum ALCcontext::eax_eax_get(
 373     const GUID* property_set_id,
 374     ALuint property_id,
 375     ALuint property_source_id,
 376     ALvoid* property_value,
 377     ALuint property_value_size)
 378 {
 379     eax_initialize();
 380
 381     const auto eax_call = create_eax_call(
 382         true,
 383         property_set_id,
 384         property_id,
 385         property_source_id,
 386         property_value,
 387         property_value_size
 388     );
 389
 390     eax_unlock_legacy_fx_slots(eax_call);
 391
 392     switch (eax_call.get_property_set_id())
 393     {
 394         case EaxEaxCallPropertySetId::context:
 395             eax_get(eax_call);
 396             break;
 397
 398         case EaxEaxCallPropertySetId::fx_slot:
 399         case EaxEaxCallPropertySetId::fx_slot_effect:
 400             eax_dispatch_fx_slot(eax_call);
 401             break;
 402
 403         case EaxEaxCallPropertySetId::source:
 404             eax_dispatch_source(eax_call);
 405             break;
 406
 407         default:
 408             eax_fail("Unsupported property set id.");
 409     }
 410
 411     return AL_NO_ERROR;
 412 }
 413
 414 void ALCcontext::eax_update_filters()
 415 {
 416     ForEachSource(this, std::mem_fn(&ALsource::eax_update_filters));
 417 }
 418
 419 void ALCcontext::eax_commit_and_update_sources()
 420 {
 421     std::unique_lock<std::mutex> source_lock{mSourceLock};
 422     ForEachSource(this, std::mem_fn(&ALsource::eax_commit_and_update));
 423 }
 424
 425 void ALCcontext::eax_set_last_error() noexcept
 426 {
 427     eax_last_error_ = EAXERR_INVALID_OPERATION;
 428 }
 429
 430 [[noreturn]]
 431 void ALCcontext::eax_fail(
 432     const char* message)
 433 {
 434     throw ContextException{message};
 435 }
 436
 437 void ALCcontext::eax_initialize_extensions()
 438 {
 439     if (!eax_g_is_enabled)
 440     {
 441         return;
 442     }
 443
 444     const auto string_max_capacity =
 445         std::strlen(mExtensionList) + 1 +
 446         std::strlen(eax1_ext_name) + 1 +
 447         std::strlen(eax2_ext_name) + 1 +
 448         std::strlen(eax3_ext_name) + 1 +
 449         std::strlen(eax4_ext_name) + 1 +
 450         std::strlen(eax5_ext_name) + 1 +
 451         std::strlen(eax_x_ram_ext_name) + 1 +
 452         0;
 453
 454     eax_extension_list_.reserve(string_max_capacity);
 455
 456     if (eax_is_capable())
 457     {
 458         eax_extension_list_ += eax1_ext_name;
 459         eax_extension_list_ += ' ';
 460
 461         eax_extension_list_ += eax2_ext_name;
 462         eax_extension_list_ += ' ';
 463
 464         eax_extension_list_ += eax3_ext_name;
 465         eax_extension_list_ += ' ';
 466
 467         eax_extension_list_ += eax4_ext_name;
 468         eax_extension_list_ += ' ';
 469
 470         eax_extension_list_ += eax5_ext_name;
 471         eax_extension_list_ += ' ';
 472     }
 473
 474     eax_extension_list_ += eax_x_ram_ext_name;
 475     eax_extension_list_ += ' ';
 476
 477     eax_extension_list_ += mExtensionList;
 478     mExtensionList = eax_extension_list_.c_str();
 479 }
 480
 481 void ALCcontext::eax_initialize()
 482 {
 483     if (eax_is_initialized_)
 484     {
 485         return;
 486     }
 487
 488     if (eax_is_tried_)
 489     {
 490         eax_fail("No EAX.");
 491     }
 492
 493     eax_is_tried_ = true;
 494
 495     if (!eax_g_is_enabled)
 496     {
 497         eax_fail("EAX disabled by a configuration.");
 498     }
 499
 500     eax_ensure_compatibility();
 501     eax_set_defaults();
 502     eax_set_air_absorbtion_hf();
 503     eax_update_speaker_configuration();
 504     eax_initialize_fx_slots();
 505     eax_initialize_sources();
 506
 507     eax_is_initialized_ = true;
 508 }
 509
 510 bool ALCcontext::eax_has_no_default_effect_slot() const noexcept
 511 {
 512     return mDefaultSlot == nullptr;
 513 }
 514
 515 void ALCcontext::eax_ensure_no_default_effect_slot() const
 516 {
 517     if (!eax_has_no_default_effect_slot())
 518     {
 519         eax_fail("There is a default effect slot in the context.");
 520     }
 521 }
 522
 523 bool ALCcontext::eax_has_enough_aux_sends() const noexcept
 524 {
 525     return mALDevice->NumAuxSends >= EAX_MAX_FXSLOTS;
 526 }
 527
 528 void ALCcontext::eax_ensure_enough_aux_sends() const
 529 {
 530     if (!eax_has_enough_aux_sends())
 531     {
 532         eax_fail("Not enough aux sends.");
 533     }
 534 }
 535
 536 void ALCcontext::eax_ensure_compatibility()
 537 {
 538     eax_ensure_enough_aux_sends();
 539 }
 540
 541 unsigned long ALCcontext::eax_detect_speaker_configuration() const
 542 {
 543 #define EAX_PREFIX "[EAX_DETECT_SPEAKER_CONFIG]"
 544
 545     switch(mDevice->FmtChans)
 546     {
 547     case DevFmtMono: return SPEAKERS_2;
 548     case DevFmtStereo:
 549         /* Pretend 7.1 if using UHJ output, since they both provide full
 550          * horizontal surround.
 551          */
 552         if(mDevice->mUhjEncoder)
 553             return SPEAKERS_7;
 554         if(mDevice->Flags.test(DirectEar))
 555             return HEADPHONES;
 556         return SPEAKERS_2;
 557     case DevFmtQuad: return SPEAKERS_4;
 558     case DevFmtX51: return SPEAKERS_5;
 559     case DevFmtX61: return SPEAKERS_6;
 560     case DevFmtX71: return SPEAKERS_7;
 561     /* This could also be HEADPHONES, since headphones-based HRTF and Ambi3D
 562      * provide full-sphere surround sound. Depends if apps are more likely to
 563      * consider headphones or 7.1 for surround sound support.
 564      */
 565     case DevFmtAmbi3D: return SPEAKERS_7;
 566     }
 567     ERR(EAX_PREFIX "Unexpected device channel format 0x%x.\n", mDevice->FmtChans);
 568     return HEADPHONES;
 569
 570 #undef EAX_PREFIX
 571 }
 572
 573 void ALCcontext::eax_update_speaker_configuration()
 574 {
 575     eax_speaker_config_ = eax_detect_speaker_configuration();
 576 }
 577
 578 void ALCcontext::eax_set_last_error_defaults() noexcept
 579 {
 580     eax_last_error_ = EAX_OK;
 581 }
 582
 583 void ALCcontext::eax_set_session_defaults() noexcept
 584 {
 585     eax_session_.ulEAXVersion = EAXCONTEXT_MINEAXSESSION;
 586     eax_session_.ulMaxActiveSends = EAXCONTEXT_DEFAULTMAXACTIVESENDS;
 587 }
 588
 589 void ALCcontext::eax_set_context_defaults() noexcept
 590 {
 591     eax_.context.guidPrimaryFXSlotID = EAXCONTEXT_DEFAULTPRIMARYFXSLOTID;
 592     eax_.context.flDistanceFactor = EAXCONTEXT_DEFAULTDISTANCEFACTOR;
 593     eax_.context.flAirAbsorptionHF = EAXCONTEXT_DEFAULTAIRABSORPTIONHF;
 594     eax_.context.flHFReference = EAXCONTEXT_DEFAULTHFREFERENCE;
 595 }
 596
 597 void ALCcontext::eax_set_defaults() noexcept
 598 {
 599     eax_set_last_error_defaults();
 600     eax_set_session_defaults();
 601     eax_set_context_defaults();
 602
 603     eax_d_ = eax_;
 604 }
 605
 606 void ALCcontext::eax_unlock_legacy_fx_slots(const EaxEaxCall& eax_call) noexcept
 607 {
 608     if (eax_call.get_version() != 5 || eax_are_legacy_fx_slots_unlocked_)
 609         return;
 610
 611     eax_are_legacy_fx_slots_unlocked_ = true;
 612     eax_fx_slots_.unlock_legacy();
 613 }
 614
 615 void ALCcontext::eax_dispatch_fx_slot(
 616     const EaxEaxCall& eax_call)
 617 {
 618     const auto fx_slot_index = eax_call.get_fx_slot_index();
 619     if(!fx_slot_index.has_value())
 620         eax_fail("Invalid fx slot index.");
 621
 622     auto& fx_slot = eax_get_fx_slot(*fx_slot_index);
 623     if(fx_slot.eax_dispatch(eax_call))
 624     {
 625         std::lock_guard<std::mutex> source_lock{mSourceLock};
 626         eax_update_filters();
 627     }
 628 }
 629
 630 void ALCcontext::eax_dispatch_source(
 631     const EaxEaxCall& eax_call)
 632 {
 633     const auto source_id = eax_call.get_property_al_name();
 634
 635     std::lock_guard<std::mutex> source_lock{mSourceLock};
 636
 637     const auto source = ALsource::eax_lookup_source(*this, source_id);
 638
 639     if (!source)
 640     {
 641         eax_fail("Source not found.");
 642     }
 643
 644     source->eax_dispatch(eax_call);
 645 }
 646
 647 void ALCcontext::eax_get_primary_fx_slot_id(
 648     const EaxEaxCall& eax_call)
 649 {
 650     eax_call.set_value<ContextException>(eax_.context.guidPrimaryFXSlotID);
 651 }
 652
 653 void ALCcontext::eax_get_distance_factor(
 654     const EaxEaxCall& eax_call)
 655 {
 656     eax_call.set_value<ContextException>(eax_.context.flDistanceFactor);
 657 }
 658
 659 void ALCcontext::eax_get_air_absorption_hf(
 660     const EaxEaxCall& eax_call)
 661 {
 662     eax_call.set_value<ContextException>(eax_.context.flAirAbsorptionHF);
 663 }
 664
 665 void ALCcontext::eax_get_hf_reference(
 666     const EaxEaxCall& eax_call)
 667 {
 668     eax_call.set_value<ContextException>(eax_.context.flHFReference);
 669 }
 670
 671 void ALCcontext::eax_get_last_error(
 672     const EaxEaxCall& eax_call)
 673 {
 674     const auto eax_last_error = eax_last_error_;
 675     eax_last_error_ = EAX_OK;
 676     eax_call.set_value<ContextException>(eax_last_error);
 677 }
 678
 679 void ALCcontext::eax_get_speaker_config(
 680     const EaxEaxCall& eax_call)
 681 {
 682     eax_call.set_value<ContextException>(eax_speaker_config_);
 683 }
 684
 685 void ALCcontext::eax_get_session(
 686     const EaxEaxCall& eax_call)
 687 {
 688     eax_call.set_value<ContextException>(eax_session_);
 689 }
 690
 691 void ALCcontext::eax_get_macro_fx_factor(
 692     const EaxEaxCall& eax_call)
 693 {
 694     eax_call.set_value<ContextException>(eax_.context.flMacroFXFactor);
 695 }
 696
 697 void ALCcontext::eax_get_context_all(
 698     const EaxEaxCall& eax_call)
 699 {
 700     switch (eax_call.get_version())
 701     {
 702         case 4:
 703             eax_call.set_value<ContextException>(static_cast<const EAX40CONTEXTPROPERTIES&>(eax_.context));
 704             break;
 705
 706         case 5:
 707             eax_call.set_value<ContextException>(static_cast<const EAX50CONTEXTPROPERTIES&>(eax_.context));
 708             break;
 709
 710         default:
 711             eax_fail("Unsupported EAX version.");
 712     }
 713 }
 714
 715 void ALCcontext::eax_get(
 716     const EaxEaxCall& eax_call)
 717 {
 718     switch (eax_call.get_property_id())
 719     {
 720         case EAXCONTEXT_NONE:
 721             break;
 722
 723         case EAXCONTEXT_ALLPARAMETERS:
 724             eax_get_context_all(eax_call);
 725             break;
 726
 727         case EAXCONTEXT_PRIMARYFXSLOTID:
 728             eax_get_primary_fx_slot_id(eax_call);
 729             break;
 730
 731         case EAXCONTEXT_DISTANCEFACTOR:
 732             eax_get_distance_factor(eax_call);
 733             break;
 734
 735         case EAXCONTEXT_AIRABSORPTIONHF:
 736             eax_get_air_absorption_hf(eax_call);
 737             break;
 738
 739         case EAXCONTEXT_HFREFERENCE:
 740             eax_get_hf_reference(eax_call);
 741             break;
 742
 743         case EAXCONTEXT_LASTERROR:
 744             eax_get_last_error(eax_call);
 745             break;
 746
 747         case EAXCONTEXT_SPEAKERCONFIG:
 748             eax_get_speaker_config(eax_call);
 749             break;
 750
 751         case EAXCONTEXT_EAXSESSION:
 752             eax_get_session(eax_call);
 753             break;
 754
 755         case EAXCONTEXT_MACROFXFACTOR:
 756             eax_get_macro_fx_factor(eax_call);
 757             break;
 758
 759         default:
 760             eax_fail("Unsupported property id.");
 761     }
 762 }
 763
 764 void ALCcontext::eax_set_primary_fx_slot_id()
 765 {
 766     eax_previous_primary_fx_slot_index_ = eax_primary_fx_slot_index_;
 767     eax_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 768 }
 769
 770 void ALCcontext::eax_set_distance_factor()
 771 {
 772     mListener.mMetersPerUnit = eax_.context.flDistanceFactor;
 773     mPropsDirty = true;
 774 }
 775
 776 void ALCcontext::eax_set_air_absorbtion_hf()
 777 {
 778     mAirAbsorptionGainHF = level_mb_to_gain(eax_.context.flAirAbsorptionHF);
 779     mPropsDirty = true;
 780 }
 781
 782 void ALCcontext::eax_set_hf_reference()
 783 {
 784     // TODO
 785 }
 786
 787 void ALCcontext::eax_set_macro_fx_factor()
 788 {
 789     // TODO
 790 }
 791
 792 void ALCcontext::eax_set_context()
 793 {
 794     eax_set_primary_fx_slot_id();
 795     eax_set_distance_factor();
 796     eax_set_air_absorbtion_hf();
 797     eax_set_hf_reference();
 798 }
 799
 800 void ALCcontext::eax_initialize_fx_slots()
 801 {
 802     eax_fx_slots_.initialize(*this);
 803     eax_previous_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 804     eax_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 805 }
 806
 807 void ALCcontext::eax_initialize_sources()
 808 {
 809     std::unique_lock<std::mutex> source_lock{mSourceLock};
 810     auto init_source = [this](ALsource &source) noexcept
 811     { source.eax_initialize(this); };
 812     ForEachSource(this, init_source);
 813 }
 814
 815 void ALCcontext::eax_update_sources()
 816 {
 817     std::unique_lock<std::mutex> source_lock{mSourceLock};
 818     auto update_source = [this](ALsource &source)
 819     { source.eax_update(eax_context_shared_dirty_flags_); };
 820     ForEachSource(this, update_source);
 821 }
 822
 823 void ALCcontext::eax_validate_primary_fx_slot_id(
 824     const GUID& primary_fx_slot_id)
 825 {
 826     if (primary_fx_slot_id != EAX_NULL_GUID &&
 827         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot0 &&
 828         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot0 &&
 829         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot1 &&
 830         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot1 &&
 831         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot2 &&
 832         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot2 &&
 833         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot3 &&
 834         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot3)
 835     {
 836         eax_fail("Unsupported primary FX slot id.");
 837     }
 838 }
 839
 840 void ALCcontext::eax_validate_distance_factor(
 841     float distance_factor)
 842 {
 843     eax_validate_range<ContextException>(
 844         "Distance Factor",
 845         distance_factor,
 846         EAXCONTEXT_MINDISTANCEFACTOR,
 847         EAXCONTEXT_MAXDISTANCEFACTOR);
 848 }
 849
 850 void ALCcontext::eax_validate_air_absorption_hf(
 851     float air_absorption_hf)
 852 {
 853     eax_validate_range<ContextException>(
 854         "Air Absorption HF",
 855         air_absorption_hf,
 856         EAXCONTEXT_MINAIRABSORPTIONHF,
 857         EAXCONTEXT_MAXAIRABSORPTIONHF);
 858 }
 859
 860 void ALCcontext::eax_validate_hf_reference(
 861     float hf_reference)
 862 {
 863     eax_validate_range<ContextException>(
 864         "HF Reference",
 865         hf_reference,
 866         EAXCONTEXT_MINHFREFERENCE,
 867         EAXCONTEXT_MAXHFREFERENCE);
 868 }
 869
 870 void ALCcontext::eax_validate_speaker_config(
 871     unsigned long speaker_config)
 872 {
 873     switch (speaker_config)
 874     {
 875         case HEADPHONES:
 876         case SPEAKERS_2:
 877         case SPEAKERS_4:
 878         case SPEAKERS_5:
 879         case SPEAKERS_6:
 880         case SPEAKERS_7:
 881             break;
 882
 883         default:
 884             eax_fail("Unsupported speaker configuration.");
 885     }
 886 }
 887
 888 void ALCcontext::eax_validate_session_eax_version(
 889     unsigned long eax_version)
 890 {
 891     switch (eax_version)
 892     {
 893         case EAX_40:
 894         case EAX_50:
 895             break;
 896
 897         default:
 898             eax_fail("Unsupported session EAX version.");
 899     }
 900 }
 901
 902 void ALCcontext::eax_validate_session_max_active_sends(
 903     unsigned long max_active_sends)
 904 {
 905     eax_validate_range<ContextException>(
 906         "Max Active Sends",
 907         max_active_sends,
 908         EAXCONTEXT_MINMAXACTIVESENDS,
 909         EAXCONTEXT_MAXMAXACTIVESENDS);
 910 }
 911
 912 void ALCcontext::eax_validate_session(
 913     const EAXSESSIONPROPERTIES& eax_session)
 914 {
 915     eax_validate_session_eax_version(eax_session.ulEAXVersion);
 916     eax_validate_session_max_active_sends(eax_session.ulMaxActiveSends);
 917 }
 918
 919 void ALCcontext::eax_validate_macro_fx_factor(
 920     float macro_fx_factor)
 921 {
 922     eax_validate_range<ContextException>(
 923         "Macro FX Factor",
 924         macro_fx_factor,
 925         EAXCONTEXT_MINMACROFXFACTOR,
 926         EAXCONTEXT_MAXMACROFXFACTOR);
 927 }
 928
 929 void ALCcontext::eax_validate_context_all(
 930     const EAX40CONTEXTPROPERTIES& context_all)
 931 {
 932     eax_validate_primary_fx_slot_id(context_all.guidPrimaryFXSlotID);
 933     eax_validate_distance_factor(context_all.flDistanceFactor);
 934     eax_validate_air_absorption_hf(context_all.flAirAbsorptionHF);
 935     eax_validate_hf_reference(context_all.flHFReference);
 936 }
 937
 938 void ALCcontext::eax_validate_context_all(
 939     const EAX50CONTEXTPROPERTIES& context_all)
 940 {
 941     eax_validate_context_all(static_cast<const EAX40CONTEXTPROPERTIES>(context_all));
 942     eax_validate_macro_fx_factor(context_all.flMacroFXFactor);
 943 }
 944
 945 void ALCcontext::eax_defer_primary_fx_slot_id(
 946     const GUID& primary_fx_slot_id)
 947 {
 948     eax_d_.context.guidPrimaryFXSlotID = primary_fx_slot_id;
 949
 950     eax_context_dirty_flags_.guidPrimaryFXSlotID =
 951         (eax_.context.guidPrimaryFXSlotID != eax_d_.context.guidPrimaryFXSlotID);
 952 }
 953
 954 void ALCcontext::eax_defer_distance_factor(
 955     float distance_factor)
 956 {
 957     eax_d_.context.flDistanceFactor = distance_factor;
 958
 959     eax_context_dirty_flags_.flDistanceFactor =
 960         (eax_.context.flDistanceFactor != eax_d_.context.flDistanceFactor);
 961 }
 962
 963 void ALCcontext::eax_defer_air_absorption_hf(
 964     float air_absorption_hf)
 965 {
 966     eax_d_.context.flAirAbsorptionHF = air_absorption_hf;
 967
 968     eax_context_dirty_flags_.flAirAbsorptionHF =
 969         (eax_.context.flAirAbsorptionHF != eax_d_.context.flAirAbsorptionHF);
 970 }
 971
 972 void ALCcontext::eax_defer_hf_reference(
 973     float hf_reference)
 974 {
 975     eax_d_.context.flHFReference = hf_reference;
 976
 977     eax_context_dirty_flags_.flHFReference =
 978         (eax_.context.flHFReference != eax_d_.context.flHFReference);
 979 }
 980
 981 void ALCcontext::eax_defer_macro_fx_factor(
 982     float macro_fx_factor)
 983 {
 984     eax_d_.context.flMacroFXFactor = macro_fx_factor;
 985
 986     eax_context_dirty_flags_.flMacroFXFactor =
 987         (eax_.context.flMacroFXFactor != eax_d_.context.flMacroFXFactor);
 988 }
 989
 990 void ALCcontext::eax_defer_context_all(
 991     const EAX40CONTEXTPROPERTIES& context_all)
 992 {
 993     eax_defer_primary_fx_slot_id(context_all.guidPrimaryFXSlotID);
 994     eax_defer_distance_factor(context_all.flDistanceFactor);
 995     eax_defer_air_absorption_hf(context_all.flAirAbsorptionHF);
 996     eax_defer_hf_reference(context_all.flHFReference);
 997 }
 998
 999 void ALCcontext::eax_defer_context_all(
1000     const EAX50CONTEXTPROPERTIES& context_all)
1001 {
1002     eax_defer_context_all(static_cast<const EAX40CONTEXTPROPERTIES&>(context_all));
1003     eax_defer_macro_fx_factor(context_all.flMacroFXFactor);
1004 }
1005
1006 void ALCcontext::eax_defer_context_all(
1007     const EaxEaxCall& eax_call)
1008 {
1009     switch(eax_call.get_version())
1010     {
1011     case 4:
1012         {
1013             const auto& context_all =
1014                 eax_call.get_value<ContextException, EAX40CONTEXTPROPERTIES>();
1015
1016             eax_validate_context_all(context_all);
1017             eax_defer_context_all(context_all);
1018         }
1019         break;
1020
1021     case 5:
1022         {
1023             const auto& context_all =
1024                 eax_call.get_value<ContextException, EAX50CONTEXTPROPERTIES>();
1025
1026             eax_validate_context_all(context_all);
1027             eax_defer_context_all(context_all);
1028         }
1029         break;
1030
1031     default:
1032         eax_fail("Unsupported EAX version.");
1033     }
1034 }
1035
1036 void ALCcontext::eax_defer_primary_fx_slot_id(
1037     const EaxEaxCall& eax_call)
1038 {
1039     const auto& primary_fx_slot_id =
1040         eax_call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::guidPrimaryFXSlotID)>();
1041
1042     eax_validate_primary_fx_slot_id(primary_fx_slot_id);
1043     eax_defer_primary_fx_slot_id(primary_fx_slot_id);
1044 }
1045
1046 void ALCcontext::eax_defer_distance_factor(
1047     const EaxEaxCall& eax_call)
1048 {
1049     const auto& distance_factor =
1050         eax_call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flDistanceFactor)>();
1051
1052     eax_validate_distance_factor(distance_factor);
1053     eax_defer_distance_factor(distance_factor);
1054 }
1055
1056 void ALCcontext::eax_defer_air_absorption_hf(
1057     const EaxEaxCall& eax_call)
1058 {
1059     const auto& air_absorption_hf =
1060         eax_call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flAirAbsorptionHF)>();
1061
1062     eax_validate_air_absorption_hf(air_absorption_hf);
1063     eax_defer_air_absorption_hf(air_absorption_hf);
1064 }
1065
1066 void ALCcontext::eax_defer_hf_reference(
1067     const EaxEaxCall& eax_call)
1068 {
1069     const auto& hf_reference =
1070         eax_call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flHFReference)>();
1071
1072     eax_validate_hf_reference(hf_reference);
1073     eax_defer_hf_reference(hf_reference);
1074 }
1075
1076 void ALCcontext::eax_set_session(
1077     const EaxEaxCall& eax_call)
1078 {
1079     const auto& eax_session =
1080         eax_call.get_value<ContextException, const EAXSESSIONPROPERTIES>();
1081
1082     eax_validate_session(eax_session);
1083
1084     eax_session_ = eax_session;
1085 }
1086
1087 void ALCcontext::eax_defer_macro_fx_factor(
1088     const EaxEaxCall& eax_call)
1089 {
1090     const auto& macro_fx_factor =
1091         eax_call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flMacroFXFactor)>();
1092
1093     eax_validate_macro_fx_factor(macro_fx_factor);
1094     eax_defer_macro_fx_factor(macro_fx_factor);
1095 }
1096
1097 void ALCcontext::eax_set(
1098     const EaxEaxCall& eax_call)
1099 {
1100     switch (eax_call.get_property_id())
1101     {
1102         case EAXCONTEXT_NONE:
1103             break;
1104
1105         case EAXCONTEXT_ALLPARAMETERS:
1106             eax_defer_context_all(eax_call);
1107             break;
1108
1109         case EAXCONTEXT_PRIMARYFXSLOTID:
1110             eax_defer_primary_fx_slot_id(eax_call);
1111             break;
1112
1113         case EAXCONTEXT_DISTANCEFACTOR:
1114             eax_defer_distance_factor(eax_call);
1115             break;
1116
1117         case EAXCONTEXT_AIRABSORPTIONHF:
1118             eax_defer_air_absorption_hf(eax_call);
1119             break;
1120
1121         case EAXCONTEXT_HFREFERENCE:
1122             eax_defer_hf_reference(eax_call);
1123             break;
1124
1125         case EAXCONTEXT_LASTERROR:
1126             eax_fail("Last error is read-only.");
1127
1128         case EAXCONTEXT_SPEAKERCONFIG:
1129             eax_fail("Speaker configuration is read-only.");
1130
1131         case EAXCONTEXT_EAXSESSION:
1132             eax_set_session(eax_call);
1133             break;
1134
1135         case EAXCONTEXT_MACROFXFACTOR:
1136             eax_defer_macro_fx_factor(eax_call);
1137             break;
1138
1139         default:
1140             eax_fail("Unsupported property id.");
1141     }
1142 }
1143
1144 void ALCcontext::eax_apply_deferred()
1145 {
1146     if (eax_context_dirty_flags_ == ContextDirtyFlags{})
1147     {
1148         return;
1149     }
1150
1151     eax_ = eax_d_;
1152
1153     if (eax_context_dirty_flags_.guidPrimaryFXSlotID)
1154     {
1155         eax_context_shared_dirty_flags_.primary_fx_slot_id = true;
1156         eax_set_primary_fx_slot_id();
1157     }
1158
1159     if (eax_context_dirty_flags_.flDistanceFactor)
1160     {
1161         eax_set_distance_factor();
1162     }
1163
1164     if (eax_context_dirty_flags_.flAirAbsorptionHF)
1165     {
1166         eax_set_air_absorbtion_hf();
1167     }
1168
1169     if (eax_context_dirty_flags_.flHFReference)
1170     {
1171         eax_set_hf_reference();
1172     }
1173
1174     if (eax_context_dirty_flags_.flMacroFXFactor)
1175     {
1176         eax_set_macro_fx_factor();
1177     }
1178
1179     if (eax_context_shared_dirty_flags_ != EaxContextSharedDirtyFlags{})
1180     {
1181         eax_update_sources();
1182     }
1183
1184     eax_context_shared_dirty_flags_ = EaxContextSharedDirtyFlags{};
1185     eax_context_dirty_flags_ = ContextDirtyFlags{};
1186 }
1187
1188
1189 namespace
1190 {
1191
1192
1193 class EaxSetException :
1194     public EaxException
1195 {
1196 public:
1197     explicit EaxSetException(
1198         const char* message)
1199         :
1200         EaxException{"EAX_SET", message}
1201     {
1202     }
1203 }; // EaxSetException
1204
1205
1206 [[noreturn]]
1207 void eax_fail_set(
1208     const char* message)
1209 {
1210     throw EaxSetException{message};
1211 }
1212
1213
1214 class EaxGetException :
1215     public EaxException
1216 {
1217 public:
1218     explicit EaxGetException(
1219         const char* message)
1220         :
1221         EaxException{"EAX_GET", message}
1222     {
1223     }
1224 }; // EaxGetException
1225
1226
1227 [[noreturn]]
1228 void eax_fail_get(
1229     const char* message)
1230 {
1231     throw EaxGetException{message};
1232 }
1233
1234
1235 } // namespace
1236
1237
1238 FORCE_ALIGN ALenum AL_APIENTRY EAXSet(
1239     const GUID* property_set_id,
1240     ALuint property_id,
1241     ALuint property_source_id,
1242     ALvoid* property_value,
1243     ALuint property_value_size) noexcept
1244 try
1245 {
1246     auto context = GetContextRef();
1247
1248     if (!context)
1249     {
1250         eax_fail_set("No current context.");
1251     }
1252
1253     std::lock_guard<std::mutex> prop_lock{context->mPropLock};
1254
1255     return context->eax_eax_set(
1256         property_set_id,
1257         property_id,
1258         property_source_id,
1259         property_value,
1260         property_value_size
1261     );
1262 }
1263 catch (...)
1264 {
1265     eax_log_exception(__func__);
1266     return AL_INVALID_OPERATION;
1267 }
1268
1269 FORCE_ALIGN ALenum AL_APIENTRY EAXGet(
1270     const GUID* property_set_id,
1271     ALuint property_id,
1272     ALuint property_source_id,
1273     ALvoid* property_value,
1274     ALuint property_value_size) noexcept
1275 try
1276 {
1277     auto context = GetContextRef();
1278
1279     if (!context)
1280     {
1281         eax_fail_get("No current context.");
1282     }
1283
1284     std::lock_guard<std::mutex> prop_lock{context->mPropLock};
1285
1286     return context->eax_eax_get(
1287         property_set_id,
1288         property_id,
1289         property_source_id,
1290         property_value,
1291         property_value_size
1292     );
1293 }
1294 catch (...)
1295 {
1296     eax_log_exception(__func__);
1297     return AL_INVALID_OPERATION;
1298 }
1299 #endif // ALSOFT_EAX