antkeeper
/
superbuild


								#ifndef CORE_CONTEXT_H

								#define CORE_CONTEXT_H


								#include <array>

								#include <atomic>

								#include <cstddef>

								#include <memory>

								#include <thread>


								#include "almalloc.h"

								#include "alspan.h"

								#include "atomic.h"

								#include "bufferline.h"

								#include "threads.h"

								#include "vecmat.h"

								#include "vector.h"


								struct DeviceBase;

								struct EffectSlot;

								struct EffectSlotProps;

								struct RingBuffer;

								struct Voice;

								struct VoiceChange;

								struct VoicePropsItem;


								using uint = unsigned int;


								constexpr float SpeedOfSoundMetersPerSec{343.3f};


								constexpr float AirAbsorbGainHF{0.99426f}; /* -0.05dB */


								enum class DistanceModel : unsigned char {

								    Disable,

								    Inverse, InverseClamped,

								    Linear, LinearClamped,

								    Exponent, ExponentClamped,


								    Default = InverseClamped

								};


								struct WetBuffer {

								    bool mInUse;

								    al::FlexArray<FloatBufferLine, 16> mBuffer;


								    WetBuffer(size_t count) : mBuffer{count} { }


								    DEF_FAM_NEWDEL(WetBuffer, mBuffer)

								};

								using WetBufferPtr = std::unique_ptr<WetBuffer>;


								struct ContextProps {

								    std::array<float,3> Position;

								    std::array<float,3> Velocity;

								    std::array<float,3> OrientAt;

								    std::array<float,3> OrientUp;

								    float Gain;

								    float MetersPerUnit;

								    float AirAbsorptionGainHF;


								    float DopplerFactor;

								    float DopplerVelocity;

								    float SpeedOfSound;

								    bool SourceDistanceModel;

								    DistanceModel mDistanceModel;


								    std::atomic<ContextProps*> next;


								    DEF_NEWDEL(ContextProps)

								};


								struct ContextParams {

								    /* Pointer to the most recent property values that are awaiting an update. */

								    std::atomic<ContextProps*> ContextUpdate{nullptr};


								    alu::Vector Position{};

								    alu::Matrix Matrix{alu::Matrix::Identity()};

								    alu::Vector Velocity{};


								    float Gain{1.0f};

								    float MetersPerUnit{1.0f};

								    float AirAbsorptionGainHF{AirAbsorbGainHF};


								    float DopplerFactor{1.0f};

								    float SpeedOfSound{SpeedOfSoundMetersPerSec}; /* in units per sec! */


								    bool SourceDistanceModel{false};

								    DistanceModel mDistanceModel{};

								};


								struct ContextBase {

								    DeviceBase *const mDevice;


								    /* Counter for the pre-mixing updates, in 31.1 fixed point (lowest bit

								     * indicates if updates are currently happening).

								     */

								    RefCount mUpdateCount{0u};

								    std::atomic<bool> mHoldUpdates{false};

								    std::atomic<bool> mStopVoicesOnDisconnect{true};


								    float mGainBoost{1.0f};


								    /* Linked lists of unused property containers, free to use for future

								     * updates.

								     */

								    std::atomic<ContextProps*> mFreeContextProps{nullptr};

								    std::atomic<VoicePropsItem*> mFreeVoiceProps{nullptr};

								    std::atomic<EffectSlotProps*> mFreeEffectslotProps{nullptr};


								    /* The voice change tail is the beginning of the "free" elements, up to and

								     * *excluding* the current. If tail==current, there's no free elements and

								     * new ones need to be allocated. The current voice change is the element

								     * last processed, and any after are pending.

								     */

								    VoiceChange *mVoiceChangeTail{};

								    std::atomic<VoiceChange*> mCurrentVoiceChange{};


								    void allocVoiceChanges();

								    void allocVoiceProps();


								    ContextParams mParams;


								    using VoiceArray = al::FlexArray<Voice*>;

								    std::atomic<VoiceArray*> mVoices{};

								    std::atomic<size_t> mActiveVoiceCount{};


								    void allocVoices(size_t addcount);

								    al::span<Voice*> getVoicesSpan() const noexcept

								    {

								        return {mVoices.load(std::memory_order_relaxed)->data(),

								            mActiveVoiceCount.load(std::memory_order_relaxed)};

								    }

								    al::span<Voice*> getVoicesSpanAcquired() const noexcept

								    {

								        return {mVoices.load(std::memory_order_acquire)->data(),

								            mActiveVoiceCount.load(std::memory_order_acquire)};

								    }


								    using EffectSlotArray = al::FlexArray<EffectSlot*>;

								    std::atomic<EffectSlotArray*> mActiveAuxSlots{nullptr};


								    std::thread mEventThread;

								    al::semaphore mEventSem;

								    std::unique_ptr<RingBuffer> mAsyncEvents;

								    std::atomic<uint> mEnabledEvts{0u};


								    /* Asynchronous voice change actions are processed as a linked list of

								     * VoiceChange objects by the mixer, which is atomically appended to.

								     * However, to avoid allocating each object individually, they're allocated

								     * in clusters that are stored in a vector for easy automatic cleanup.

								     */

								    using VoiceChangeCluster = std::unique_ptr<VoiceChange[]>;

								    al::vector<VoiceChangeCluster> mVoiceChangeClusters;


								    using VoiceCluster = std::unique_ptr<Voice[]>;

								    al::vector<VoiceCluster> mVoiceClusters;


								    using VoicePropsCluster = std::unique_ptr<VoicePropsItem[]>;

								    al::vector<VoicePropsCluster> mVoicePropClusters;


								    ContextBase(DeviceBase *device);

								    ContextBase(const ContextBase&) = delete;

								    ContextBase& operator=(const ContextBase&) = delete;

								    ~ContextBase();

								};


								#endif /* CORE_CONTEXT_H */