al/source.h

   1 #ifndef AL_SOURCE_H
   2 #define AL_SOURCE_H
   3
   4 #include <array>
   5 #include <atomic>
   6 #include <cstddef>
   7 #include <iterator>
   8 #include <limits>
   9 #include <deque>
  10
  11 #include "AL/al.h"
  12 #include "AL/alc.h"
  13
  14 #include "alc/alu.h"
  15 #include "alc/context.h"
  16 #include "alc/inprogext.h"
  17 #include "aldeque.h"
  18 #include "almalloc.h"
  19 #include "alnumeric.h"
  20 #include "atomic.h"
  21 #include "core/voice.h"
  22 #include "vector.h"
  23
  24 #ifdef ALSOFT_EAX
  25 #include "eax_eax_call.h"
  26 #include "eax_fx_slot_index.h"
  27 #include "eax_utils.h"
  28 #endif // ALSOFT_EAX
  29
  30 struct ALbuffer;
  31 struct ALeffectslot;
  32
  33
  34 enum class SourceStereo : bool {
  35     Normal = AL_NORMAL_SOFT,
  36     Enhanced = AL_SUPER_STEREO_SOFT
  37 };
  38
  39 #define DEFAULT_SENDS  2
  40
  41 #define INVALID_VOICE_IDX static_cast<ALuint>(-1)
  42
  43 struct ALbufferQueueItem : public VoiceBufferItem {
  44     ALbuffer *mBuffer{nullptr};
  45
  46     DISABLE_ALLOC()
  47 };
  48
  49
  50 #ifdef ALSOFT_EAX
  51 using EaxSourceSourceFilterDirtyFlagsValue = std::uint_least16_t;
  52
  53 struct EaxSourceSourceFilterDirtyFlags
  54 {
  55     using EaxIsBitFieldStruct = bool;
  56
  57         EaxSourceSourceFilterDirtyFlagsValue lDirect : 1;
  58         EaxSourceSourceFilterDirtyFlagsValue lDirectHF : 1;
  59         EaxSourceSourceFilterDirtyFlagsValue lRoom : 1;
  60         EaxSourceSourceFilterDirtyFlagsValue lRoomHF : 1;
  61         EaxSourceSourceFilterDirtyFlagsValue lObstruction : 1;
  62         EaxSourceSourceFilterDirtyFlagsValue flObstructionLFRatio : 1;
  63         EaxSourceSourceFilterDirtyFlagsValue lOcclusion : 1;
  64         EaxSourceSourceFilterDirtyFlagsValue flOcclusionLFRatio : 1;
  65         EaxSourceSourceFilterDirtyFlagsValue flOcclusionRoomRatio : 1;
  66         EaxSourceSourceFilterDirtyFlagsValue flOcclusionDirectRatio : 1;
  67         EaxSourceSourceFilterDirtyFlagsValue lExclusion : 1;
  68         EaxSourceSourceFilterDirtyFlagsValue flExclusionLFRatio : 1;
  69 }; // EaxSourceSourceFilterDirtyFlags
  70
  71
  72 using EaxSourceSourceMiscDirtyFlagsValue = std::uint_least8_t;
  73
  74 struct EaxSourceSourceMiscDirtyFlags
  75 {
  76     using EaxIsBitFieldStruct = bool;
  77
  78         EaxSourceSourceMiscDirtyFlagsValue lOutsideVolumeHF : 1;
  79         EaxSourceSourceMiscDirtyFlagsValue flDopplerFactor : 1;
  80         EaxSourceSourceMiscDirtyFlagsValue flRolloffFactor : 1;
  81         EaxSourceSourceMiscDirtyFlagsValue flRoomRolloffFactor : 1;
  82         EaxSourceSourceMiscDirtyFlagsValue flAirAbsorptionFactor : 1;
  83         EaxSourceSourceMiscDirtyFlagsValue ulFlags : 1;
  84         EaxSourceSourceMiscDirtyFlagsValue flMacroFXFactor : 1;
  85         EaxSourceSourceMiscDirtyFlagsValue speaker_levels : 1;
  86 }; // EaxSourceSourceMiscDirtyFlags
  87
  88
  89 using EaxSourceSendDirtyFlagsValue = std::uint_least8_t;
  90
  91 struct EaxSourceSendDirtyFlags
  92 {
  93     using EaxIsBitFieldStruct = bool;
  94
  95         EaxSourceSendDirtyFlagsValue lSend : 1;
  96         EaxSourceSendDirtyFlagsValue lSendHF : 1;
  97         EaxSourceSendDirtyFlagsValue lOcclusion : 1;
  98         EaxSourceSendDirtyFlagsValue flOcclusionLFRatio : 1;
  99         EaxSourceSendDirtyFlagsValue flOcclusionRoomRatio : 1;
 100         EaxSourceSendDirtyFlagsValue flOcclusionDirectRatio : 1;
 101         EaxSourceSendDirtyFlagsValue lExclusion : 1;
 102         EaxSourceSendDirtyFlagsValue flExclusionLFRatio : 1;
 103 }; // EaxSourceSendDirtyFlags
 104
 105
 106 struct EaxSourceSendsDirtyFlags
 107 {
 108     using EaxIsBitFieldStruct = bool;
 109
 110         EaxSourceSendDirtyFlags sends[EAX_MAX_FXSLOTS];
 111 }; // EaxSourceSendsDirtyFlags
 112 #endif // ALSOFT_EAX
 113
 114 struct ALsource {
 115     /** Source properties. */
 116     float Pitch{1.0f};
 117     float Gain{1.0f};
 118     float OuterGain{0.0f};
 119     float MinGain{0.0f};
 120     float MaxGain{1.0f};
 121     float InnerAngle{360.0f};
 122     float OuterAngle{360.0f};
 123     float RefDistance{1.0f};
 124     float MaxDistance{std::numeric_limits<float>::max()};
 125     float RolloffFactor{1.0f};
 126     std::array<float,3> Position{{0.0f, 0.0f, 0.0f}};
 127     std::array<float,3> Velocity{{0.0f, 0.0f, 0.0f}};
 128     std::array<float,3> Direction{{0.0f, 0.0f, 0.0f}};
 129     std::array<float,3> OrientAt{{0.0f, 0.0f, -1.0f}};
 130     std::array<float,3> OrientUp{{0.0f, 1.0f,  0.0f}};
 131     bool HeadRelative{false};
 132     bool Looping{false};
 133     DistanceModel mDistanceModel{DistanceModel::Default};
 134     Resampler mResampler{ResamplerDefault};
 135     DirectMode DirectChannels{DirectMode::Off};
 136     SpatializeMode mSpatialize{SpatializeMode::Auto};
 137     SourceStereo mStereoMode{SourceStereo::Normal};
 138
 139     bool DryGainHFAuto{true};
 140     bool WetGainAuto{true};
 141     bool WetGainHFAuto{true};
 142     float OuterGainHF{1.0f};
 143
 144     float AirAbsorptionFactor{0.0f};
 145     float RoomRolloffFactor{0.0f};
 146     float DopplerFactor{1.0f};
 147
 148     /* NOTE: Stereo pan angles are specified in radians, counter-clockwise
 149      * rather than clockwise.
 150      */
 151     std::array<float,2> StereoPan{{al::numbers::pi_v<float>/6.0f, -al::numbers::pi_v<float>/6.0f}};
 152
 153     float Radius{0.0f};
 154     float EnhWidth{0.593f};
 155
 156     /** Direct filter and auxiliary send info. */
 157     struct {
 158         float Gain;
 159         float GainHF;
 160         float HFReference;
 161         float GainLF;
 162         float LFReference;
 163     } Direct;
 164     struct SendData {
 165         ALeffectslot *Slot;
 166         float Gain;
 167         float GainHF;
 168         float HFReference;
 169         float GainLF;
 170         float LFReference;
 171     };
 172     std::array<SendData,MAX_SENDS> Send;
 173
 174     /**
 175      * Last user-specified offset, and the offset type (bytes, samples, or
 176      * seconds).
 177      */
 178     double Offset{0.0};
 179     ALenum OffsetType{AL_NONE};
 180
 181     /** Source type (static, streaming, or undetermined) */
 182     ALenum SourceType{AL_UNDETERMINED};
 183
 184     /** Source state (initial, playing, paused, or stopped) */
 185     ALenum state{AL_INITIAL};
 186
 187     /** Source Buffer Queue head. */
 188     al::deque<ALbufferQueueItem> mQueue;
 189
 190     bool mPropsDirty{true};
 191
 192     /* Index into the context's Voices array. Lazily updated, only checked and
 193      * reset when looking up the voice.
 194      */
 195     ALuint VoiceIdx{INVALID_VOICE_IDX};
 196
 197     /** Self ID */
 198     ALuint id{0};
 199
 200
 201     ALsource();
 202     ~ALsource();
 203
 204     ALsource(const ALsource&) = delete;
 205     ALsource& operator=(const ALsource&) = delete;
 206
 207     DISABLE_ALLOC()
 208
 209 #ifdef ALSOFT_EAX
 210 public:
 211     void eax_initialize(ALCcontext *context) noexcept;
 212
 213
 214     void eax_dispatch(
 215         const EaxEaxCall& eax_call);
 216
 217
 218     void eax_update_filters();
 219
 220     void eax_update(
 221         EaxContextSharedDirtyFlags dirty_flags);
 222
 223     void eax_commit() { eax_apply_deferred(); }
 224     void eax_commit_and_update();
 225
 226     bool eax_is_initialized() const noexcept { return eax_al_context_; }
 227
 228
 229     static ALsource* eax_lookup_source(
 230         ALCcontext& al_context,
 231         ALuint source_id) noexcept;
 232
 233
 234 private:
 235     static constexpr auto eax_max_speakers = 9;
 236
 237
 238     using EaxActiveFxSlots = std::array<bool, EAX_MAX_FXSLOTS>;
 239     using EaxSpeakerLevels = std::array<long, eax_max_speakers>;
 240
 241     struct Eax
 242     {
 243         using Sends = std::array<EAXSOURCEALLSENDPROPERTIES, EAX_MAX_FXSLOTS>;
 244
 245         EAX50ACTIVEFXSLOTS active_fx_slots{};
 246         EAX50SOURCEPROPERTIES source{};
 247         Sends sends{};
 248         EaxSpeakerLevels speaker_levels{};
 249     }; // Eax
 250
 251
 252     bool eax_uses_primary_id_{};
 253     bool eax_has_active_fx_slots_{};
 254     bool eax_are_active_fx_slots_dirty_{};
 255
 256     ALCcontext* eax_al_context_{};
 257
 258     EAXBUFFER_REVERBPROPERTIES eax1_{};
 259     Eax eax_{};
 260     Eax eax_d_{};
 261     EaxActiveFxSlots eax_active_fx_slots_{};
 262
 263     EaxSourceSendsDirtyFlags eax_sends_dirty_flags_{};
 264     EaxSourceSourceFilterDirtyFlags eax_source_dirty_filter_flags_{};
 265     EaxSourceSourceMiscDirtyFlags eax_source_dirty_misc_flags_{};
 266
 267
 268     [[noreturn]]
 269     static void eax_fail(
 270         const char* message);
 271
 272
 273     void eax_set_source_defaults() noexcept;
 274     void eax_set_active_fx_slots_defaults() noexcept;
 275     void eax_set_send_defaults(EAXSOURCEALLSENDPROPERTIES& eax_send) noexcept;
 276     void eax_set_sends_defaults() noexcept;
 277     void eax_set_speaker_levels_defaults() noexcept;
 278     void eax_set_defaults() noexcept;
 279
 280
 281     static float eax_calculate_dst_occlusion_mb(
 282         long src_occlusion_mb,
 283         float path_ratio,
 284         float lf_ratio) noexcept;
 285
 286     EaxAlLowPassParam eax_create_direct_filter_param() const noexcept;
 287
 288     EaxAlLowPassParam eax_create_room_filter_param(
 289         const ALeffectslot& fx_slot,
 290         const EAXSOURCEALLSENDPROPERTIES& send) const noexcept;
 291
 292     void eax_set_fx_slots();
 293
 294     void eax_initialize_fx_slots();
 295
 296     void eax_update_direct_filter_internal();
 297
 298     void eax_update_room_filters_internal();
 299
 300     void eax_update_filters_internal();
 301
 302     void eax_update_primary_fx_slot_id();
 303
 304
 305     void eax_defer_active_fx_slots(
 306         const EaxEaxCall& eax_call);
 307
 308
 309     static const char* eax_get_exclusion_name() noexcept;
 310
 311     static const char* eax_get_exclusion_lf_ratio_name() noexcept;
 312
 313
 314     static const char* eax_get_occlusion_name() noexcept;
 315
 316     static const char* eax_get_occlusion_lf_ratio_name() noexcept;
 317
 318     static const char* eax_get_occlusion_direct_ratio_name() noexcept;
 319
 320     static const char* eax_get_occlusion_room_ratio_name() noexcept;
 321
 322
 323     static void eax1_validate_reverb_mix(float reverb_mix);
 324
 325     static void eax_validate_send_receiving_fx_slot_guid(
 326         const GUID& guidReceivingFXSlotID);
 327
 328     static void eax_validate_send_send(
 329         long lSend);
 330
 331     static void eax_validate_send_send_hf(
 332         long lSendHF);
 333
 334     static void eax_validate_send_occlusion(
 335         long lOcclusion);
 336
 337     static void eax_validate_send_occlusion_lf_ratio(
 338         float flOcclusionLFRatio);
 339
 340     static void eax_validate_send_occlusion_room_ratio(
 341         float flOcclusionRoomRatio);
 342
 343     static void eax_validate_send_occlusion_direct_ratio(
 344         float flOcclusionDirectRatio);
 345
 346     static void eax_validate_send_exclusion(
 347         long lExclusion);
 348
 349     static void eax_validate_send_exclusion_lf_ratio(
 350         float flExclusionLFRatio);
 351
 352     static void eax_validate_send(
 353         const EAXSOURCESENDPROPERTIES& all);
 354
 355     static void eax_validate_send_exclusion_all(
 356         const EAXSOURCEEXCLUSIONSENDPROPERTIES& all);
 357
 358     static void eax_validate_send_occlusion_all(
 359         const EAXSOURCEOCCLUSIONSENDPROPERTIES& all);
 360
 361     static void eax_validate_send_all(
 362         const EAXSOURCEALLSENDPROPERTIES& all);
 363
 364
 365     static EaxFxSlotIndexValue eax_get_send_index(
 366         const GUID& send_guid);
 367
 368
 369     void eax_defer_send_send(
 370         long lSend,
 371         EaxFxSlotIndexValue index);
 372
 373     void eax_defer_send_send_hf(
 374         long lSendHF,
 375         EaxFxSlotIndexValue index);
 376
 377     void eax_defer_send_occlusion(
 378         long lOcclusion,
 379         EaxFxSlotIndexValue index);
 380
 381     void eax_defer_send_occlusion_lf_ratio(
 382         float flOcclusionLFRatio,
 383         EaxFxSlotIndexValue index);
 384
 385     void eax_defer_send_occlusion_room_ratio(
 386         float flOcclusionRoomRatio,
 387         EaxFxSlotIndexValue index);
 388
 389     void eax_defer_send_occlusion_direct_ratio(
 390         float flOcclusionDirectRatio,
 391         EaxFxSlotIndexValue index);
 392
 393     void eax_defer_send_exclusion(
 394         long lExclusion,
 395         EaxFxSlotIndexValue index);
 396
 397     void eax_defer_send_exclusion_lf_ratio(
 398         float flExclusionLFRatio,
 399         EaxFxSlotIndexValue index);
 400
 401     void eax_defer_send(
 402         const EAXSOURCESENDPROPERTIES& all,
 403         EaxFxSlotIndexValue index);
 404
 405     void eax_defer_send_exclusion_all(
 406         const EAXSOURCEEXCLUSIONSENDPROPERTIES& all,
 407         EaxFxSlotIndexValue index);
 408
 409     void eax_defer_send_occlusion_all(
 410         const EAXSOURCEOCCLUSIONSENDPROPERTIES& all,
 411         EaxFxSlotIndexValue index);
 412
 413     void eax_defer_send_all(
 414         const EAXSOURCEALLSENDPROPERTIES& all,
 415         EaxFxSlotIndexValue index);
 416
 417
 418     void eax_defer_send(
 419         const EaxEaxCall& eax_call);
 420
 421     void eax_defer_send_exclusion_all(
 422         const EaxEaxCall& eax_call);
 423
 424     void eax_defer_send_occlusion_all(
 425         const EaxEaxCall& eax_call);
 426
 427     void eax_defer_send_all(
 428         const EaxEaxCall& eax_call);
 429
 430
 431     static void eax_validate_source_direct(
 432         long direct);
 433
 434     static void eax_validate_source_direct_hf(
 435         long direct_hf);
 436
 437     static void eax_validate_source_room(
 438         long room);
 439
 440     static void eax_validate_source_room_hf(
 441         long room_hf);
 442
 443     static void eax_validate_source_obstruction(
 444         long obstruction);
 445
 446     static void eax_validate_source_obstruction_lf_ratio(
 447         float obstruction_lf_ratio);
 448
 449     static void eax_validate_source_occlusion(
 450         long occlusion);
 451
 452     static void eax_validate_source_occlusion_lf_ratio(
 453         float occlusion_lf_ratio);
 454
 455     static void eax_validate_source_occlusion_room_ratio(
 456         float occlusion_room_ratio);
 457
 458     static void eax_validate_source_occlusion_direct_ratio(
 459         float occlusion_direct_ratio);
 460
 461     static void eax_validate_source_exclusion(
 462         long exclusion);
 463
 464     static void eax_validate_source_exclusion_lf_ratio(
 465         float exclusion_lf_ratio);
 466
 467     static void eax_validate_source_outside_volume_hf(
 468         long outside_volume_hf);
 469
 470     static void eax_validate_source_doppler_factor(
 471         float doppler_factor);
 472
 473     static void eax_validate_source_rolloff_factor(
 474         float rolloff_factor);
 475
 476     static void eax_validate_source_room_rolloff_factor(
 477         float room_rolloff_factor);
 478
 479     static void eax_validate_source_air_absorption_factor(
 480         float air_absorption_factor);
 481
 482     static void eax_validate_source_flags(
 483         unsigned long flags,
 484         int eax_version);
 485
 486     static void eax_validate_source_macro_fx_factor(
 487         float macro_fx_factor);
 488
 489     static void eax_validate_source_2d_all(
 490         const EAXSOURCE2DPROPERTIES& all,
 491         int eax_version);
 492
 493     static void eax_validate_source_obstruction_all(
 494         const EAXOBSTRUCTIONPROPERTIES& all);
 495
 496     static void eax_validate_source_exclusion_all(
 497         const EAXEXCLUSIONPROPERTIES& all);
 498
 499     static void eax_validate_source_occlusion_all(
 500         const EAXOCCLUSIONPROPERTIES& all);
 501
 502     static void eax_validate_source_all(
 503         const EAX20BUFFERPROPERTIES& all,
 504         int eax_version);
 505
 506     static void eax_validate_source_all(
 507         const EAX30SOURCEPROPERTIES& all,
 508         int eax_version);
 509
 510     static void eax_validate_source_all(
 511         const EAX50SOURCEPROPERTIES& all,
 512         int eax_version);
 513
 514     static void eax_validate_source_speaker_id(
 515         long speaker_id);
 516
 517     static void eax_validate_source_speaker_level(
 518         long speaker_level);
 519
 520     static void eax_validate_source_speaker_level_all(
 521         const EAXSPEAKERLEVELPROPERTIES& all);
 522
 523
 524     void eax_defer_source_direct(
 525         long lDirect);
 526
 527     void eax_defer_source_direct_hf(
 528         long lDirectHF);
 529
 530     void eax_defer_source_room(
 531         long lRoom);
 532
 533     void eax_defer_source_room_hf(
 534         long lRoomHF);
 535
 536     void eax_defer_source_obstruction(
 537         long lObstruction);
 538
 539     void eax_defer_source_obstruction_lf_ratio(
 540         float flObstructionLFRatio);
 541
 542     void eax_defer_source_occlusion(
 543         long lOcclusion);
 544
 545     void eax_defer_source_occlusion_lf_ratio(
 546         float flOcclusionLFRatio);
 547
 548     void eax_defer_source_occlusion_room_ratio(
 549         float flOcclusionRoomRatio);
 550
 551     void eax_defer_source_occlusion_direct_ratio(
 552         float flOcclusionDirectRatio);
 553
 554     void eax_defer_source_exclusion(
 555         long lExclusion);
 556
 557     void eax_defer_source_exclusion_lf_ratio(
 558         float flExclusionLFRatio);
 559
 560     void eax_defer_source_outside_volume_hf(
 561         long lOutsideVolumeHF);
 562
 563     void eax_defer_source_doppler_factor(
 564         float flDopplerFactor);
 565
 566     void eax_defer_source_rolloff_factor(
 567         float flRolloffFactor);
 568
 569     void eax_defer_source_room_rolloff_factor(
 570         float flRoomRolloffFactor);
 571
 572     void eax_defer_source_air_absorption_factor(
 573         float flAirAbsorptionFactor);
 574
 575     void eax_defer_source_flags(
 576         unsigned long ulFlags);
 577
 578     void eax_defer_source_macro_fx_factor(
 579         float flMacroFXFactor);
 580
 581     void eax_defer_source_2d_all(
 582         const EAXSOURCE2DPROPERTIES& all);
 583
 584     void eax_defer_source_obstruction_all(
 585         const EAXOBSTRUCTIONPROPERTIES& all);
 586
 587     void eax_defer_source_exclusion_all(
 588         const EAXEXCLUSIONPROPERTIES& all);
 589
 590     void eax_defer_source_occlusion_all(
 591         const EAXOCCLUSIONPROPERTIES& all);
 592
 593     void eax_defer_source_all(
 594         const EAX20BUFFERPROPERTIES& all);
 595
 596     void eax_defer_source_all(
 597         const EAX30SOURCEPROPERTIES& all);
 598
 599     void eax_defer_source_all(
 600         const EAX50SOURCEPROPERTIES& all);
 601
 602     void eax_defer_source_speaker_level_all(
 603         const EAXSPEAKERLEVELPROPERTIES& all);
 604
 605
 606     void eax_defer_source_direct(
 607         const EaxEaxCall& eax_call);
 608
 609     void eax_defer_source_direct_hf(
 610         const EaxEaxCall& eax_call);
 611
 612     void eax_defer_source_room(
 613         const EaxEaxCall& eax_call);
 614
 615     void eax_defer_source_room_hf(
 616         const EaxEaxCall& eax_call);
 617
 618     void eax_defer_source_obstruction(
 619         const EaxEaxCall& eax_call);
 620
 621     void eax_defer_source_obstruction_lf_ratio(
 622         const EaxEaxCall& eax_call);
 623
 624     void eax_defer_source_occlusion(
 625         const EaxEaxCall& eax_call);
 626
 627     void eax_defer_source_occlusion_lf_ratio(
 628         const EaxEaxCall& eax_call);
 629
 630     void eax_defer_source_occlusion_room_ratio(
 631         const EaxEaxCall& eax_call);
 632
 633     void eax_defer_source_occlusion_direct_ratio(
 634         const EaxEaxCall& eax_call);
 635
 636     void eax_defer_source_exclusion(
 637         const EaxEaxCall& eax_call);
 638
 639     void eax_defer_source_exclusion_lf_ratio(
 640         const EaxEaxCall& eax_call);
 641
 642     void eax_defer_source_outside_volume_hf(
 643         const EaxEaxCall& eax_call);
 644
 645     void eax_defer_source_doppler_factor(
 646         const EaxEaxCall& eax_call);
 647
 648     void eax_defer_source_rolloff_factor(
 649         const EaxEaxCall& eax_call);
 650
 651     void eax_defer_source_room_rolloff_factor(
 652         const EaxEaxCall& eax_call);
 653
 654     void eax_defer_source_air_absorption_factor(
 655         const EaxEaxCall& eax_call);
 656
 657     void eax_defer_source_flags(
 658         const EaxEaxCall& eax_call);
 659
 660     void eax_defer_source_macro_fx_factor(
 661         const EaxEaxCall& eax_call);
 662
 663     void eax_defer_source_2d_all(
 664         const EaxEaxCall& eax_call);
 665
 666     void eax_defer_source_obstruction_all(
 667         const EaxEaxCall& eax_call);
 668
 669     void eax_defer_source_exclusion_all(
 670         const EaxEaxCall& eax_call);
 671
 672     void eax_defer_source_occlusion_all(
 673         const EaxEaxCall& eax_call);
 674
 675     void eax_defer_source_all(
 676         const EaxEaxCall& eax_call);
 677
 678     void eax_defer_source_speaker_level_all(
 679         const EaxEaxCall& eax_call);
 680
 681
 682     void eax_set_outside_volume_hf();
 683
 684     void eax_set_doppler_factor();
 685
 686     void eax_set_rolloff_factor();
 687
 688     void eax_set_room_rolloff_factor();
 689
 690     void eax_set_air_absorption_factor();
 691
 692
 693     void eax_set_direct_hf_auto_flag();
 694
 695     void eax_set_room_auto_flag();
 696
 697     void eax_set_room_hf_auto_flag();
 698
 699     void eax_set_flags();
 700
 701
 702     void eax_set_macro_fx_factor();
 703
 704     void eax_set_speaker_levels();
 705
 706
 707     void eax1_set_efx();
 708     void eax1_set_reverb_mix(const EaxEaxCall& eax_call);
 709     void eax1_set(const EaxEaxCall& eax_call);
 710
 711     void eax_apply_deferred();
 712
 713     void eax_set(
 714         const EaxEaxCall& eax_call);
 715
 716
 717     static const GUID& eax_get_send_fx_slot_guid(
 718         int eax_version,
 719         EaxFxSlotIndexValue fx_slot_index);
 720
 721     static void eax_copy_send(
 722         const EAXSOURCEALLSENDPROPERTIES& src_send,
 723         EAXSOURCESENDPROPERTIES& dst_send);
 724
 725     static void eax_copy_send(
 726         const EAXSOURCEALLSENDPROPERTIES& src_send,
 727         EAXSOURCEALLSENDPROPERTIES& dst_send);
 728
 729     static void eax_copy_send(
 730         const EAXSOURCEALLSENDPROPERTIES& src_send,
 731         EAXSOURCEOCCLUSIONSENDPROPERTIES& dst_send);
 732
 733     static void eax_copy_send(
 734         const EAXSOURCEALLSENDPROPERTIES& src_send,
 735         EAXSOURCEEXCLUSIONSENDPROPERTIES& dst_send);
 736
 737     template<
 738         typename TException,
 739         typename TSrcSend
 740     >
 741     void eax_api_get_send_properties(
 742         const EaxEaxCall& eax_call) const
 743     {
 744         const auto eax_version = eax_call.get_version();
 745         const auto dst_sends = eax_call.get_values<TException, TSrcSend>();
 746         const auto send_count = dst_sends.size();
 747
 748         for (auto fx_slot_index = EaxFxSlotIndexValue{}; fx_slot_index < send_count; ++fx_slot_index)
 749         {
 750             auto& dst_send = dst_sends[fx_slot_index];
 751             const auto& src_send = eax_.sends[fx_slot_index];
 752
 753             eax_copy_send(src_send, dst_send);
 754
 755             dst_send.guidReceivingFXSlotID = eax_get_send_fx_slot_guid(eax_version, fx_slot_index);
 756         }
 757     }
 758
 759
 760     void eax1_get(const EaxEaxCall& eax_call);
 761
 762     void eax_api_get_source_all_v2(
 763         const EaxEaxCall& eax_call);
 764
 765     void eax_api_get_source_all_v3(
 766         const EaxEaxCall& eax_call);
 767
 768     void eax_api_get_source_all_v5(
 769         const EaxEaxCall& eax_call);
 770
 771     void eax_api_get_source_all(
 772         const EaxEaxCall& eax_call);
 773
 774     void eax_api_get_source_all_obstruction(
 775         const EaxEaxCall& eax_call);
 776
 777     void eax_api_get_source_all_occlusion(
 778         const EaxEaxCall& eax_call);
 779
 780     void eax_api_get_source_all_exclusion(
 781         const EaxEaxCall& eax_call);
 782
 783     void eax_api_get_source_active_fx_slot_id(
 784         const EaxEaxCall& eax_call);
 785
 786     void eax_api_get_source_all_2d(
 787         const EaxEaxCall& eax_call);
 788
 789     void eax_api_get_source_speaker_level_all(
 790         const EaxEaxCall& eax_call);
 791
 792     void eax_get(
 793         const EaxEaxCall& eax_call);
 794
 795
 796     // `alSource3i(source, AL_AUXILIARY_SEND_FILTER, ...)`
 797     void eax_set_al_source_send(ALeffectslot *slot, size_t sendidx,
 798         const EaxAlLowPassParam &filter);
 799 #endif // ALSOFT_EAX
 800 };
 801
 802 void UpdateAllSourceProps(ALCcontext *context);
 803
 804 #endif