vae::core::Engine Class Reference

Central class handling all outside communication. More...

#include <vae_engine.hpp>

Collaboration diagram for vae::core::Engine:

Public Member Functions
	Engine ()=default
	Engine (const Engine &)=delete
	Don't allow any kind of move of copy of the object. More...
	Engine (const Engine *)=delete
	Engine (Engine &&)=delete
Engine &	operator= (const Engine &)=delete
Engine &	operator= (Engine &&)=delete
	~Engine ()
Result	setMixerVolume (BankHandle bank, MixerHandle mixer, Sample volume)
	Set the Mixer Volume. More...
Result	muteMixerEffect (BankHandle bank, MixerHandle mixer, Size index, bool mute)
	Bypass a effect in a mixer. More...
Result	setMixerEffectParameter (BankHandle bank, MixerHandle mixer, Size index, Size param, Sample value)
	Set the Mixer Effect Parameter. More...
ListenerHandle _VAE_PUBLIC_API	createListener ()
	Create a Listener object. More...
Result _VAE_PUBLIC_API	removeListener (ListenerHandle listener)
	Unregister listener. More...
Result _VAE_PUBLIC_API	setListener (ListenerHandle listener, const LocationOrientation &locOr)
	Set the position of a listener. More...
Result _VAE_PUBLIC_API	loadHRTF (const char *path, Size size=0)
Engine Controls
Main engine functionality
Result _VAE_PUBLIC_API	init (const EngineConfig &config={})
	Initializes the engine and does most of the upfront allocations. More...
Result _VAE_PUBLIC_API	start ()
	Tries to open default device and start audio thread. More...
Result _VAE_PUBLIC_API	stop ()
	Stops processing and waits for audio thead to clean up. More...
void _VAE_PUBLIC_API	update ()
	Update function needs to be called regularly to handle outbound events and other housekeeping. More...
template<typename T >
void	process (const SampleIndex frames, T *output, int channels)
Result _VAE_PUBLIC_API	fireEvent (BankHandle bankHandle, EventHandle eventHandle, EmitterHandle emitterHandle, Sample gain=1.0, MixerHandle mixerHandle=InvalidMixerHandle, ListenerHandle listenerHandle=AllListeners)
	Main mechanism to start and stop sounds. More...
Result _VAE_PUBLIC_API	fireGlobalEvent (GlobalEventHandle globalHandle, EmitterHandle emitterHandle, Sample gain=1.0, MixerHandle mixerHandle=InvalidMixerHandle, ListenerHandle listenerHandle=AllListeners)
	Works like fireEvent but with a global Event identifier. More...
Size _VAE_PUBLIC_API	getActiveVoiceCount () const
	Get the number of currently playing Voices. More...
Size _VAE_PUBLIC_API	getStreamTime () const
void _VAE_PUBLIC_API	setMasterVolume (Sample volume)
	Set the global output volume before the limiter. More...
bool _VAE_PUBLIC_API	checkVersion (int major, int minor, int patch)
	Check if the compiled version matches. More...
Emitter manipulation
Contains everything related to emitter creation and basic manipulation of voices started from them
EmitterHandle _VAE_PUBLIC_API	createEmitter ()
	Creates an emitter and returns the handle. More...
EmitterHandle _VAE_PUBLIC_API	createAutoEmitter (BankHandle bank, EventHandle event, float maxDist, const LocationDirection &locDir, float spread)
	Emitter which triggers an event once a listener is close enough. More...
Result _VAE_PUBLIC_API	addEmitter (EmitterHandle h)
	Adds an emitter with a custom handle, can be an internal ID for example. More...
Result _VAE_PUBLIC_API	removeEmitter (EmitterHandle h)
	Unregister a emiter an kill all its voices. More...
Result _VAE_PUBLIC_API	setEmitter (EmitterHandle emitter, const LocationDirection &locDir, float spread)
	Set the Emitter position, orientation and spread. More...
Result _VAE_PUBLIC_API	stopEmitter (EmitterHandle emitter)
	Stop all voices from emitter. More...
void _VAE_PUBLIC_API	setVolume (EmitterHandle emitter, Sample gain)
	Sets the volume of all active voices with this emitter. More...
void _VAE_PUBLIC_API	seek (EmitterHandle emitter, Size time)
	Set the current time of all voices with the emitter. More...
void _VAE_PUBLIC_API	setSpeed (EmitterHandle emitter, float speed)
	Set the playback speed. More...
void _VAE_PUBLIC_API	setLowpass (EmitterHandle emitter, float cutoff)
	Simple lowpass filter for the voices. More...
void _VAE_PUBLIC_API	setHighpass (EmitterHandle emitter, float cutoff)
	Simple highpass filter for the voices. More...
Ressource Management
Everything related to Bank and other ressource loading/unloading
Result _VAE_PUBLIC_API	loadBank (const char *path, Size size=0)
	Load bank from filesystem. More...
Result	loadBank (Bank &bank)
	Load bank from memory. More...
Result	addSource (BankHandle bankHandle, Source &source)
	Add or replace a source in a bank. More...
Result	addEvent (BankHandle bankHandle, Event &event)
	Add or replace event in a bank Locks audio thread. More...
