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