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     const auto call = create_eax_call(
 334         EaxCallType::set,
 335         property_set_id,
 336         property_id,
 337         property_source_id,
 338         property_value,
 339         property_value_size);
 340     eax_initialize(call);
 341     eax_unlock_legacy_fx_slots(call);
 342
 343     switch (call.get_property_set_id())
 344     {
 345         case EaxCallPropertySetId::context:
 346             eax_set(call);
 347             break;
 348
 349         case EaxCallPropertySetId::fx_slot:
 350         case EaxCallPropertySetId::fx_slot_effect:
 351             eax_dispatch_fx_slot(call);
 352             break;
 353
 354         case EaxCallPropertySetId::source:
 355             eax_dispatch_source(call);
 356             break;
 357
 358         default:
 359             eax_fail("Unsupported property set id.");
 360     }
 361
 362     static constexpr auto deferred_flag = 0x80000000u;
 363     if(!(property_id&deferred_flag) && !mDeferUpdates)
 364         applyAllUpdates();
 365
 366     return AL_NO_ERROR;
 367 }
 368
 369 ALenum ALCcontext::eax_eax_get(
 370     const GUID* property_set_id,
 371     ALuint property_id,
 372     ALuint property_source_id,
 373     ALvoid* property_value,
 374     ALuint property_value_size)
 375 {
 376     const auto call = create_eax_call(
 377         EaxCallType::get,
 378         property_set_id,
 379         property_id,
 380         property_source_id,
 381         property_value,
 382         property_value_size);
 383     eax_initialize(call);
 384     eax_unlock_legacy_fx_slots(call);
 385
 386     switch (call.get_property_set_id())
 387     {
 388         case EaxCallPropertySetId::context:
 389             eax_get(call);
 390             break;
 391
 392         case EaxCallPropertySetId::fx_slot:
 393         case EaxCallPropertySetId::fx_slot_effect:
 394             eax_dispatch_fx_slot(call);
 395             break;
 396
 397         case EaxCallPropertySetId::source:
 398             eax_dispatch_source(call);
 399             break;
 400
 401         default:
 402             eax_fail("Unsupported property set id.");
 403     }
 404
 405     return AL_NO_ERROR;
 406 }
 407
 408 void ALCcontext::eax_update_filters()
 409 {
 410     ForEachSource(this, std::mem_fn(&ALsource::eax_update_filters));
 411 }
 412
 413 void ALCcontext::eax_commit_and_update_sources()
 414 {
 415     std::unique_lock<std::mutex> source_lock{mSourceLock};
 416     ForEachSource(this, std::mem_fn(&ALsource::eax_commit_and_update));
 417 }
 418
 419 void ALCcontext::eax_set_last_error() noexcept
 420 {
 421     eax_last_error_ = EAXERR_INVALID_OPERATION;
 422 }
 423
 424 [[noreturn]]
 425 void ALCcontext::eax_fail(
 426     const char* message)
 427 {
 428     throw ContextException{message};
 429 }
 430
 431 void ALCcontext::eax_initialize_extensions()
 432 {
 433     if (!eax_g_is_enabled)
 434     {
 435         return;
 436     }
 437
 438     const auto string_max_capacity =
 439         std::strlen(mExtensionList) + 1 +
 440         std::strlen(eax1_ext_name) + 1 +
 441         std::strlen(eax2_ext_name) + 1 +
 442         std::strlen(eax3_ext_name) + 1 +
 443         std::strlen(eax4_ext_name) + 1 +
 444         std::strlen(eax5_ext_name) + 1 +
 445         std::strlen(eax_x_ram_ext_name) + 1 +
 446         0;
 447
 448     eax_extension_list_.reserve(string_max_capacity);
 449
 450     if (eax_is_capable())
 451     {
 452         eax_extension_list_ += eax1_ext_name;
 453         eax_extension_list_ += ' ';
 454
 455         eax_extension_list_ += eax2_ext_name;
 456         eax_extension_list_ += ' ';
 457
 458         eax_extension_list_ += eax3_ext_name;
 459         eax_extension_list_ += ' ';
 460
 461         eax_extension_list_ += eax4_ext_name;
 462         eax_extension_list_ += ' ';
 463
 464         eax_extension_list_ += eax5_ext_name;
 465         eax_extension_list_ += ' ';
 466     }
 467
 468     eax_extension_list_ += eax_x_ram_ext_name;
 469     eax_extension_list_ += ' ';
 470
 471     eax_extension_list_ += mExtensionList;
 472     mExtensionList = eax_extension_list_.c_str();
 473 }
 474
 475 void ALCcontext::eax_initialize(const EaxCall& call)
 476 {
 477     if (eax_is_initialized_)
 478     {
 479         return;
 480     }
 481
 482     if (eax_is_tried_)
 483     {
 484         eax_fail("No EAX.");
 485     }
 486
 487     eax_is_tried_ = true;
 488
 489     if (!eax_g_is_enabled)
 490     {
 491         eax_fail("EAX disabled by a configuration.");
 492     }
 493
 494     eax_ensure_compatibility();
 495     eax_set_defaults();
 496     eax_set_air_absorbtion_hf();
 497     eax_update_speaker_configuration();
 498     eax_initialize_fx_slots(call);
 499     eax_initialize_sources();
 500
 501     eax_is_initialized_ = true;
 502 }
 503
 504 bool ALCcontext::eax_has_no_default_effect_slot() const noexcept
 505 {
 506     return mDefaultSlot == nullptr;
 507 }
 508
 509 void ALCcontext::eax_ensure_no_default_effect_slot() const
 510 {
 511     if (!eax_has_no_default_effect_slot())
 512     {
 513         eax_fail("There is a default effect slot in the context.");
 514     }
 515 }
 516
 517 bool ALCcontext::eax_has_enough_aux_sends() const noexcept
 518 {
 519     return mALDevice->NumAuxSends >= EAX_MAX_FXSLOTS;
 520 }
 521
 522 void ALCcontext::eax_ensure_enough_aux_sends() const
 523 {
 524     if (!eax_has_enough_aux_sends())
 525     {
 526         eax_fail("Not enough aux sends.");
 527     }
 528 }
 529
 530 void ALCcontext::eax_ensure_compatibility()
 531 {
 532     eax_ensure_enough_aux_sends();
 533 }
 534
 535 unsigned long ALCcontext::eax_detect_speaker_configuration() const
 536 {
 537 #define EAX_PREFIX "[EAX_DETECT_SPEAKER_CONFIG]"
 538
 539     switch(mDevice->FmtChans)
 540     {
 541     case DevFmtMono: return SPEAKERS_2;
 542     case DevFmtStereo:
 543         /* Pretend 7.1 if using UHJ output, since they both provide full
 544          * horizontal surround.
 545          */
 546         if(mDevice->mUhjEncoder)
 547             return SPEAKERS_7;
 548         if(mDevice->Flags.test(DirectEar))
 549             return HEADPHONES;
 550         return SPEAKERS_2;
 551     case DevFmtQuad: return SPEAKERS_4;
 552     case DevFmtX51: return SPEAKERS_5;
 553     case DevFmtX61: return SPEAKERS_6;
 554     case DevFmtX71: return SPEAKERS_7;
 555     /* 3D7.1 is only compatible with 5.1. This could instead be HEADPHONES to
 556      * suggest full-sphere surround sound (like HRTF).
 557      */
 558     case DevFmtX3D71: return SPEAKERS_5;
 559     /* This could also be HEADPHONES, since headphones-based HRTF and Ambi3D
 560      * provide full-sphere surround sound. Depends if apps are more likely to
 561      * consider headphones or 7.1 for surround sound support.
 562      */
 563     case DevFmtAmbi3D: return SPEAKERS_7;
 564     }
 565     ERR(EAX_PREFIX "Unexpected device channel format 0x%x.\n", mDevice->FmtChans);
 566     return HEADPHONES;
 567
 568 #undef EAX_PREFIX
 569 }
 570
 571 void ALCcontext::eax_update_speaker_configuration()
 572 {
 573     eax_speaker_config_ = eax_detect_speaker_configuration();
 574 }
 575
 576 void ALCcontext::eax_set_last_error_defaults() noexcept
 577 {
 578     eax_last_error_ = EAX_OK;
 579 }
 580
 581 void ALCcontext::eax_set_session_defaults() noexcept
 582 {
 583     eax_session_.ulEAXVersion = EAXCONTEXT_MINEAXSESSION;
 584     eax_session_.ulMaxActiveSends = EAXCONTEXT_DEFAULTMAXACTIVESENDS;
 585 }
 586
 587 void ALCcontext::eax_set_context_defaults() noexcept
 588 {
 589     eax_.context.guidPrimaryFXSlotID = EAXCONTEXT_DEFAULTPRIMARYFXSLOTID;
 590     eax_.context.flDistanceFactor = EAXCONTEXT_DEFAULTDISTANCEFACTOR;
 591     eax_.context.flAirAbsorptionHF = EAXCONTEXT_DEFAULTAIRABSORPTIONHF;
 592     eax_.context.flHFReference = EAXCONTEXT_DEFAULTHFREFERENCE;
 593 }
 594
 595 void ALCcontext::eax_set_defaults() noexcept
 596 {
 597     eax_set_last_error_defaults();
 598     eax_set_session_defaults();
 599     eax_set_context_defaults();
 600
 601     eax_d_ = eax_;
 602 }
 603
 604 void ALCcontext::eax_unlock_legacy_fx_slots(const EaxCall& call) noexcept
 605 {
 606     if (call.get_version() != 5 || eax_are_legacy_fx_slots_unlocked_)
 607         return;
 608
 609     eax_are_legacy_fx_slots_unlocked_ = true;
 610     eax_fx_slots_.unlock_legacy();
 611 }
 612
 613 void ALCcontext::eax_dispatch_fx_slot(const EaxCall& call)
 614 {
 615     const auto fx_slot_index = call.get_fx_slot_index();
 616     if(!fx_slot_index.has_value())
 617         eax_fail("Invalid fx slot index.");
 618
 619     auto& fx_slot = eax_get_fx_slot(*fx_slot_index);
 620     if(fx_slot.eax_dispatch(call))
 621     {
 622         std::lock_guard<std::mutex> source_lock{mSourceLock};
 623         eax_update_filters();
 624     }
 625 }
 626
 627 void ALCcontext::eax_dispatch_source(const EaxCall& call)
 628 {
 629     const auto source_id = call.get_property_al_name();
 630
 631     std::lock_guard<std::mutex> source_lock{mSourceLock};
 632
 633     const auto source = ALsource::eax_lookup_source(*this, source_id);
 634
 635     if (!source)
 636     {
 637         eax_fail("Source not found.");
 638     }
 639
 640     source->eax_dispatch(call);
 641 }
 642
 643 void ALCcontext::eax_get_primary_fx_slot_id(const EaxCall& call)
 644 {
 645     call.set_value<ContextException>(eax_.context.guidPrimaryFXSlotID);
 646 }
 647
 648 void ALCcontext::eax_get_distance_factor(const EaxCall& call)
 649 {
 650     call.set_value<ContextException>(eax_.context.flDistanceFactor);
 651 }
 652
 653 void ALCcontext::eax_get_air_absorption_hf(const EaxCall& call)
 654 {
 655     call.set_value<ContextException>(eax_.context.flAirAbsorptionHF);
 656 }
 657
 658 void ALCcontext::eax_get_hf_reference(const EaxCall& call)
 659 {
 660     call.set_value<ContextException>(eax_.context.flHFReference);
 661 }
 662
 663 void ALCcontext::eax_get_last_error(const EaxCall& call)
 664 {
 665     const auto eax_last_error = eax_last_error_;
 666     eax_last_error_ = EAX_OK;
 667     call.set_value<ContextException>(eax_last_error);
 668 }
 669
 670 void ALCcontext::eax_get_speaker_config(const EaxCall& call)
 671 {
 672     call.set_value<ContextException>(eax_speaker_config_);
 673 }
 674
 675 void ALCcontext::eax_get_session(const EaxCall& call)
 676 {
 677     call.set_value<ContextException>(eax_session_);
 678 }
 679
 680 void ALCcontext::eax_get_macro_fx_factor(const EaxCall& call)
 681 {
 682     call.set_value<ContextException>(eax_.context.flMacroFXFactor);
 683 }
 684
 685 void ALCcontext::eax_get_context_all(const EaxCall& call)
 686 {
 687     switch (call.get_version())
 688     {
 689         case 4:
 690             call.set_value<ContextException>(static_cast<const EAX40CONTEXTPROPERTIES&>(eax_.context));
 691             break;
 692
 693         case 5:
 694             call.set_value<ContextException>(static_cast<const EAX50CONTEXTPROPERTIES&>(eax_.context));
 695             break;
 696
 697         default:
 698             eax_fail("Unsupported EAX version.");
 699     }
 700 }
 701
 702 void ALCcontext::eax_get(const EaxCall& call)
 703 {
 704     switch (call.get_property_id())
 705     {
 706         case EAXCONTEXT_NONE:
 707             break;
 708
 709         case EAXCONTEXT_ALLPARAMETERS:
 710             eax_get_context_all(call);
 711             break;
 712
 713         case EAXCONTEXT_PRIMARYFXSLOTID:
 714             eax_get_primary_fx_slot_id(call);
 715             break;
 716
 717         case EAXCONTEXT_DISTANCEFACTOR:
 718             eax_get_distance_factor(call);
 719             break;
 720
 721         case EAXCONTEXT_AIRABSORPTIONHF:
 722             eax_get_air_absorption_hf(call);
 723             break;
 724
 725         case EAXCONTEXT_HFREFERENCE:
 726             eax_get_hf_reference(call);
 727             break;
 728
 729         case EAXCONTEXT_LASTERROR:
 730             eax_get_last_error(call);
 731             break;
 732
 733         case EAXCONTEXT_SPEAKERCONFIG:
 734             eax_get_speaker_config(call);
 735             break;
 736
 737         case EAXCONTEXT_EAXSESSION:
 738             eax_get_session(call);
 739             break;
 740
 741         case EAXCONTEXT_MACROFXFACTOR:
 742             eax_get_macro_fx_factor(call);
 743             break;
 744
 745         default:
 746             eax_fail("Unsupported property id.");
 747     }
 748 }
 749
 750 void ALCcontext::eax_set_primary_fx_slot_id()
 751 {
 752     eax_previous_primary_fx_slot_index_ = eax_primary_fx_slot_index_;
 753     eax_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 754 }
 755
 756 void ALCcontext::eax_set_distance_factor()
 757 {
 758     mListener.mMetersPerUnit = eax_.context.flDistanceFactor;
 759     mPropsDirty = true;
 760 }
 761
 762 void ALCcontext::eax_set_air_absorbtion_hf()
 763 {
 764     mAirAbsorptionGainHF = level_mb_to_gain(eax_.context.flAirAbsorptionHF);
 765     mPropsDirty = true;
 766 }
 767
 768 void ALCcontext::eax_set_hf_reference()
 769 {
 770     // TODO
 771 }
 772
 773 void ALCcontext::eax_set_macro_fx_factor()
 774 {
 775     // TODO
 776 }
 777
 778 void ALCcontext::eax_set_context()
 779 {
 780     eax_set_primary_fx_slot_id();
 781     eax_set_distance_factor();
 782     eax_set_air_absorbtion_hf();
 783     eax_set_hf_reference();
 784 }
 785
 786 void ALCcontext::eax_initialize_fx_slots(const EaxCall& call)
 787 {
 788     eax_fx_slots_.initialize(call, *this);
 789     eax_previous_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 790     eax_primary_fx_slot_index_ = eax_.context.guidPrimaryFXSlotID;
 791 }
 792
 793 void ALCcontext::eax_initialize_sources()
 794 {
 795     std::unique_lock<std::mutex> source_lock{mSourceLock};
 796     auto init_source = [this](ALsource &source) noexcept
 797     { source.eax_initialize(this); };
 798     ForEachSource(this, init_source);
 799 }
 800
 801 void ALCcontext::eax_update_sources()
 802 {
 803     std::unique_lock<std::mutex> source_lock{mSourceLock};
 804     auto update_source = [this](ALsource &source)
 805     { source.eax_update(eax_context_shared_dirty_flags_); };
 806     ForEachSource(this, update_source);
 807 }
 808
 809 void ALCcontext::eax_validate_primary_fx_slot_id(
 810     const GUID& primary_fx_slot_id)
 811 {
 812     if (primary_fx_slot_id != EAX_NULL_GUID &&
 813         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot0 &&
 814         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot0 &&
 815         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot1 &&
 816         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot1 &&
 817         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot2 &&
 818         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot2 &&
 819         primary_fx_slot_id != EAXPROPERTYID_EAX40_FXSlot3 &&
 820         primary_fx_slot_id != EAXPROPERTYID_EAX50_FXSlot3)
 821     {
 822         eax_fail("Unsupported primary FX slot id.");
 823     }
 824 }
 825
 826 void ALCcontext::eax_validate_distance_factor(
 827     float distance_factor)
 828 {
 829     eax_validate_range<ContextException>(
 830         "Distance Factor",
 831         distance_factor,
 832         EAXCONTEXT_MINDISTANCEFACTOR,
 833         EAXCONTEXT_MAXDISTANCEFACTOR);
 834 }
 835
 836 void ALCcontext::eax_validate_air_absorption_hf(
 837     float air_absorption_hf)
 838 {
 839     eax_validate_range<ContextException>(
 840         "Air Absorption HF",
 841         air_absorption_hf,
 842         EAXCONTEXT_MINAIRABSORPTIONHF,
 843         EAXCONTEXT_MAXAIRABSORPTIONHF);
 844 }
 845
 846 void ALCcontext::eax_validate_hf_reference(
 847     float hf_reference)
 848 {
 849     eax_validate_range<ContextException>(
 850         "HF Reference",
 851         hf_reference,
 852         EAXCONTEXT_MINHFREFERENCE,
 853         EAXCONTEXT_MAXHFREFERENCE);
 854 }
 855
 856 void ALCcontext::eax_validate_speaker_config(
 857     unsigned long speaker_config)
 858 {
 859     switch (speaker_config)
 860     {
 861         case HEADPHONES:
 862         case SPEAKERS_2:
 863         case SPEAKERS_4:
 864         case SPEAKERS_5:
 865         case SPEAKERS_6:
 866         case SPEAKERS_7:
 867             break;
 868
 869         default:
 870             eax_fail("Unsupported speaker configuration.");
 871     }
 872 }
 873
 874 void ALCcontext::eax_validate_session_eax_version(
 875     unsigned long eax_version)
 876 {
 877     switch (eax_version)
 878     {
 879         case EAX_40:
 880         case EAX_50:
 881             break;
 882
 883         default:
 884             eax_fail("Unsupported session EAX version.");
 885     }
 886 }
 887
 888 void ALCcontext::eax_validate_session_max_active_sends(
 889     unsigned long max_active_sends)
 890 {
 891     eax_validate_range<ContextException>(
 892         "Max Active Sends",
 893         max_active_sends,
 894         EAXCONTEXT_MINMAXACTIVESENDS,
 895         EAXCONTEXT_MAXMAXACTIVESENDS);
 896 }
 897
 898 void ALCcontext::eax_validate_session(
 899     const EAXSESSIONPROPERTIES& eax_session)
 900 {
 901     eax_validate_session_eax_version(eax_session.ulEAXVersion);
 902     eax_validate_session_max_active_sends(eax_session.ulMaxActiveSends);
 903 }
 904
 905 void ALCcontext::eax_validate_macro_fx_factor(
 906     float macro_fx_factor)
 907 {
 908     eax_validate_range<ContextException>(
 909         "Macro FX Factor",
 910         macro_fx_factor,
 911         EAXCONTEXT_MINMACROFXFACTOR,
 912         EAXCONTEXT_MAXMACROFXFACTOR);
 913 }
 914
 915 void ALCcontext::eax_validate_context_all(
 916     const EAX40CONTEXTPROPERTIES& context_all)
 917 {
 918     eax_validate_primary_fx_slot_id(context_all.guidPrimaryFXSlotID);
 919     eax_validate_distance_factor(context_all.flDistanceFactor);
 920     eax_validate_air_absorption_hf(context_all.flAirAbsorptionHF);
 921     eax_validate_hf_reference(context_all.flHFReference);
 922 }
 923
 924 void ALCcontext::eax_validate_context_all(
 925     const EAX50CONTEXTPROPERTIES& context_all)
 926 {
 927     eax_validate_context_all(static_cast<const EAX40CONTEXTPROPERTIES>(context_all));
 928     eax_validate_macro_fx_factor(context_all.flMacroFXFactor);
 929 }
 930
 931 void ALCcontext::eax_defer_primary_fx_slot_id(
 932     const GUID& primary_fx_slot_id)
 933 {
 934     eax_d_.context.guidPrimaryFXSlotID = primary_fx_slot_id;
 935
 936     eax_context_dirty_flags_.guidPrimaryFXSlotID =
 937         (eax_.context.guidPrimaryFXSlotID != eax_d_.context.guidPrimaryFXSlotID);
 938 }
 939
 940 void ALCcontext::eax_defer_distance_factor(
 941     float distance_factor)
 942 {
 943     eax_d_.context.flDistanceFactor = distance_factor;
 944
 945     eax_context_dirty_flags_.flDistanceFactor =
 946         (eax_.context.flDistanceFactor != eax_d_.context.flDistanceFactor);
 947 }
 948
 949 void ALCcontext::eax_defer_air_absorption_hf(
 950     float air_absorption_hf)
 951 {
 952     eax_d_.context.flAirAbsorptionHF = air_absorption_hf;
 953
 954     eax_context_dirty_flags_.flAirAbsorptionHF =
 955         (eax_.context.flAirAbsorptionHF != eax_d_.context.flAirAbsorptionHF);
 956 }
 957
 958 void ALCcontext::eax_defer_hf_reference(
 959     float hf_reference)
 960 {
 961     eax_d_.context.flHFReference = hf_reference;
 962
 963     eax_context_dirty_flags_.flHFReference =
 964         (eax_.context.flHFReference != eax_d_.context.flHFReference);
 965 }
 966
 967 void ALCcontext::eax_defer_macro_fx_factor(
 968     float macro_fx_factor)
 969 {
 970     eax_d_.context.flMacroFXFactor = macro_fx_factor;
 971
 972     eax_context_dirty_flags_.flMacroFXFactor =
 973         (eax_.context.flMacroFXFactor != eax_d_.context.flMacroFXFactor);
 974 }
 975
 976 void ALCcontext::eax_defer_context_all(
 977     const EAX40CONTEXTPROPERTIES& context_all)
 978 {
 979     eax_defer_primary_fx_slot_id(context_all.guidPrimaryFXSlotID);
 980     eax_defer_distance_factor(context_all.flDistanceFactor);
 981     eax_defer_air_absorption_hf(context_all.flAirAbsorptionHF);
 982     eax_defer_hf_reference(context_all.flHFReference);
 983 }
 984
 985 void ALCcontext::eax_defer_context_all(
 986     const EAX50CONTEXTPROPERTIES& context_all)
 987 {
 988     eax_defer_context_all(static_cast<const EAX40CONTEXTPROPERTIES&>(context_all));
 989     eax_defer_macro_fx_factor(context_all.flMacroFXFactor);
 990 }
 991
 992 void ALCcontext::eax_defer_context_all(const EaxCall& call)
 993 {
 994     switch(call.get_version())
 995     {
 996     case 4:
 997         {
 998             const auto& context_all =
 999                 call.get_value<ContextException, EAX40CONTEXTPROPERTIES>();
1000
1001             eax_validate_context_all(context_all);
1002             eax_defer_context_all(context_all);
1003         }
1004         break;
1005
1006     case 5:
1007         {
1008             const auto& context_all =
1009                 call.get_value<ContextException, EAX50CONTEXTPROPERTIES>();
1010
1011             eax_validate_context_all(context_all);
1012             eax_defer_context_all(context_all);
1013         }
1014         break;
1015
1016     default:
1017         eax_fail("Unsupported EAX version.");
1018     }
1019 }
1020
1021 void ALCcontext::eax_defer_primary_fx_slot_id(const EaxCall& call)
1022 {
1023     const auto& primary_fx_slot_id =
1024         call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::guidPrimaryFXSlotID)>();
1025
1026     eax_validate_primary_fx_slot_id(primary_fx_slot_id);
1027     eax_defer_primary_fx_slot_id(primary_fx_slot_id);
1028 }
1029
1030 void ALCcontext::eax_defer_distance_factor(const EaxCall& call)
1031 {
1032     const auto& distance_factor =
1033         call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flDistanceFactor)>();
1034
1035     eax_validate_distance_factor(distance_factor);
1036     eax_defer_distance_factor(distance_factor);
1037 }
1038
1039 void ALCcontext::eax_defer_air_absorption_hf(const EaxCall& call)
1040 {
1041     const auto& air_absorption_hf =
1042         call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flAirAbsorptionHF)>();
1043
1044     eax_validate_air_absorption_hf(air_absorption_hf);
1045     eax_defer_air_absorption_hf(air_absorption_hf);
1046 }
1047
1048 void ALCcontext::eax_defer_hf_reference(const EaxCall& call)
1049 {
1050     const auto& hf_reference =
1051         call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flHFReference)>();
1052
1053     eax_validate_hf_reference(hf_reference);
1054     eax_defer_hf_reference(hf_reference);
1055 }
1056
1057 void ALCcontext::eax_set_session(const EaxCall& call)
1058 {
1059     const auto& eax_session =
1060         call.get_value<ContextException, const EAXSESSIONPROPERTIES>();
1061
1062     eax_validate_session(eax_session);
1063
1064     eax_session_ = eax_session;
1065 }
1066
1067 void ALCcontext::eax_defer_macro_fx_factor(const EaxCall& call)
1068 {
1069     const auto& macro_fx_factor =
1070         call.get_value<ContextException, const decltype(EAX50CONTEXTPROPERTIES::flMacroFXFactor)>();
1071
1072     eax_validate_macro_fx_factor(macro_fx_factor);
1073     eax_defer_macro_fx_factor(macro_fx_factor);
1074 }
1075
1076 void ALCcontext::eax_set(const EaxCall& call)
1077 {
1078     switch (call.get_property_id())
1079     {
1080         case EAXCONTEXT_NONE:
1081             break;
1082
1083         case EAXCONTEXT_ALLPARAMETERS:
1084             eax_defer_context_all(call);
1085             break;
1086
1087         case EAXCONTEXT_PRIMARYFXSLOTID:
1088             eax_defer_primary_fx_slot_id(call);
1089             break;
1090
1091         case EAXCONTEXT_DISTANCEFACTOR:
1092             eax_defer_distance_factor(call);
1093             break;
1094
1095         case EAXCONTEXT_AIRABSORPTIONHF:
1096             eax_defer_air_absorption_hf(call);
1097             break;
1098
1099         case EAXCONTEXT_HFREFERENCE:
1100             eax_defer_hf_reference(call);
1101             break;
1102
1103         case EAXCONTEXT_LASTERROR:
1104             eax_fail("Last error is read-only.");
1105
1106         case EAXCONTEXT_SPEAKERCONFIG:
1107             eax_fail("Speaker configuration is read-only.");
1108
1109         case EAXCONTEXT_EAXSESSION:
1110             eax_set_session(call);
1111             break;
1112
1113         case EAXCONTEXT_MACROFXFACTOR:
1114             eax_defer_macro_fx_factor(call);
1115             break;
1116
1117         default:
1118             eax_fail("Unsupported property id.");
1119     }
1120 }
1121
1122 void ALCcontext::eax_apply_deferred()
1123 {
1124     if (eax_context_dirty_flags_ == ContextDirtyFlags{})
1125     {
1126         return;
1127     }
1128
1129     eax_ = eax_d_;
1130
1131     if (eax_context_dirty_flags_.guidPrimaryFXSlotID)
1132     {
1133         eax_context_shared_dirty_flags_.primary_fx_slot_id = true;
1134         eax_set_primary_fx_slot_id();
1135     }
1136
1137     if (eax_context_dirty_flags_.flDistanceFactor)
1138     {
1139         eax_set_distance_factor();
1140     }
1141
1142     if (eax_context_dirty_flags_.flAirAbsorptionHF)
1143     {
1144         eax_set_air_absorbtion_hf();
1145     }
1146
1147     if (eax_context_dirty_flags_.flHFReference)
1148     {
1149         eax_set_hf_reference();
1150     }
1151
1152     if (eax_context_dirty_flags_.flMacroFXFactor)
1153     {
1154         eax_set_macro_fx_factor();
1155     }
1156
1157     if (eax_context_shared_dirty_flags_ != EaxContextSharedDirtyFlags{})
1158     {
1159         eax_update_sources();
1160     }
1161
1162     eax_context_shared_dirty_flags_ = EaxContextSharedDirtyFlags{};
1163     eax_context_dirty_flags_ = ContextDirtyFlags{};
1164 }
1165
1166
1167 namespace
1168 {
1169
1170
1171 class EaxSetException :
1172     public EaxException
1173 {
1174 public:
1175     explicit EaxSetException(
1176         const char* message)
1177         :
1178         EaxException{"EAX_SET", message}
1179     {
1180     }
1181 }; // EaxSetException
1182
1183
1184 [[noreturn]]
1185 void eax_fail_set(
1186     const char* message)
1187 {
1188     throw EaxSetException{message};
1189 }
1190
1191
1192 class EaxGetException :
1193     public EaxException
1194 {
1195 public:
1196     explicit EaxGetException(
1197         const char* message)
1198         :
1199         EaxException{"EAX_GET", message}
1200     {
1201     }
1202 }; // EaxGetException
1203
1204
1205 [[noreturn]]
1206 void eax_fail_get(
1207     const char* message)
1208 {
1209     throw EaxGetException{message};
1210 }
1211
1212
1213 } // namespace
1214
1215
1216 FORCE_ALIGN ALenum AL_APIENTRY EAXSet(
1217     const GUID* property_set_id,
1218     ALuint property_id,
1219     ALuint property_source_id,
1220     ALvoid* property_value,
1221     ALuint property_value_size) noexcept
1222 try
1223 {
1224     auto context = GetContextRef();
1225
1226     if (!context)
1227     {
1228         eax_fail_set("No current context.");
1229     }
1230
1231     std::lock_guard<std::mutex> prop_lock{context->mPropLock};
1232
1233     return context->eax_eax_set(
1234         property_set_id,
1235         property_id,
1236         property_source_id,
1237         property_value,
1238         property_value_size
1239     );
1240 }
1241 catch (...)
1242 {
1243     eax_log_exception(__func__);
1244     return AL_INVALID_OPERATION;
1245 }
1246
1247 FORCE_ALIGN ALenum AL_APIENTRY EAXGet(
1248     const GUID* property_set_id,
1249     ALuint property_id,
1250     ALuint property_source_id,
1251     ALvoid* property_value,
1252     ALuint property_value_size) noexcept
1253 try
1254 {
1255     auto context = GetContextRef();
1256
1257     if (!context)
1258     {
1259         eax_fail_get("No current context.");
1260     }
1261
1262     std::lock_guard<std::mutex> prop_lock{context->mPropLock};
1263
1264     return context->eax_eax_get(
1265         property_set_id,
1266         property_id,
1267         property_source_id,
1268         property_value,
1269         property_value_size
1270     );
1271 }
1272 catch (...)
1273 {
1274     eax_log_exception(__func__);
1275     return AL_INVALID_OPERATION;
1276 }
1277 #endif // ALSOFT_EAX