Result	addMixer (BankHandle bankHandle, Mixer &mixer)
Result	addBank (Bank &bank)
Result _VAE_PUBLIC_API	unloadBankFromId (BankHandle bankHandle)
	Unload bank from handle. More...
void _VAE_PUBLIC_API	unloadAllBanks ()
	Unload every bank and data associated with it. More...

Private Types
using	Thread = std::thread
using	ConditionVariable = std::condition_variable

Private Member Functions
void	process ()
	Main processing function. More...
void	onBufferSwap (Device *device)
	Called from audio device when it needs more audio. More...
void	threadedProcess ()
	Called from own audio thread, not the device. More...
void	onThreadedBufferSwap (Device *device)
	Called from audio device when using seperate audio thread. More...

Private Attributes
EngineConfig	mConfig
	Config object provided at initlalization. More...
VoiceManger	mVoiceManager
	Holds and handle voices. More...
SpatialManager	mSpatialManager
	Holds and manages spatial emitters. More...
BankManager	mBankManager
	Holds and manages banks. More...
Processor	mProcessor
	Default Voice processor. More...
MixerProcessor	mMixerProcessor
	Mixer channel processor. More...
SpatialProcessor	mSpatialProcessor
	Spatial voice processor. More...
ScratchBuffer	mScratchBuffer
	used to combine the signal from all banks and push it to the device More...
SampleIndex	mTime = 0
	Global engine time in samples. More...
Time	mTimeFract = 0
	Global engine time in seconds. More...
Sample	mLimiterLastPeak = 1.0
	Master limiter last peak. More...
Sample	mMasterVolume = 1.0
	Master Colume applied after limiting. More...
Device *	mDevice = nullptr
	Output device. More...
Thread *	mAudioThread
	Thread processing voices and mixers. More...
ConditionVariable	mAudioConsumed
	Notifies the audio thread when more audio is needed. More...
std::mutex	mMutex
	Mutex needed to use mAudioConsumed, doesn't actually do anything else. More...
bool	mAudioThreadRunning = false

Detailed Description

Central class handling all outside communication.

Can be sealed off by using EnginePimpl instead

Definition at line 48 of file vae_engine.hpp.

Member Typedef Documentation

ConditionVariable

using vae::core::Engine::ConditionVariable = std::condition_variable

private

Definition at line 71 of file vae_engine.hpp.

Thread

using vae::core::Engine::Thread = std::thread

private

Definition at line 70 of file vae_engine.hpp.

Constructor & Destructor Documentation

Engine() [1/4]

vae::core::Engine::Engine ( )

default

Engine() [2/4]

vae::core::Engine::Engine ( const Engine &  )

delete

Don't allow any kind of move of copy of the object.

Engine() [3/4]

vae::core::Engine::Engine ( const Engine *  )

delete

Engine() [4/4]

vae::core::Engine::Engine ( Engine &&  )

delete

~Engine()

vae::core::Engine::~Engine ( )

inline

Definition at line 209 of file vae_engine.hpp.

                  {
            VAE_PROFILER_SCOPE_NAMED("Destroy Engine")
            stop();
            unloadAllBanks();
            VAE_INFO("Engine destructed")
        }

Here is the call graph for this function:

Member Function Documentation

addBank()

Result vae::core::Engine::addBank ( Bank &  bank )

inline

Definition at line 825 of file vae_engine.hpp.

                                   {
            return mBankManager.addBank(bank);
        }

Here is the call graph for this function:

addEmitter()

Result _VAE_PUBLIC_API vae::core::Engine::addEmitter ( EmitterHandle  h )

inline

Adds an emitter with a custom handle, can be an internal ID for example.

migt be desireable to make EmitterHandle the same size as a pointer so this can simply be the pointer of the entity that is associated with it.

Parameters

h

Returns

Result

