aboutsummaryrefslogtreecommitdiffstats
path: root/alc/context.h
blob: 4b3e34615fff01483632d65ca0661d47dc22e2ef (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
#ifndef ALC_CONTEXT_H
#define ALC_CONTEXT_H

#include <atomic>
#include <memory>
#include <mutex>
#include <stdint.h>
#include <utility>

#include "AL/al.h"
#include "AL/alc.h"
#include "AL/alext.h"

#include "al/listener.h"
#include "almalloc.h"
#include "alnumeric.h"
#include "atomic.h"
#include "core/context.h"
#include "intrusive_ptr.h"
#include "vector.h"

#ifdef ALSOFT_EAX
#include "al/eax_eax_call.h"
#include "al/eax_fx_slot_index.h"
#include "al/eax_fx_slots.h"
#include "al/eax_utils.h"


using EaxContextSharedDirtyFlagsValue = std::uint_least8_t;

struct EaxContextSharedDirtyFlags
{
    using EaxIsBitFieldStruct = bool;

    EaxContextSharedDirtyFlagsValue primary_fx_slot_id : 1;
    EaxContextSharedDirtyFlagsValue air_absorption_hf : 1;
}; // EaxContextSharedDirtyFlags


using ContextDirtyFlagsValue = std::uint_least8_t;

struct ContextDirtyFlags
{
    using EaxIsBitFieldStruct = bool;

    ContextDirtyFlagsValue guidPrimaryFXSlotID : 1;
    ContextDirtyFlagsValue flDistanceFactor : 1;
    ContextDirtyFlagsValue flAirAbsorptionHF : 1;
    ContextDirtyFlagsValue flHFReference : 1;
    ContextDirtyFlagsValue flMacroFXFactor : 1;
}; // ContextDirtyFlags


struct EaxAlIsExtensionPresentResult
{
    ALboolean is_present;
    bool is_return;
}; // EaxAlIsExtensionPresentResult
#endif // ALSOFT_EAX

struct ALeffect;
struct ALeffectslot;
struct ALsource;

using uint = unsigned int;


struct SourceSubList {
    uint64_t FreeMask{~0_u64};
    ALsource *Sources{nullptr}; /* 64 */

    SourceSubList() noexcept = default;
    SourceSubList(const SourceSubList&) = delete;
    SourceSubList(SourceSubList&& rhs) noexcept : FreeMask{rhs.FreeMask}, Sources{rhs.Sources}
    { rhs.FreeMask = ~0_u64; rhs.Sources = nullptr; }
    ~SourceSubList();

    SourceSubList& operator=(const SourceSubList&) = delete;
    SourceSubList& operator=(SourceSubList&& rhs) noexcept
    { std::swap(FreeMask, rhs.FreeMask); std::swap(Sources, rhs.Sources); return *this; }
};

struct EffectSlotSubList {
    uint64_t FreeMask{~0_u64};
    ALeffectslot *EffectSlots{nullptr}; /* 64 */

    EffectSlotSubList() noexcept = default;
    EffectSlotSubList(const EffectSlotSubList&) = delete;
    EffectSlotSubList(EffectSlotSubList&& rhs) noexcept
      : FreeMask{rhs.FreeMask}, EffectSlots{rhs.EffectSlots}
    { rhs.FreeMask = ~0_u64; rhs.EffectSlots = nullptr; }
    ~EffectSlotSubList();

    EffectSlotSubList& operator=(const EffectSlotSubList&) = delete;
    EffectSlotSubList& operator=(EffectSlotSubList&& rhs) noexcept
    { std::swap(FreeMask, rhs.FreeMask); std::swap(EffectSlots, rhs.EffectSlots); return *this; }
};

struct ALCcontext : public al::intrusive_ref<ALCcontext>, ContextBase {
    const al::intrusive_ptr<ALCdevice> mALDevice;

    /* Wet buffers used by effect slots. */
    al::vector<WetBufferPtr> mWetBuffers;


    al::atomic_invflag mPropsDirty;
    std::atomic<bool> mDeferUpdates{false};

    std::mutex mPropLock;

    std::atomic<ALenum> mLastError{AL_NO_ERROR};

    DistanceModel mDistanceModel{DistanceModel::Default};
    bool mSourceDistanceModel{false};

    float mDopplerFactor{1.0f};
    float mDopplerVelocity{1.0f};
    float mSpeedOfSound{SpeedOfSoundMetersPerSec};

    std::mutex mEventCbLock;
    ALEVENTPROCSOFT mEventCb{};
    void *mEventParam{nullptr};

    ALlistener mListener{};

    al::vector<SourceSubList> mSourceList;
    ALuint mNumSources{0};
    std::mutex mSourceLock;

    al::vector<EffectSlotSubList> mEffectSlotList;
    ALuint mNumEffectSlots{0u};
    std::mutex mEffectSlotLock;

    /* Default effect slot */
    std::unique_ptr<ALeffectslot> mDefaultSlot;

    const char *mExtensionList{nullptr};


    ALCcontext(al::intrusive_ptr<ALCdevice> device);
    ALCcontext(const ALCcontext&) = delete;
    ALCcontext& operator=(const ALCcontext&) = delete;
    ~ALCcontext();

    void init();
    /**
     * Removes the context from its device and removes it from being current on
     * the running thread or globally. Returns true if other contexts still
     * exist on the device.
     */
    bool deinit();

    /**
     * Defers/suspends updates for the given context's listener and sources.
     * This does *NOT* stop mixing, but rather prevents certain property
     * changes from taking effect. mPropLock must be held when called.
     */
    bool deferUpdates() noexcept
    { return mDeferUpdates.exchange(true, std::memory_order_acq_rel); }

    /**
     * Resumes update processing after being deferred. mPropLock must be held
     * when called.
     */
    void processUpdates();

#ifdef __USE_MINGW_ANSI_STDIO
    [[gnu::format(gnu_printf, 3, 4)]]
#else
    [[gnu::format(printf, 3, 4)]]
#endif
    void setError(ALenum errorCode, const char *msg, ...);

    /* Process-wide current context */
    static std::atomic<ALCcontext*> sGlobalContext;

private:
    /* Thread-local current context. */
    static thread_local ALCcontext *sLocalContext;

    /* Thread-local context handling. This handles attempting to release the
     * context which may have been left current when the thread is destroyed.
     */
    class ThreadCtx {
    public:
        ~ThreadCtx();
        void set(ALCcontext *ctx) const noexcept { sLocalContext = ctx; }
    };
    static thread_local ThreadCtx sThreadContext;

public:
    /* HACK: MinGW generates bad code when accessing an extern thread_local
     * object. Add a wrapper function for it that only accesses it where it's
     * defined.
     */
#ifdef __MINGW32__
    static ALCcontext *getThreadContext() noexcept;
    static void setThreadContext(ALCcontext *context) noexcept;
#else
    static ALCcontext *getThreadContext() noexcept { return sLocalContext; }
    static void setThreadContext(ALCcontext *context) noexcept { sThreadContext.set(context); }
#endif

    /* Default effect that applies to sources that don't have an effect on send 0. */
    static ALeffect sDefaultEffect;

    DEF_NEWDEL(ALCcontext)

#ifdef ALSOFT_EAX
public:
    bool has_eax() const noexcept { return eax_is_initialized_; }

    bool eax_is_capable() const noexcept;


    void eax_uninitialize() noexcept;


    ALenum eax_eax_set(
        const GUID* property_set_id,
        ALuint property_id,
        ALuint property_source_id,
        ALvoid* property_value,
        ALuint property_value_size);

    ALenum eax_eax_get(
        const GUID* property_set_id,
        ALuint property_id,
        ALuint property_source_id,
        ALvoid* property_value,
        ALuint property_value_size);


    void eax_update_filters();

    void eax_commit_sources();
    void eax_commit_and_update_sources();


    void eax_set_last_error() noexcept;


    float eax_get_max_filter_gain() const noexcept;

    float eax_get_air_absorption_factor() const noexcept;

    EaxFxSlotIndex eax_get_previous_primary_fx_slot_index() const noexcept;

    EaxFxSlotIndex eax_get_primary_fx_slot_index() const noexcept;

    const ALeffectslot& eax_get_fx_slot(
        EaxFxSlotIndexValue fx_slot_index) const;

    ALeffectslot& eax_get_fx_slot(
        EaxFxSlotIndexValue fx_slot_index);


private:
    using SourceList = al::vector<SourceSubList>;


    struct SourceListIteratorBeginTag{};
    struct SourceListIteratorEndTag{};

    class SourceListIterator
    {
    public:
        SourceListIterator(
            SourceList& sources,
            SourceListIteratorBeginTag) noexcept;

        SourceListIterator(
            SourceList& sources,
            SourceListIteratorEndTag) noexcept;

        SourceListIterator(
            const SourceListIterator& rhs);

        SourceListIterator& operator=(
            const SourceListIterator& rhs) = delete;

        SourceListIterator& operator++();

        ALsource& operator*() noexcept;

        bool operator==(
            const SourceListIterator& rhs) const noexcept;

        bool operator!=(
            const SourceListIterator& rhs) const noexcept;


    private:
        SourceList::iterator sub_list_iterator_;
        SourceList::iterator sub_list_end_iterator_;
        std::uint64_t sub_list_item_index_;
    }; // SourceListIterator

    class SourceListEnumerator
    {
    public:
        explicit SourceListEnumerator(
            SourceList& sources) noexcept;

        SourceListEnumerator(
            const SourceListEnumerator& rhs) = delete;

        SourceListEnumerator& operator=(
            const SourceListEnumerator& rhs) = delete;

        SourceListIterator begin() noexcept;

        SourceListIterator end() noexcept;


    private:
        SourceList& sources_;
    }; // SourceListEnumerator


    struct Eax
    {
        EAX50CONTEXTPROPERTIES context{};
    }; // Eax


    bool eax_is_initialized_{};
    bool eax_is_tried_{};
    bool eax_are_legacy_fx_slots_unlocked_{};

    long eax_last_error_{};
    unsigned long eax_speaker_config_{};

    float eax_max_filter_gain_{};
    float eax_air_absorption_factor_{};
    EaxFxSlotIndex eax_previous_primary_fx_slot_index_{};
    EaxFxSlotIndex eax_primary_fx_slot_index_{};
    EaxFxSlots eax_fx_slots_{};

    EaxContextSharedDirtyFlags eax_context_shared_dirty_flags_{};

    Eax eax_{};
    Eax eax_d_{};
    EAXSESSIONPROPERTIES eax_session_{};

    ContextDirtyFlags eax_context_dirty_flags_{};

    std::string eax_extension_list_{};


    [[noreturn]]
    static void eax_fail(
        const char* message);


    void eax_initialize_extensions();

    void eax_initialize();


    bool eax_has_no_default_effect_slot() const noexcept;

    void eax_ensure_no_default_effect_slot() const;

    bool eax_has_enough_aux_sends() const noexcept;

    void eax_ensure_enough_aux_sends() const;

    void eax_ensure_compatibility();


    unsigned long eax_detect_speaker_configuration() const;
    void eax_update_speaker_configuration();


    void eax_initialize_filter_gain();

    void eax_set_last_error_defaults() noexcept;

    void eax_set_session_defaults() noexcept;

    void eax_set_context_defaults() noexcept;

    void eax_set_defaults() noexcept;

    void eax_initialize_sources();


    void eax_unlock_legacy_fx_slots(const EaxEaxCall& eax_call) noexcept;


    void eax_dispatch_fx_slot(
        const EaxEaxCall& eax_call);

    void eax_dispatch_source(
        const EaxEaxCall& eax_call);


    void eax_get_primary_fx_slot_id(
        const EaxEaxCall& eax_call);

    void eax_get_distance_factor(
        const EaxEaxCall& eax_call);

    void eax_get_air_absorption_hf(
        const EaxEaxCall& eax_call);

    void eax_get_hf_reference(
        const EaxEaxCall& eax_call);

    void eax_get_last_error(
        const EaxEaxCall& eax_call);

    void eax_get_speaker_config(
        const EaxEaxCall& eax_call);

    void eax_get_session(
        const EaxEaxCall& eax_call);

    void eax_get_macro_fx_factor(
        const EaxEaxCall& eax_call);

    void eax_get_context_all(
        const EaxEaxCall& eax_call);

    void eax_get(
        const EaxEaxCall& eax_call);


    void eax_set_primary_fx_slot_id();

    void eax_set_distance_factor();

    void eax_set_air_absorbtion_hf();

    void eax_set_hf_reference();

    void eax_set_macro_fx_factor();

    void eax_set_context();

    void eax_initialize_fx_slots();


    void eax_update_sources();


    void eax_validate_primary_fx_slot_id(
        const GUID& primary_fx_slot_id);

    void eax_validate_distance_factor(
        float distance_factor);

    void eax_validate_air_absorption_hf(
        float air_absorption_hf);

    void eax_validate_hf_reference(
        float hf_reference);

    void eax_validate_speaker_config(
        unsigned long speaker_config);

    void eax_validate_session_eax_version(
        unsigned long eax_version);

    void eax_validate_session_max_active_sends(
        unsigned long max_active_sends);

    void eax_validate_session(
        const EAXSESSIONPROPERTIES& eax_session);

    void eax_validate_macro_fx_factor(
        float macro_fx_factor);

    void eax_validate_context_all(
        const EAX40CONTEXTPROPERTIES& context_all);

    void eax_validate_context_all(
        const EAX50CONTEXTPROPERTIES& context_all);


    void eax_defer_primary_fx_slot_id(
        const GUID& primary_fx_slot_id);

    void eax_defer_distance_factor(
        float distance_factor);

    void eax_defer_air_absorption_hf(
        float air_absorption_hf);

    void eax_defer_hf_reference(
        float hf_reference);

    void eax_defer_macro_fx_factor(
        float macro_fx_factor);

    void eax_defer_context_all(
        const EAX40CONTEXTPROPERTIES& context_all);

    void eax_defer_context_all(
        const EAX50CONTEXTPROPERTIES& context_all);


    void eax_defer_context_all(
        const EaxEaxCall& eax_call);

    void eax_defer_primary_fx_slot_id(
        const EaxEaxCall& eax_call);

    void eax_defer_distance_factor(
        const EaxEaxCall& eax_call);

    void eax_defer_air_absorption_hf(
        const EaxEaxCall& eax_call);

    void eax_defer_hf_reference(
        const EaxEaxCall& eax_call);

    void eax_set_session(
        const EaxEaxCall& eax_call);

    void eax_defer_macro_fx_factor(
        const EaxEaxCall& eax_call);

    void eax_set(
        const EaxEaxCall& eax_call);

    void eax_apply_deferred();
#endif // ALSOFT_EAX
};

#define SETERR_RETURN(ctx, err, retval, ...) do {                             \
    (ctx)->setError((err), __VA_ARGS__);                                      \
    return retval;                                                            \
} while(0)


using ContextRef = al::intrusive_ptr<ALCcontext>;

ContextRef GetContextRef(void);

void UpdateContextProps(ALCcontext *context);


extern bool TrapALError;


#ifdef ALSOFT_EAX
ALenum AL_APIENTRY EAXSet(
    const GUID* property_set_id,
    ALuint property_id,
    ALuint property_source_id,
    ALvoid* property_value,
    ALuint property_value_size) noexcept;

ALenum AL_APIENTRY EAXGet(
    const GUID* property_set_id,
    ALuint property_id,
    ALuint property_source_id,
    ALvoid* property_value,
    ALuint property_value_size) noexcept;
#endif // ALSOFT_EAX

#endif /* ALC_CONTEXT_H */