Definition at line 598 of file vae_engine.hpp.

                                                           {
            return mSpatialManager.addEmitter(h);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

addEvent()

Result vae::core::Engine::addEvent ( BankHandle  bankHandle, Event &  event  )

inline

Add or replace event in a bank Locks audio thread.

Parameters

bankHandle
event	Moved and now owned by bank

Returns

Result

Definition at line 817 of file vae_engine.hpp.

                                                             {
            return mBankManager.addEvent(bankHandle, event);
        }

Here is the call graph for this function:

addMixer()

Result vae::core::Engine::addMixer ( BankHandle  bankHandle, Mixer &  mixer  )

inline

Definition at line 821 of file vae_engine.hpp.

                                                             {
            return mBankManager.addMixer(bankHandle, mixer);
        }

Here is the call graph for this function:

addSource()

Result vae::core::Engine::addSource ( BankHandle  bankHandle, Source &  source  )

inline

Add or replace a source in a bank.

Parameters

bankHandle
source	Moved and now owned by bank

Returns

Result

Definition at line 806 of file vae_engine.hpp.

                                                                {
            return mBankManager.addSource(bankHandle, source, mConfig.internalSampleRate);
        }

Here is the call graph for this function:

checkVersion()

bool _VAE_PUBLIC_API vae::core::Engine::checkVersion ( int  major, int  minor, int  patch  )

inline

Check if the compiled version matches.

Definition at line 550 of file vae_engine.hpp.

                                                                           {
            return
                VAE_VERSION_MAJOR == major &&
                VAE_VERSION_MINOR == minor &&
                VAE_VERSION_PATCH == patch;
        }

Here is the caller graph for this function:

createAutoEmitter()

EmitterHandle _VAE_PUBLIC_API vae::core::Engine::createAutoEmitter ( BankHandle  bank, EventHandle  event, float  maxDist, const LocationDirection &  locDir, float  spread  )

inline

Emitter which triggers an event once a listener is close enough.

Parameters

bank
event
maxDist
locDir
spread

Returns

EmitterHandle Handle like a normal emitter

Definition at line 584 of file vae_engine.hpp.

          {
            return mSpatialManager.createAutoEmitter(bank, event, maxDist, locDir, spread);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

createEmitter()

EmitterHandle _VAE_PUBLIC_API vae::core::Engine::createEmitter ( )

inline

Creates an emitter and returns the handle.

Returns

EmitterHandle Random handle

Definition at line 570 of file vae_engine.hpp.

                                                      {
            return mSpatialManager.createEmitter();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

createListener()

ListenerHandle _VAE_PUBLIC_API vae::core::Engine::createListener ( )

inline

Create a Listener object.

TODO make listener 0 implicit

Returns

ListenerHandle

Definition at line 742 of file vae_engine.hpp.

                                                        {
            return mSpatialManager.createListener();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

fireEvent()

Result _VAE_PUBLIC_API vae::core::Engine::fireEvent ( BankHandle  bankHandle, EventHandle  eventHandle, EmitterHandle  emitterHandle, Sample  gain = 1.0, MixerHandle  mixerHandle = InvalidMixerHandle, ListenerHandle  listenerHandle = AllListeners  )

inline

Main mechanism to start and stop sounds.

See also

Event

Parameters

bankHandle	bank id where the event is provided
eventHandle	id of the event
emitterHandle	handle of the emitter, needed for spatial audio or controlling the voice
gain	optional volume factor
mixerHandle	optional id of mixer channel sound will be routed to, this will override the one set in the event
listenerHandle	For which listener this event will be adible for, default to all

Returns

Result

Definition at line 389 of file vae_engine.hpp.

          {
            VAE_PROFILER_SCOPE()
            if (emitterHandle != InvalidEmitterHandle && !mSpatialManager.hasEmitter(emitterHandle)) {
                VAE_ERROR("No emitter %u registered", emitterHandle)
                return Result::InvalidEmitter;
            }
 
            if (!mBankManager.has(bankHandle)) {
                VAE_ERROR("Fired event %i on unloaded bank %i", eventHandle, bankHandle)
                return Result::InvalidBank;
            }
 
            auto& bank = mBankManager.get(bankHandle);
 
            if (bank.events.size() <= eventHandle) {
                VAE_WARN("Fired missing event %i on bank %i", eventHandle, bankHandle)
                return Result::ValidHandleRequired;
            }
 
            auto& event = bank.events[eventHandle];
 
            Result result;
 
            if (event.action == Event::Action::start) {
                if (event.source != InvalidSourceHandle) {
                    VAE_DEBUG_EVENT("Event %i:%i starts source %i", eventHandle, bankHandle, event.source)
                    // Has source attached
                    if (event.spatial) {
                        // Spatialized sounds will play for every listener
                        result = mSpatialManager.forListeners(listenerHandle, [&](Listener& l) {
                            return mVoiceManager.play(
                                event, bankHandle, gain, emitterHandle, l.id, mixerHandle
                            );
                        });
                    } else {
                        // non spatialized sounds just once
                        result = mVoiceManager.play(
                            event, bankHandle, gain, emitterHandle, listenerHandle, mixerHandle
                        );
                    }
                }
 
                // Fire all other chained events
                for (auto& i : event.chained_events) {
                    if (i == InvalidEventHandle) { continue; }
                    VAE_DEBUG_EVENT("Event %i:%i starts chained event %i", eventHandle, bankHandle, i)
                    result = fireEvent(
                        bankHandle, i, emitterHandle, gain,
                        mixerHandle, listenerHandle
                    );
                }
 
                if (result != Result::Success) {
                    VAE_DEBUG_EVENT("Event %i:%i failed to start voices", eventHandle, bankHandle)
                    return result; // ! someting went wrong
                }
            }
 
            else if (event.action == Event::Action::random) {
                for (int index = rand() % StaticConfig::MaxChainedEvents; 0 <= index; index--) {
                    auto& i = event.chained_events[index];
                    if (i == InvalidEventHandle) { continue; }
                    VAE_DEBUG_EVENT("Event %i:%i starts random event %i", eventHandle, bankHandle, i)
                    result = fireEvent(
                        bankHandle, i, emitterHandle, gain,
                        mixerHandle, listenerHandle
                    );
                    break;
                }
            }
 
            else if (event.action == Event::Action::stop) {
                // TODO test stopping
                if (event.source != InvalidSourceHandle) {
                    VAE_DEBUG_EVENT("Event %i:%i stops source %i", eventHandle, bankHandle, event.source)
                    mVoiceManager.stop(event.source, &Voice::source, emitterHandle);
                }
                for (auto& i : event.chained_events) {
                    if (i == InvalidEventHandle) { continue; }
                    // kill every voice started from these events
                    VAE_DEBUG_EVENT("Event %i:%i stops voices from event %i", eventHandle, bankHandle, i)
                    mVoiceManager.stop(i, &Voice::event, emitterHandle);
                }
                if (event.mixer != Mixer::MasterMixerHandle) {
                    // kill every voice in a mixer channel
                    VAE_DEBUG_EVENT("Event %i:%i stops voices in mixer %i", eventHandle, bankHandle, event.mixer)
                    mVoiceManager.stop(event.mixer, &Voice::mixer, emitterHandle);
                }
            }
 
            else if (event.action == Event::Action::emit) {
                VAE_DEBUG_EVENT("Event %i:%i emits event", eventHandle, bankHandle)
                if (mConfig.eventCallback != nullptr) {
                    EventCallbackData data;
                    constexpr int as = sizeof(data);
                    data.context = mConfig.eventCallbackContext;
                    data.bank = bankHandle;
                    data.event = eventHandle;
                    data.emitter = emitterHandle;
                    mConfig.eventCallback(&data);
                }
            }
 
            return Result::Success;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

fireGlobalEvent()

Result _VAE_PUBLIC_API vae::core::Engine::fireGlobalEvent ( GlobalEventHandle  globalHandle, EmitterHandle  emitterHandle, Sample  gain = 1.0, MixerHandle  mixerHandle = InvalidMixerHandle, ListenerHandle  listenerHandle = AllListeners  )

inline

Works like fireEvent but with a global Event identifier.

See also

fireEvent

Parameters

globalHandle	The GlobalEventHandle combines both bank and event id
emitterHandle	optional handle of the emitter, needed for spatial audio
gain	optional volume factor
mixerHandle	id of mixer channel sound will be routed to, this will override the one set in the event

Returns

Result

Definition at line 510 of file vae_engine.hpp.

          {
            BankHandle bankHandle;
            EventHandle eventHandle;
            splitGlobalEventHandle(globalHandle, bankHandle, eventHandle);
            return fireEvent(
                bankHandle, eventHandle, emitterHandle,
                gain, mixerHandle, listenerHandle
            );
        }

Here is the call graph for this function:

Here is the caller graph for this function:

getActiveVoiceCount()

Size _VAE_PUBLIC_API vae::core::Engine::getActiveVoiceCount ( ) const

inline

Get the number of currently playing Voices.

Definition at line 529 of file vae_engine.hpp.

                                                         {
            return mVoiceManager.getActiveVoiceCount();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

getStreamTime()

Size _VAE_PUBLIC_API vae::core::Engine::getStreamTime ( ) const

inline

Definition at line 533 of file vae_engine.hpp.

                                                    {
            return mTime;
        }

init()

Result _VAE_PUBLIC_API vae::core::Engine::init ( const EngineConfig &  config = {} )

inline

Initializes the engine and does most of the upfront allocations.

Run this before start !

Everything will be allocated according to the provided config. Loading a Bank will still cause an allocation. If there are already banks loaded, they will be reloaded to have the correct samplerate.

See also

start

Parameters

config

Optional config to setup the internals.

Returns

Result

Definition at line 230 of file vae_engine.hpp.

                                                                 {}) {
            VAE_PROFILER_SCOPE_NAMED("Engine init")
            VAE_DEBUG("Initializing engine...")
            mConfig = config;
            mScratchBuffer.resize(StaticConfig::MaxBlock, StaticConfig::MaxChannels);
            mScratchBuffer.set(0);
            mScratchBuffer.sampleRate = mConfig.internalSampleRate;
            mVoiceManager.init(mConfig);
            mSpatialManager.init(mConfig.preAllocatedEmitters);
            mSpatialProcessor.init(mConfig.voices);
            mMixerProcessor.init();
            mBankManager.init(mConfig.rootPath, mConfig.internalSampleRate);
            VAE_DEBUG("Engine initialized")
            return Result::Success;
        }

Here is the caller graph for this function:

loadBank() [1/2]

Result vae::core::Engine::loadBank ( Bank &  bank )

inline

Load bank from memory.

See also

loadBank

Parameters

bank	Moved and now owned by the engine

Returns

Result

Definition at line 796 of file vae_engine.hpp.

                                    {
            return mBankManager.load(bank, mConfig.internalSampleRate);
        }

Here is the call graph for this function:

loadBank() [2/2]

Result _VAE_PUBLIC_API vae::core::Engine::loadBank ( const char *  path, Size  size = 0  )

inline

Load bank from filesystem.

This operation might take a little time but won't lock the audio thread until the bank is inserted. This should be safe to do at any time.

Parameters

path

Returns

Result

Definition at line 786 of file vae_engine.hpp.

                                                                         {
            return mBankManager.load(path, size, mConfig.rootPath, mConfig.internalSampleRate);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

loadHRTF()

Result _VAE_PUBLIC_API vae::core::Engine::loadHRTF ( const char *  path, Size  size = 0  )

inline

Definition at line 763 of file vae_engine.hpp.

                                                                         {
            return mSpatialProcessor.loadHRTF(
                path, size, mConfig.rootPath,
                mConfig.internalSampleRate
            );
        }

Here is the call graph for this function:

Here is the caller graph for this function:

muteMixerEffect()

Result vae::core::Engine::muteMixerEffect ( BankHandle  bank, MixerHandle  mixer, Size  index, bool  mute  )

inline

Bypass a effect in a mixer.

Parameters

bank
mixer
index	See setMixerEffectParameter
mute

Returns

Result

Definition at line 704 of file vae_engine.hpp.

                                                                                          {
            mBankManager.get(bank).mixers[mixer].effects[index].bypassed = mute;
            return Result::Success;
        }

Here is the call graph for this function:

onBufferSwap()

void vae::core::Engine::onBufferSwap ( Device *  device )

inlineprivate

Called from audio device when it needs more audio.

This will do synchronous processing.

Parameters

device

Definition at line 163 of file vae_engine.hpp.

                                          {
            (void) device;
            process();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

onThreadedBufferSwap()

void vae::core::Engine::onThreadedBufferSwap ( Device *  device )

inlineprivate

Called from audio device when using seperate audio thread.

This will only notify the adio thread to do work.

Parameters

device

Definition at line 189 of file vae_engine.hpp.

                                                  {
            (void) device;
            mAudioConsumed.notify_one();
        }

Here is the caller graph for this function:

operator=() [1/2]

Engine & vae::core::Engine::operator= ( const Engine &  )

delete

operator=() [2/2]

Engine & vae::core::Engine::operator= ( Engine &&  )

delete

process() [1/2]

void vae::core::Engine::process ( )

inlineprivate

Main processing function.

Called either from onBufferSwap or threadedProcess This does't need to be locked since it only renders the banks. The data accessed from this class will only be used from this thread. The bank however needs to be locks which happens in the bankmanager

Definition at line 86 of file vae_engine.hpp.

                       {
            VAE_PROFILER_FRAME_MARK_START(profiler::audioFrame)
            VAE_PROFILER_SCOPE_NAMED("Engine Process")
            auto& d = *mDevice;
            auto sampleRate = mConfig.internalSampleRate;
 
            const Time step = 1.0 / Time(sampleRate);
 
            // process until device can't take any more audio
            while (true) {
                // ! this is an underestimate when resampling so we don't have any leftovers
                auto remaining = d.canPush();
 
                static_assert(32 <= StaticConfig::MaxBlock, "MaxBlock needs to be larger");
 
                if (remaining < 32) {
                    break; // ! Don't even bother with small blocks, we'll get em next time
                }
 
                // clamp to max processable size, the preallocated scratch buffers can't take any larger blocks
                remaining = std::min(remaining, StaticConfig::MaxBlock);
 
                mScratchBuffer.setValidSize(remaining);
 
                Size renderedNormal = 0;
                Size renderedSpatial = 0;
                // TODO PERF VAE banks could be processed in parallel
                // however each bank needs to get a temporary own copy of the voice
                // or else this will be false sharing city
                mBankManager.forEach([&](Bank& i) {
                    renderedNormal += mProcessor.mix(mVoiceManager, i, remaining, sampleRate);
                    renderedSpatial += mSpatialProcessor.mix(
                        mVoiceManager, i, mSpatialManager, remaining, sampleRate
                    );
                    mMixerProcessor.mix(mVoiceManager, i, remaining);
                    auto& bankMaster = i.mixers[Mixer::MasterMixerHandle].buffer;
                    mScratchBuffer.add(bankMaster);
                    bankMaster.set(0);
                });
 
                VAE_PROFILER_PLOT("Rendered Normal Voices", int64_t(renderedNormal));
                VAE_PROFILER_PLOT("Rendered Spatial Voices", int64_t(renderedSpatial));
                VAE_PROFILER_PLOT("Rendered Total Voices", int64_t(renderedSpatial + renderedNormal));
 
                {
                    VAE_PROFILER_SCOPE_NAMED("Peak limiting")
                    // Shitty peak limiter
                    mLimiterLastPeak *= Sample(0.99); // return to normal slowly
                    mLimiterLastPeak = std::max(Sample(1.0), mLimiterLastPeak);
                    Sample currentPeak = 0;
                    for (Uchar c = 0; c < mScratchBuffer.channels(); c++) {
                        for (Size i = 0; i < remaining; i++) {
                            currentPeak = std::max(currentPeak, mScratchBuffer[c][i]);
                        }
                    }
                    currentPeak *= mMasterVolume; // pretend we already applied the master volume
                    mLimiterLastPeak = std::max(mLimiterLastPeak, currentPeak);
                    mLimiterLastPeak += Sample(0.05); // add a little extra so we really stay away from clipping
                }
                const Sample gain = mMasterVolume / mLimiterLastPeak; // this can be higher than 1 one but the result can't
                VAE_PROFILER_PLOT("Limited Master Volume", int64_t(gain * 1000));
                mScratchBuffer.multiply(gain); // apply the master volume and limiter
                d.push(mScratchBuffer);
                mScratchBuffer.set(0);
                mTime += remaining;
                mTimeFract += step * remaining;
            }
            VAE_PROFILER_FRAME_MARK_END(profiler::audioFrame)
            VAE_PROFILER_FRAME_MARK()
            if (mConfig.updateInAudioThread) { update(); }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

process() [2/2]

template<typename T >

void vae::core::Engine::process ( const SampleIndex  frames, T *  output, int  channels  )

inline

Definition at line 348 of file vae_engine.hpp.

                                                                        {
            SampleIndex time = 0;
            while (time < frames) {
                // clamp to max processable size, the preallocated scratch buffers can't take any larger blocks
                SampleIndex remaining = std::min(remaining, StaticConfig::MaxBlock);
 
                mScratchBuffer.setValidSize(remaining);
 
                // however each bank needs to get a temporary own copy of the voice
                // or else this will be false sharing city
                mBankManager.forEach([&](Bank& i) {
                    mProcessor.mix(mVoiceManager, i, remaining, mConfig.internalSampleRate);
                    mSpatialProcessor.mix(
                        mVoiceManager, i, mSpatialManager, remaining, mConfig.internalSampleRate
                    );
                    mMixerProcessor.mix(mVoiceManager, i, remaining);
                    auto& bankMaster = i.mixers[Mixer::MasterMixerHandle].buffer;
                    mScratchBuffer.add(bankMaster);
                    bankMaster.set(0);
                });
 
                mScratchBuffer.multiply(mMasterVolume);
                mScratchBuffer.putInterleaved(output + time * channels, remaining);
                mScratchBuffer.set(0);
                mTime += remaining;
                time += remaining;
            }
        }

Here is the call graph for this function:

removeEmitter()

Result _VAE_PUBLIC_API vae::core::Engine::removeEmitter ( EmitterHandle  h )

inline

Unregister a emiter an kill all its voices.

Parameters

h

Returns

Result

Definition at line 607 of file vae_engine.hpp.

                                                              {
            mVoiceManager.stop(h, &Voice::emitter);
            return mSpatialManager.removeEmitter(h);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

removeListener()

Result _VAE_PUBLIC_API vae::core::Engine::removeListener ( ListenerHandle  listener )

inline

Unregister listener.

Parameters

listener

Definition at line 750 of file vae_engine.hpp.

                                                                       {
            return mSpatialManager.removeListener(listener);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

seek()

void _VAE_PUBLIC_API vae::core::Engine::seek ( EmitterHandle  emitter, Size  time  )

inline

Set the current time of all voices with the emitter.

Parameters

emitter
time	Time in samples

Definition at line 648 of file vae_engine.hpp.

                                                                    {
            mVoiceManager.setVoiceProperty(emitter, &Voice::time, SampleIndex(time));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setEmitter()

Result _VAE_PUBLIC_API vae::core::Engine::setEmitter ( EmitterHandle  emitter, const LocationDirection &  locDir, float  spread  )

inline

Set the Emitter position, orientation and spread.

Parameters

emitter	The emitter
locDir	The desired location
spread	The width of the panning (if it's spatial and not HRTF)

Returns

Result

Definition at line 619 of file vae_engine.hpp.

          {
            return mSpatialManager.setEmitter(emitter, locDir, spread);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setHighpass()

void _VAE_PUBLIC_API vae::core::Engine::setHighpass ( EmitterHandle  emitter, float  cutoff  )

inline

Simple highpass filter for the voices.

Parameters

emitter
cutoff	0-1. 0 doesn't filter, 1 filter the wholespektrum

Definition at line 675 of file vae_engine.hpp.

                                                                              {
            mVoiceManager.setVoiceProperty(emitter, &VoiceFilter::highpass, cutoff);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setListener()

Result _VAE_PUBLIC_API vae::core::Engine::setListener ( ListenerHandle  listener, const LocationOrientation &  locOr  )

inline

Set the position of a listener.

Parameters

listener

Returns

Result

Definition at line 759 of file vae_engine.hpp.

                                                                                                      {
            return mSpatialManager.setListener(listener, locOr);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setLowpass()

void _VAE_PUBLIC_API vae::core::Engine::setLowpass ( EmitterHandle  emitter, float  cutoff  )

inline

Simple lowpass filter for the voices.

Parameters

emitter
cutoff	0-1. 0 doesn't filter, 1 filter the wholespektrum

Definition at line 666 of file vae_engine.hpp.

                                                                             {
            mVoiceManager.setVoiceProperty(emitter, &VoiceFilter::lowpass, cutoff);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setMasterVolume()

void _VAE_PUBLIC_API vae::core::Engine::setMasterVolume ( Sample  volume )

inline

Set the global output volume before the limiter.

The engine can't clip, but if the output is too load the signal will be squashed in the limiter.

Parameters

volume

1.0 is the default, not interpolated for now

Definition at line 543 of file vae_engine.hpp.

                                                            {
            mMasterVolume = volume;
        }

Here is the caller graph for this function:

setMixerEffectParameter()

Result vae::core::Engine::setMixerEffectParameter ( BankHandle  bank, MixerHandle  mixer, Size  index, Size  param, Sample  value  )

inline

Set the Mixer Effect Parameter.

Parameters

bank
mixer
index	which effects slot out of StaticConfig::MaxMixerEffects
param	which param by index out of StaticConfig::MaxEffectsParameter
value	value of the parameter from 0 to 1

Returns

Result

Definition at line 719 of file vae_engine.hpp.

                                                                                                                 {
            VAE_PROFILER_SCOPE_NAMED("Set Mixer Effect");
            // TODO this is garbage but needs a event queue anyways
            auto& b = mBankManager.get(bank);
            auto& m = b.mixers[mixer];
            auto& e = m.effects[index];
            auto& p = e.parameters[param];
            p.value = value;
            return Result::Success;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setMixerVolume()

Result vae::core::Engine::setMixerVolume ( BankHandle  bank, MixerHandle  mixer, Sample  volume  )

inline

Set the Mixer Volume.

Parameters

bank
mixer
volume

Returns

Result

Definition at line 690 of file vae_engine.hpp.

                                                                                 {
            mBankManager.get(bank).mixers[mixer].gain = volume;
            return Result::Success;
        }

Here is the call graph for this function:

setSpeed()

void _VAE_PUBLIC_API vae::core::Engine::setSpeed ( EmitterHandle  emitter, float  speed  )

inline

Set the playback speed.

Parameters

emitter
speed	1.0 is the default speed, pitch will be affected as well.

Definition at line 657 of file vae_engine.hpp.

                                                                          {
            mVoiceManager.setVoiceProperty(emitter, &VoiceFilter::speed, speed);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

setVolume()

void _VAE_PUBLIC_API vae::core::Engine::setVolume ( EmitterHandle  emitter, Sample  gain  )

inline

Sets the volume of all active voices with this emitter.

Parameters

emitter
gain

Definition at line 639 of file vae_engine.hpp.

                                                                           {
            mVoiceManager.setVoiceProperty(emitter, &Voice::gain, gain);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

start()

Result _VAE_PUBLIC_API vae::core::Engine::start ( )

inline

Tries to open default device and start audio thread.

Call this after start.

See also

init

Returns

Result

Definition at line 251 of file vae_engine.hpp.

                                       {
        #ifndef VAE_NO_AUDIO_DEVICE
            VEA_PROFILER_THREAD_NAME("Application Thread")
            VAE_PROFILER_SCOPE()
            {
                VAE_PROFILER_SCOPE_NAMED("Device Instance")
                Backend& backend = DefaultBackend::instance();
                mDevice = backend.createDevice(mConfig);
            }
            if (mConfig.processInBufferSwitch) {
                mDevice->setCallback(TKLB_DELEGATE(&Engine::onBufferSwap, *this));
                VAE_DEBUG("Mixing in buffer switch")
            } else {
            #ifndef VAE_NO_AUDIO_THREAD
                mDevice->setCallback(TKLB_DELEGATE(&Engine::onThreadedBufferSwap, *this));
                mAudioThreadRunning = true;
                VAE_PROFILER_SCOPE_NAMED("Start audio thread")
                mAudioThread = new Thread(&Engine::threadedProcess, this);
                VAE_DEBUG("Mixing in seperate thread")
            #else
                VAE_ERROR("Can't mix in audio thread since it's disabled via VAE_NO_AUDIO_THREAD")
            #endif // !VAE_NO_AUDIO_THREAD
            }
            {
                VAE_PROFILER_SCOPE_NAMED("Device Instance")
                return mDevice->openDevice() ? Result::Success : Result::DeviceError;
            }
        #endif // !VAE_NO_AUDIO_DEVICE
            return Result::GenericFailure;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

stop()

Result _VAE_PUBLIC_API vae::core::Engine::stop ( )

inline

Stops processing and waits for audio thead to clean up.

Returns

Result

Definition at line 286 of file vae_engine.hpp.

                                      {
        #ifndef VAE_NO_AUDIO_DEVICE
            VAE_PROFILER_SCOPE()
            #ifndef VAE_NO_AUDIO_THREAD
            if (mAudioThreadRunning) {
                mAudioThreadRunning = false;
                mAudioConsumed.notify_one(); // make sure the audio thread knows it's time to go
                if(mAudioThread->joinable()) {
                    mAudioThread->join();
                    delete mAudioThread;
                    VAE_DEBUG("Audio thread stopped")
                } else {
                    VAE_ERROR("Can't join audio thread")
                }
            }
            #endif // !VAE_NO_AUDIO_THREAD
            if (mDevice != nullptr) {
                delete mDevice;
                mDevice = nullptr;
            }
    #endif // !VAE_NO_AUDIO_DEVICE
            return Result::Success;
        }

Here is the caller graph for this function:

stopEmitter()

Result _VAE_PUBLIC_API vae::core::Engine::stopEmitter ( EmitterHandle  emitter )

inline

Stop all voices from emitter.

Parameters

emitter

Returns

Result

Definition at line 630 of file vae_engine.hpp.

                                                                  {
            return mVoiceManager.stop(emitter, &Voice::emitter);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

threadedProcess()

void vae::core::Engine::threadedProcess ( )

inlineprivate

Called from own audio thread, not the device.

Definition at line 175 of file vae_engine.hpp.

                               {
            VEA_PROFILER_THREAD_NAME("Audio thread")
            while(mAudioThreadRunning) {
                process();  // Process one block in advance so there's no underrun
                std::unique_lock<std::mutex> l(mMutex);
                mAudioConsumed.wait(l); // Wait until we got work
            }
        }

Here is the call graph for this function:

Here is the caller graph for this function:

unloadAllBanks()

void _VAE_PUBLIC_API vae::core::Engine::unloadAllBanks ( )

inline

Unload every bank and data associated with it.

Definition at line 845 of file vae_engine.hpp.

                                              {
            VAE_PROFILER_SCOPE()
            VAE_INFO("Start unloading all banks")
            mBankManager.unloadAll();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

unloadBankFromId()

Result _VAE_PUBLIC_API vae::core::Engine::unloadBankFromId ( BankHandle  bankHandle )

inline

Unload bank from handle.

Locks audio thread and stops all voices from that bank.

Parameters

bankHandle

Returns

Result

Definition at line 835 of file vae_engine.hpp.

                                                                       {
            VAE_PROFILER_SCOPE()
            VAE_INFO("Start Unload bank %i", bankHandle)
            mVoiceManager.stop(bankHandle, &Voice::bank);
            return mBankManager.unloadFromId(bankHandle);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void _VAE_PUBLIC_API vae::core::Engine::update ( )

inline

Update function needs to be called regularly to handle outbound events and other housekeeping.

If this isn't called regularly events might be lost and chained events not fired. When EngineConfig::updateInAudioThread is true, this doesn't need to be called manually.

See also

EngineConfig::updateInAudioThread

Definition at line 317 of file vae_engine.hpp.

                                      {
            VAE_PROFILER_FRAME_MARK_START(profiler::audioFrame)
            VAE_PROFILER_SCOPE_NAMED("Engine Update")
            // Update emitters and start voices nearby
            mBankManager.lock();
            mSpatialManager.update(
                mVoiceManager,
                [&](EventHandle event, BankHandle bank, EmitterHandle emitter) {
                    fireEvent(bank, event, emitter);
                }
            );
 
            // Handle finished voices and their events
            mVoiceManager.forEachFinishedVoice([&](Voice& v) {
                if (v.emitter != InvalidEmitterHandle) {
                    mSpatialManager.getEmitter(v.emitter).autoplaying = false;
                    // Make sure the event can be triggered again by that emitter
                }
                auto onEnd = mBankManager.get(v.bank).events[v.event].on_end;
                if (onEnd != InvalidEventHandle) {
                    fireEvent(v.bank, onEnd, v.emitter, 1.0, v.mixer);
                }
                return true;
            });
            mBankManager.unlock();
            VAE_PROFILER_FRAME_MARK_END(profiler::audioFrame)
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mAudioConsumed

ConditionVariable vae::core::Engine::mAudioConsumed

private

Notifies the audio thread when more audio is needed.

Definition at line 73 of file vae_engine.hpp.

mAudioThread

Thread* vae::core::Engine::mAudioThread

private

Thread processing voices and mixers.

Definition at line 72 of file vae_engine.hpp.

mAudioThreadRunning

bool vae::core::Engine::mAudioThreadRunning = false

private

Definition at line 75 of file vae_engine.hpp.

mBankManager

BankManager vae::core::Engine::mBankManager

private

Holds and manages banks.

Definition at line 53 of file vae_engine.hpp.

mConfig

EngineConfig vae::core::Engine::mConfig

private

Config object provided at initlalization.

Definition at line 49 of file vae_engine.hpp.

mDevice

Device* vae::core::Engine::mDevice = nullptr

private

Output device.

Definition at line 66 of file vae_engine.hpp.

mLimiterLastPeak

Sample vae::core::Engine::mLimiterLastPeak = 1.0

private

Master limiter last peak.

Definition at line 62 of file vae_engine.hpp.

mMasterVolume

Sample vae::core::Engine::mMasterVolume = 1.0

private

Master Colume applied after limiting.

Definition at line 63 of file vae_engine.hpp.

mMixerProcessor

MixerProcessor vae::core::Engine::mMixerProcessor

private

Mixer channel processor.

Definition at line 56 of file vae_engine.hpp.

mMutex

std::mutex vae::core::Engine::mMutex

private

Mutex needed to use mAudioConsumed, doesn't actually do anything else.

Definition at line 74 of file vae_engine.hpp.

mProcessor

Processor vae::core::Engine::mProcessor

private

Default Voice processor.

Definition at line 55 of file vae_engine.hpp.

mScratchBuffer

ScratchBuffer vae::core::Engine::mScratchBuffer

private

used to combine the signal from all banks and push it to the device

Definition at line 59 of file vae_engine.hpp.

mSpatialManager

SpatialManager vae::core::Engine::mSpatialManager

private

Holds and manages spatial emitters.

Definition at line 52 of file vae_engine.hpp.

mSpatialProcessor

SpatialProcessor vae::core::Engine::mSpatialProcessor

private

Spatial voice processor.

Definition at line 57 of file vae_engine.hpp.

mTime

SampleIndex vae::core::Engine::mTime = 0

private

Global engine time in samples.

Definition at line 60 of file vae_engine.hpp.

mTimeFract

Time vae::core::Engine::mTimeFract = 0

private

Global engine time in seconds.

Definition at line 61 of file vae_engine.hpp.

mVoiceManager

VoiceManger vae::core::Engine::mVoiceManager

private

Holds and handle voices.

Definition at line 51 of file vae_engine.hpp.

---

The documentation for this class was generated from the following file:

• vae_engine.hpp