RealtimeEffectState Class Reference

#include <RealtimeEffectState.h>

Inheritance diagram for RealtimeEffectState:

Collaboration diagram for RealtimeEffectState:

Classes
struct	Access
	Main thread's interface to inter-thread communication of changes of settings. More...
class	AccessState
	Mediator of two-way inter-thread communication of changes of settings. More...
struct	EffectFactory
struct	Response
struct	SettingsAndCounter

Public Member Functions
	RealtimeEffectState (const PluginID &id)
	RealtimeEffectState (const RealtimeEffectState &other)=delete
RealtimeEffectState &	operator= (const RealtimeEffectState &other)=delete
	~RealtimeEffectState ()
void	SetID (const PluginID &id)
	May be called with nonempty id at most once in the lifetime of a state. More...
const PluginID &	GetID () const noexcept
const EffectInstanceFactory *	GetEffect ()
	Initializes the effect on demand. More...
const EffectInstanceFactory *	GetEffect () const
	const accessor will not initialize the effect on demand More...
std::shared_ptr< EffectInstance >	GetInstance ()
	Expose a pointer to the state's instance (making one as needed). More...
const EffectOutputs *	GetOutputs () const
	Get locations that a GUI can connect meters to. More...
std::shared_ptr< EffectInstance >	Initialize (double rate)
	Main thread sets up for playback. More...
std::shared_ptr< EffectInstance >	AddTrack (const Track &track, unsigned chans, float sampleRate)
	Main thread sets up this state before adding it to lists. More...
bool	ProcessStart (bool running)
	Worker thread begins a batch of samples. More...
size_t	Process (const Track &track, unsigned chans, const float *const *inbuf, float *const *outbuf, float *dummybuf, size_t numSamples)
	Worker thread processes part of a batch of samples. More...
bool	ProcessEnd ()
	Worker thread finishes a batch of samples. More...
const EffectSettings &	GetSettings () const
bool	IsEnabled () const noexcept
	Test only in the main thread. More...
bool	IsActive () const noexcept
	Test only in the worker thread, or else when there is no processing. More...
void	SetActive (bool active)
	Set only in the main thread. More...
bool	Finalize () noexcept
	Main thread cleans up playback. More...
bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override
void	HandleXMLEndTag (const std::string_view &tag) override
XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override
void	WriteXML (XMLWriter &xmlFile)
std::shared_ptr< EffectSettingsAccess >	GetAccess ()
Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()
virtual	~XMLTagHandler ()
virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0
virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))
virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))
virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0
void	ReadXMLEndTag (const char *tag)
void	ReadXMLContent (const char *s, int len)
XMLTagHandler *	ReadXMLChild (const char *tag)
Public Member Functions inherited from ClientData::Site< RealtimeEffectState >
	~Site ()
	Site ()
	Site (const Site &other)
	Site (Site &&other)
Site &	operator= (const Site &other)
Site &	operator= (Site &&other)
size_t	size () const
	How many attachment pointers are in the Site. More...
Subclass &	Get (const RegisteredFactory &key)
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...
auto	Get (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass & >
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...
Subclass *	Find (const RegisteredFactory &key)
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...
auto	Find (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass * >
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...
void	Assign (const RegisteredFactory &key, ReplacementPointer &&replacement)
	Reassign Site's pointer to ClientData. More...
Public Member Functions inherited from Observer::Publisher< RealtimeEffectStateChange >
	Publisher (ExceptionPolicy *pPolicy=nullptr, Alloc a={})
	Constructor supporting type-erased custom allocation/deletion. More...
	Publisher (Publisher &&)=default
Publisher &	operator= (Publisher &&)=default
Subscription	Subscribe (Callback callback)
	Connect a callback to the Publisher; later-connected are called earlier. More...
Subscription	Subscribe (Object &obj, Return(Object::*callback)(Args...))
	Overload of Subscribe takes an object and pointer-to-member-function. More...

Static Public Member Functions
static const std::string &	XMLTag ()
Static Public Member Functions inherited from SharedNonInterfering< RealtimeEffectState >
static std::shared_ptr< RealtimeEffectState >	make_shared (Args &&...args)
Static Public Member Functions inherited from ClientData::Site< RealtimeEffectState >
static size_t	slots ()
	How many static factories have been registered with this specialization of Site. More...

Private Member Functions
std::shared_ptr< EffectInstance >	MakeInstance ()
std::shared_ptr< EffectInstance >	EnsureInstance (double rate)
AccessState *	GetAccessState () const
AccessState *	TestAccessState () const

Private Attributes
PluginID	mID
std::weak_ptr< EffectInstance >	mwInstance
	Stateful instance made by the plug-in. More...
const EffectInstanceFactory *	mPlugin {}
	Stateless effect object. More...
NonInterfering< SettingsAndCounter >	mMainSettings
	Updated immediately by Access::Set in the main thread. More...
std::unique_ptr< EffectInstance::Message >	mMessage
std::unique_ptr< EffectOutputs >	mMovedOutputs
Members that are changed also in the worker thread
NonInterfering< SettingsAndCounter >	mWorkerSettings
std::unique_ptr< EffectInstance::Message >	mMovedMessage
std::unique_ptr< EffectOutputs >	mOutputs
std::optional< EffectInstance::SampleCount >	mLatency
	How many samples must be discarded. More...
bool	mLastActive {}
	Assigned in the worker thread at the start of each processing scope. More...
Members that do not change during processing
std::unordered_map< const Track *, std::pair< size_t, double > >	mGroups
AtomicUniquePointer< AccessState >	mpAccessState { nullptr }
wxString	mParameters
size_t	mCurrentProcessor { 0 }
bool	mInitialized { false }

Additional Inherited Members
Public Types inherited from ClientData::Site< RealtimeEffectState >
using	DataType = Base
using	DataPointer = UniquePtr< Base >
using	DataFactory = std::function< DataPointer(RealtimeEffectState &) >
	Type of function from which RegisteredFactory is constructed; it builds attachments. More...
Public Types inherited from Observer::Publisher< RealtimeEffectStateChange >
using	message_type = RealtimeEffectStateChange
using	CallbackReturn = std::conditional_t< true, void, bool >
using	Callback = std::function< CallbackReturn(const RealtimeEffectStateChange &) >
	Type of functions that can be connected to the Publisher. More...
Static Public Attributes inherited from Observer::Publisher< RealtimeEffectStateChange >
static constexpr bool	notifies_all
Protected Member Functions inherited from ClientData::Site< RealtimeEffectState >
void	ForEach (const Function &function)
	Invoke function on each ClientData object that has been created in this. More...
void	ForEach (const Function &function) const
	Invoke function on each ClientData object that has been created in this. More...
Base *	FindIf (const Function &function)
	Return pointer to first attachment in this that is not null and satisfies a predicate, or nullptr. More...
const Base *	FindIf (const Function &function) const
	Return pointer to first attachment in this that is not null and satisfies a predicate, or nullptr. More...
void	BuildAll ()
	For each RegisteredFactory, if the corresponding attachment is absent in this, build and store it. More...
Protected Member Functions inherited from Observer::Publisher< RealtimeEffectStateChange >
CallbackReturn	Publish (const RealtimeEffectStateChange &message)
	Send a message to connected callbacks. More...

Detailed Description

Definition at line 32 of file RealtimeEffectState.h.

Constructor & Destructor Documentation

RealtimeEffectState() [1/2]

RealtimeEffectState::RealtimeEffectState ( const PluginID &  id )

explicit

Definition at line 315 of file RealtimeEffectState.cpp.

{
   SetID(id);
   BuildAll();
}

References ClientData::Site< RealtimeEffectState >::BuildAll(), and SetID().

Here is the call graph for this function:

RealtimeEffectState() [2/2]

RealtimeEffectState::RealtimeEffectState ( const RealtimeEffectState &  other )

delete

~RealtimeEffectState()

RealtimeEffectState::~RealtimeEffectState

(

)

Definition at line 321 of file RealtimeEffectState.cpp.

{
 
}

Member Function Documentation

AddTrack()

std::shared_ptr< EffectInstance > RealtimeEffectState::AddTrack	(	const Track &	track,
		unsigned	chans,
		float	sampleRate
	)

Main thread sets up this state before adding it to lists.

Set up processors to be visited repeatedly in Process.

The iteration over channels in AddTrack and Process must be the same

Definition at line 457 of file RealtimeEffectState.cpp.

{
   auto pInstance = EnsureInstance(sampleRate);
   if (!pInstance)
      return {};
   if (!mPlugin)
      return {};
   auto first = mCurrentProcessor;
   const auto numAudioIn = pInstance->GetAudioInCount();
   const auto numAudioOut = pInstance->GetAudioOutCount();
   AllocateChannelsToProcessors(chans, numAudioIn, numAudioOut,
   [&](unsigned, unsigned){
      // Add a NEW processor
      if (pInstance->RealtimeAddProcessor(
         mWorkerSettings.settings, mOutputs.get(), numAudioIn, sampleRate)
      ) {
         mCurrentProcessor++;
         return true;
      }
      else
         return false;
   });
   if (mCurrentProcessor > first) {
      // Remember the sampleRate of the track, so latency can be computed later
      mGroups[&track] = { first, sampleRate };
      return pInstance;
   }
   return {};
}

References anonymous_namespace{RealtimeEffectState.cpp}::AllocateChannelsToProcessors(), EnsureInstance(), mCurrentProcessor, mGroups, mOutputs, mPlugin, and mWorkerSettings.

Referenced by RealtimeEffectManager::AddTrack().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureInstance()

std::shared_ptr< EffectInstance > RealtimeEffectState::EnsureInstance ( double  rate )

private

copying settings in the main thread while worker isn't yet running

If there was already an instance, recycle it; else make one here

Definition at line 378 of file RealtimeEffectState.cpp.

{
   if (!mPlugin)
      return {};
 
   auto pInstance = mwInstance.lock();
   if (!mInitialized) {
      mWorkerSettings = mMainSettings;
      mLastActive = IsActive();
 
      if (!pInstance)
         mwInstance = pInstance = MakeInstance();
      if (!pInstance)
         return {};
 
      // PRL: conserving pre-3.2.0 behavior, but I don't know why this arbitrary
      // number was important
      pInstance->SetBlockSize(512);
 
      if (!pInstance->RealtimeInitialize(mMainSettings.settings, sampleRate))
         return {};
      mInitialized = true;
      return pInstance;
   }
   return pInstance;
}

References IsActive(), MakeInstance(), mInitialized, mLastActive, mMainSettings, mPlugin, mwInstance, and mWorkerSettings.

Referenced by AddTrack(), and Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

Finalize()

bool RealtimeEffectState::Finalize ( )

noexcept

Main thread cleans up playback.

Definition at line 651 of file RealtimeEffectState.cpp.

{
   mGroups.clear();
   mCurrentProcessor = 0;
 
   auto pInstance = mwInstance.lock();
   if (!pInstance)
      return false;
 
   if (!pInstance->UsesMessages()) {
      // This is the main thread cleaning up a state not now used in processing
      mMainSettings = mWorkerSettings;
   }
 
   auto result = pInstance->RealtimeFinalize(mMainSettings.settings);
   mLatency = {};
   mInitialized = false;
   return result;
}

References mCurrentProcessor, mGroups, mInitialized, mLatency, mMainSettings, mwInstance, and mWorkerSettings.

Referenced by RealtimeEffectManager::Finalize().

Here is the caller graph for this function:

GetAccess()

std::shared_ptr< EffectSettingsAccess > RealtimeEffectState::GetAccess

(

)

Expose access so a dialog can be connected to this state To be called by the main thread only

Postcondition

result: result != nullptr

Definition at line 781 of file RealtimeEffectState.cpp.

{
   if (!GetEffect())
      // Effect not found!
      // Return a dummy
      return std::make_shared<Access>();
 
   // Only the main thread assigns to the atomic pointer, here and
   // once only in the lifetime of the state
   if (!GetAccessState())
   {
      MakeInstance();
      mpAccessState.emplace(*mPlugin, *this);
   }
 
   return std::make_shared<Access>(*this);
}

References GetAccessState(), GetEffect(), MakeInstance(), mpAccessState, and mPlugin.

Referenced by SetActive(), and RealtimeEffectStateUI::Show().

Here is the call graph for this function:

Here is the caller graph for this function:

GetAccessState()

AccessState * RealtimeEffectState::GetAccessState ( ) const

inlineprivate

Definition at line 126 of file RealtimeEffectState.h.

   {
      return mpAccessState.load(std::memory_order_relaxed);
   }

Referenced by GetAccess(), and MakeInstance().

Here is the caller graph for this function:

GetEffect() [1/2]

const EffectInstanceFactory * RealtimeEffectState::GetEffect

(

)

Initializes the effect on demand.

Definition at line 343 of file RealtimeEffectState.cpp.

{
   if (!mPlugin) {
      mPlugin = EffectFactory::Call(mID);
      if (mPlugin) {
         // Also make EffectSettings, but preserve activation
         auto wasActive = mMainSettings.settings.extra.GetActive();
         mMainSettings.counter = 0;
         mMainSettings.settings = mPlugin->MakeSettings();
         mMainSettings.settings.extra.SetActive(wasActive);
         mOutputs = mPlugin->MakeOutputs();
         mMovedOutputs = mPlugin->MakeOutputs();
      }
   }
   return mPlugin;
}

References GlobalHook< EffectFactory, const EffectInstanceFactory *(const PluginID &) >::Call(), EffectSettingsManager::MakeOutputs(), EffectSettingsManager::MakeSettings(), mID, mMainSettings, mMovedOutputs, mOutputs, and mPlugin.

Referenced by GetAccess(), and SetID().

Here is the call graph for this function:

Here is the caller graph for this function:

GetEffect() [2/2]

const EffectInstanceFactory * RealtimeEffectState::GetEffect ( ) const

inline

const accessor will not initialize the effect on demand

Definition at line 58 of file RealtimeEffectState.h.

{ return mPlugin; }

GetID()

const PluginID & RealtimeEffectState::GetID ( ) const

noexcept

Definition at line 338 of file RealtimeEffectState.cpp.

{
   return mID;
}

References mID.

Referenced by RealtimeEffectStateUI::Show(), and RealtimeEffectStateUI::UpdateTitle().

Here is the caller graph for this function:

GetInstance()

std::shared_ptr< EffectInstance > RealtimeEffectState::GetInstance

(

)

Expose a pointer to the state's instance (making one as needed).

Postcondition

true (no promise result is not null)

If there was already an instance, recycle it; else make one here

Definition at line 407 of file RealtimeEffectState.cpp.

{
   auto pInstance = mwInstance.lock();
   if (!pInstance && mPlugin)
      mwInstance = pInstance = MakeInstance();
   return pInstance;
}

References MakeInstance(), mPlugin, and mwInstance.

Here is the call graph for this function:

GetOutputs()

const EffectOutputs * RealtimeEffectState::GetOutputs ( ) const

inline

Get locations that a GUI can connect meters to.

Definition at line 67 of file RealtimeEffectState.h.

{ return mMovedOutputs.get(); }

GetSettings()

const EffectSettings & RealtimeEffectState::GetSettings ( ) const

inline

Definition at line 90 of file RealtimeEffectState.h.

{ return mMainSettings.settings; }

HandleXMLChild()

XMLTagHandler * RealtimeEffectState::HandleXMLChild ( const std::string_view &  tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 737 of file RealtimeEffectState.cpp.

{
   // Tag may be for the state, or the list of parameters, or for one parameter.
   // See the writing method below.  All are handled by this
   return this;
}

HandleXMLEndTag()

void RealtimeEffectState::HandleXMLEndTag ( const std::string_view &  tag )

override

Definition at line 726 of file RealtimeEffectState.cpp.

{
   if (tag == XMLTag()) {
      if (mPlugin && !mParameters.empty()) {
         CommandParameters parms(mParameters);
         mPlugin->LoadSettings(parms, mMainSettings.settings);
      }
      mParameters.clear();
   }
}

References EffectSettingsManager::LoadSettings(), mMainSettings, mParameters, mPlugin, and XMLTag().

Here is the call graph for this function:

HandleXMLTag()

bool RealtimeEffectState::HandleXMLTag ( const std::string_view &  tag, const AttributesList &  attrs  )

overridevirtual

Implements XMLTagHandler.

Definition at line 685 of file RealtimeEffectState.cpp.

{
   if (tag == XMLTag()) {
      mParameters.clear();
      mPlugin = nullptr;
      mID.clear();
      for (auto &[attr, value] : attrs) {
         if (attr == idAttribute) {
            SetID(value.ToWString());
            if (!mPlugin) {
               // TODO - complain!!!!
            }
         }
         else if (attr == versionAttribute) {
         }
         else if (attr == activeAttribute)
            // Updating the EffectSettingsExtra although we haven't yet built
            // the settings
            mMainSettings.settings.extra.SetActive(value.Get<bool>());
      }
      return true;
   }
   else if (tag == parametersAttribute)
      return true;
   else if (tag == parameterAttribute) {
      wxString n;
      wxString v;
      for (auto &[attr, value] : attrs) {
         if (attr == nameAttribute)
            n = value.ToWString();
         else if (attr == valueAttribute)
            v = value.ToWString();
      }
      mParameters += wxString::Format(wxT("\"%s=%s\" "), n, v);
      return true;
   }
   else
      return false;
}

References activeAttribute, idAttribute, mID, mMainSettings, mParameters, mPlugin, nameAttribute, parameterAttribute, parametersAttribute, SetID(), valueAttribute, versionAttribute, wxT(), and XMLTag().

Here is the call graph for this function:

Initialize()

std::shared_ptr< EffectInstance > RealtimeEffectState::Initialize

(

double

rate

)

Main thread sets up for playback.

Definition at line 417 of file RealtimeEffectState.cpp.

{
   if (!mPlugin)
      return {};
 
   mCurrentProcessor = 0;
   mGroups.clear();
   mLatency = {};
   return EnsureInstance(sampleRate);
}

References EnsureInstance(), mCurrentProcessor, mGroups, mLatency, and mPlugin.

Referenced by RealtimeEffectManager::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

IsActive()

bool RealtimeEffectState::IsActive ( ) const

noexcept

Test only in the worker thread, or else when there is no processing.

Definition at line 632 of file RealtimeEffectState.cpp.

{
   return mWorkerSettings.settings.extra.GetActive();
}

References mWorkerSettings.

Referenced by EnsureInstance(), ProcessEnd(), and ProcessStart().

Here is the caller graph for this function:

IsEnabled()

bool RealtimeEffectState::IsEnabled ( ) const

noexcept

Test only in the main thread.

Definition at line 627 of file RealtimeEffectState.cpp.

{
   return mMainSettings.settings.extra.GetActive();
}

References mMainSettings.

MakeInstance()

std::shared_ptr< EffectInstance > RealtimeEffectState::MakeInstance ( )

private

Definition at line 360 of file RealtimeEffectState.cpp.

{
   mMovedMessage.reset();
   mMessage.reset();
   auto result = mPlugin->MakeInstance();
   if (result) {
      // Allocate presized containers in messages, so later
      // copies of contents might avoid free store operations
      mMessage = result->MakeMessage();
      mMovedMessage = result->MakeMessage();
      if (auto state = GetAccessState())
         state->Initialize(mMainSettings.settings,
            mMessage.get(), mMovedOutputs.get());
   }
   return result;
}

References GetAccessState(), EffectInstanceFactory::MakeInstance(), mMainSettings, mMessage, mMovedMessage, mMovedOutputs, and mPlugin.

Referenced by EnsureInstance(), GetAccess(), and GetInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

RealtimeEffectState & RealtimeEffectState::operator= ( const RealtimeEffectState &  other )

delete

Process()

size_t RealtimeEffectState::Process	(	const Track &	track,
		unsigned	chans,
		const float *const *	inbuf,
		float *const *	outbuf,
		float *	dummybuf,
		size_t	numSamples
	)

Worker thread processes part of a batch of samples.

Visit the effect processors that were added in AddTrack.

Returns

how many leading samples are discardable for latency

The iteration over channels in AddTrack and Process must be the same

Parameters

inbuf	chans input buffers
outbuf	chans output buffers
dummybuf	one dummy output buffer

Definition at line 533 of file RealtimeEffectState.cpp.

{
   auto pInstance = mwInstance.lock();
   if (!mPlugin || !pInstance || !mLastActive) {
      // Process trivially
      for (size_t ii = 0; ii < chans; ++ii)
         memcpy(outbuf[ii], inbuf[ii], numSamples * sizeof(float));
      return 0;
   }
   const auto numAudioIn = pInstance->GetAudioInCount();
   const auto numAudioOut = pInstance->GetAudioOutCount();
   const auto clientIn = stackAllocate(const float *, numAudioIn);
   const auto clientOut = stackAllocate(float *, numAudioOut);
   size_t len = 0;
   const auto &pair = mGroups[&track];
   auto processor = pair.first;
   // Outer loop over processors
   AllocateChannelsToProcessors(chans, numAudioIn, numAudioOut,
   [&](unsigned indx, unsigned ondx){
      // Point at the correct input buffers
      unsigned copied = std::min(chans - indx, numAudioIn);
      std::copy(inbuf + indx, inbuf + indx + copied, clientIn);
      // If there are too few input channels for what the processor requires,
      // re-use input channels from the beginning
      while (auto need = numAudioIn - copied) {
         auto moreCopied = std::min(chans, need);
         std::copy(inbuf, inbuf + moreCopied, clientIn + copied);
         copied += moreCopied;
      }
 
      // Point at the correct output buffers
      copied = std::min(chans - ondx, numAudioOut);
      std::copy(outbuf + ondx, outbuf + ondx + copied, clientOut);
      if (copied < numAudioOut) {
         // Make determinate pointers
         std::fill(clientOut + copied, clientOut + numAudioOut, dummybuf);
      }
 
      // Inner loop over blocks
      const auto blockSize = pInstance->GetBlockSize();
      for (size_t block = 0; block < numSamples; block += blockSize) {
         auto cnt = std::min(numSamples - block, blockSize);
         // Assuming we are in a processing scope, use the worker settings
         auto processed = pInstance->RealtimeProcess(processor,
            mWorkerSettings.settings, clientIn, clientOut, cnt);
         if (!mLatency)
            // Find latency once only per initialization scope,
            // after processing one block
            mLatency.emplace(
               pInstance->GetLatency(mWorkerSettings.settings, pair.second));
         for (size_t i = 0 ; i < numAudioIn; i++)
            if (clientIn[i])
               clientIn[i] += cnt;
         for (size_t i = 0 ; i < numAudioOut; i++)
            if (clientOut[i])
               clientOut[i] += cnt;
         if (ondx == 0) {
            // For the first processor only
            len += processed;
            auto discard = limitSampleBufferSize(len, *mLatency);
            len -= discard;
            *mLatency -= discard;
         }
      }
      ++processor;
      return true;
   });
   // Report the number discardable during the processing scope
   // We are assuming len as calculated above is the same in case of multiple
   // processors
   return numSamples - len;
}

References anonymous_namespace{RealtimeEffectState.cpp}::AllocateChannelsToProcessors(), staffpad::vo::copy(), limitSampleBufferSize(), mGroups, min(), mLastActive, mLatency, mPlugin, mwInstance, mWorkerSettings, and stackAllocate.

Referenced by RealtimeEffectManager::Process().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessEnd()

bool RealtimeEffectState::ProcessEnd

(

)

Worker thread finishes a batch of samples.

Definition at line 608 of file RealtimeEffectState.cpp.

{
   auto pInstance = mwInstance.lock();
   bool result = pInstance &&
      // Assuming we are in a processing scope, use the worker settings
      pInstance->RealtimeProcessEnd(mWorkerSettings.settings) &&
      IsActive() && mLastActive;
 
   if (auto pAccessState = TestAccessState())
      // Always done, regardless of activity
      // Some dialogs require communication back from the processor so that
      // they can update their appearance in idle time, and some plug-in
      // libraries (like lv2) require the host program to mediate the
      // communication
      pAccessState->WorkerWrite();
 
   return result;
}

References IsActive(), mLastActive, mwInstance, mWorkerSettings, and TestAccessState().

Referenced by RealtimeEffectManager::ProcessEnd().

Here is the call graph for this function:

Here is the caller graph for this function:

ProcessStart()

bool RealtimeEffectState::ProcessStart

(

bool

running

)

Worker thread begins a batch of samples.

Parameters

running

means no pause or deactivation of containing list

Definition at line 488 of file RealtimeEffectState.cpp.

{
   // Get state changes from the main thread
   // Note that it is only here that the answer of IsActive() may be changed,
   // and it is important that for each state the answer is unchanging in one
   // processing scope.
   if (auto pAccessState = TestAccessState())
      pAccessState->WorkerRead();
 
   // Detect transitions of activity state
   auto pInstance = mwInstance.lock();
   bool active = IsActive() && running;
   if (active != mLastActive) {
      if (pInstance) {
         bool success = active
            ? pInstance->RealtimeResume()
            : pInstance->RealtimeSuspend();
         if (!success)
            return false;
      }
      mLastActive = active;
   }
 
   bool result = false;
   if (pInstance) {
      // Consume messages even if not processing
      // (issue #3855: plain UI for VST 2 effects)
 
      // Assuming we are in a processing scope, use the worker settings
      EffectInstance::MessagePackage package{
         mWorkerSettings.settings, mMovedMessage.get()
      };
      result = pInstance->RealtimeProcessStart(package);
   }
 
   if (!pInstance || !active)
      return false;
   else
      return result;
}

References IsActive(), mLastActive, mMovedMessage, mwInstance, mWorkerSettings, and TestAccessState().

Referenced by RealtimeEffectManager::ProcessStart().

Here is the call graph for this function:

Here is the caller graph for this function:

SetActive()

void RealtimeEffectState::SetActive

(

bool

active

)

Set only in the main thread.

Definition at line 637 of file RealtimeEffectState.cpp.

{
   auto access = GetAccess();
   access->ModifySettings([&](EffectSettings &settings) {
      settings.extra.SetActive(active);
      return nullptr;
   });
   access->Flush();
 
   Publish(active
      ? RealtimeEffectStateChange::EffectOn
      : RealtimeEffectStateChange::EffectOff);
}

References EffectOff, EffectOn, GetAccess(), Observer::Publisher< RealtimeEffectStateChange >::Publish(), and settings().

Here is the call graph for this function:

SetID()

void RealtimeEffectState::SetID

(

const PluginID &

id

)

May be called with nonempty id at most once in the lifetime of a state.

Call with empty id is ignored. Called by the constructor that takes an id

Definition at line 326 of file RealtimeEffectState.cpp.

{
   bool empty = id.empty();
   if (mID.empty() && !empty) {
      mID = id;
      GetEffect();
   }
   else
      // Set mID to non-empty at most once
      assert(empty);
}

References GetEffect(), id, and mID.

Referenced by HandleXMLTag(), and RealtimeEffectState().

Here is the call graph for this function:

Here is the caller graph for this function:

TestAccessState()

AccessState * RealtimeEffectState::TestAccessState ( ) const

inlineprivate

Definition at line 130 of file RealtimeEffectState.h.

   {
      return mpAccessState.load(std::memory_order_acquire);
   }

Referenced by ProcessEnd(), and ProcessStart().

Here is the caller graph for this function:

WriteXML()

void RealtimeEffectState::WriteXML

(

XMLWriter &

xmlFile

)

Definition at line 744 of file RealtimeEffectState.cpp.

{
   if (!mPlugin)
      return;
 
   xmlFile.StartTag(XMLTag());
   const auto active = mMainSettings.settings.extra.GetActive();
   xmlFile.WriteAttr(activeAttribute, active);
   xmlFile.WriteAttr(idAttribute, PluginManager::GetID(mPlugin));
   xmlFile.WriteAttr(versionAttribute, mPlugin->GetVersion());
 
   CommandParameters cmdParms;
   if (mPlugin->SaveSettings(mMainSettings.settings, cmdParms)) {
      xmlFile.StartTag(parametersAttribute);
 
      wxString entryName;
      long entryIndex;
      bool entryKeepGoing;
 
      entryKeepGoing = cmdParms.GetFirstEntry(entryName, entryIndex);
      while (entryKeepGoing) {
         wxString entryValue = cmdParms.Read(entryName, "");
 
         xmlFile.StartTag(parameterAttribute);
         xmlFile.WriteAttr(nameAttribute, entryName);
         xmlFile.WriteAttr(valueAttribute, entryValue);
         xmlFile.EndTag(parameterAttribute);
 
         entryKeepGoing = cmdParms.GetNextEntry(entryName, entryIndex);
      }
 
      xmlFile.EndTag(parametersAttribute);
   }
 
   xmlFile.EndTag(XMLTag());
}

References activeAttribute, XMLWriter::EndTag(), PluginManager::GetID(), ComponentInterface::GetVersion(), idAttribute, mMainSettings, mPlugin, nameAttribute, parameterAttribute, parametersAttribute, EffectSettingsManager::SaveSettings(), XMLWriter::StartTag(), valueAttribute, versionAttribute, XMLWriter::WriteAttr(), and XMLTag().

Here is the call graph for this function:

XMLTag()

const std::string & RealtimeEffectState::XMLTag ( )

static

Definition at line 671 of file RealtimeEffectState.cpp.

{
   static const std::string result{"effect"};
   return result;
}

Referenced by RealtimeEffectList::HandleXMLChild(), HandleXMLEndTag(), HandleXMLTag(), and WriteXML().

Here is the caller graph for this function:

Member Data Documentation

mCurrentProcessor

size_t RealtimeEffectState::mCurrentProcessor { 0 }

private

Definition at line 195 of file RealtimeEffectState.h.

Referenced by AddTrack(), Finalize(), and Initialize().

mGroups

std::unordered_map<const Track *, std::pair<size_t, double> > RealtimeEffectState::mGroups

private

Definition at line 187 of file RealtimeEffectState.h.

Referenced by AddTrack(), Finalize(), Initialize(), and Process().

mID

PluginID RealtimeEffectState::mID

private

Definition at line 135 of file RealtimeEffectState.h.

Referenced by GetEffect(), GetID(), HandleXMLTag(), and SetID().

mInitialized

bool RealtimeEffectState::mInitialized { false }

private

Definition at line 196 of file RealtimeEffectState.h.

Referenced by EnsureInstance(), and Finalize().

mLastActive

bool RealtimeEffectState::mLastActive {}

private

Assigned in the worker thread at the start of each processing scope.

Definition at line 179 of file RealtimeEffectState.h.

Referenced by EnsureInstance(), Process(), ProcessEnd(), and ProcessStart().

mLatency

std::optional<EffectInstance::SampleCount> RealtimeEffectState::mLatency

private

How many samples must be discarded.

Definition at line 177 of file RealtimeEffectState.h.

Referenced by Finalize(), Initialize(), and Process().

mMainSettings

NonInterfering<SettingsAndCounter> RealtimeEffectState::mMainSettings

private

Updated immediately by Access::Set in the main thread.

Definition at line 162 of file RealtimeEffectState.h.

Referenced by RealtimeEffectState::AccessState::AccessState(), EnsureInstance(), Finalize(), GetEffect(), HandleXMLEndTag(), HandleXMLTag(), IsEnabled(), MakeInstance(), and WriteXML().

mMessage

std::unique_ptr<EffectInstance::Message> RealtimeEffectState::mMessage

private

Definition at line 163 of file RealtimeEffectState.h.

Referenced by RealtimeEffectState::AccessState::AccessState(), and MakeInstance().

mMovedMessage

std::unique_ptr<EffectInstance::Message> RealtimeEffectState::mMovedMessage

private

Definition at line 173 of file RealtimeEffectState.h.

Referenced by MakeInstance(), ProcessStart(), and RealtimeEffectState::AccessState::FromMainSlot::Reader::Reader().

mMovedOutputs

std::unique_ptr<EffectOutputs> RealtimeEffectState::mMovedOutputs

private

Definition at line 164 of file RealtimeEffectState.h.

Referenced by RealtimeEffectState::AccessState::AccessState(), GetEffect(), RealtimeEffectState::AccessState::MainRead(), and MakeInstance().

mOutputs

std::unique_ptr<EffectOutputs> RealtimeEffectState::mOutputs

private

Definition at line 174 of file RealtimeEffectState.h.

Referenced by AddTrack(), GetEffect(), and RealtimeEffectState::AccessState::WorkerWrite().

mpAccessState

AtomicUniquePointer<AccessState> RealtimeEffectState::mpAccessState { nullptr }

private

Definition at line 192 of file RealtimeEffectState.h.

Referenced by GetAccess().

mParameters

wxString RealtimeEffectState::mParameters

private

Definition at line 194 of file RealtimeEffectState.h.

Referenced by HandleXMLEndTag(), and HandleXMLTag().

mPlugin

const EffectInstanceFactory* RealtimeEffectState::mPlugin {}

private

Stateless effect object.

Definition at line 140 of file RealtimeEffectState.h.

Referenced by AddTrack(), EnsureInstance(), GetAccess(), GetEffect(), GetInstance(), HandleXMLEndTag(), HandleXMLTag(), Initialize(), MakeInstance(), Process(), and WriteXML().

mwInstance

std::weak_ptr<EffectInstance> RealtimeEffectState::mwInstance

private

Stateful instance made by the plug-in.

Definition at line 138 of file RealtimeEffectState.h.

Referenced by EnsureInstance(), Finalize(), GetInstance(), Process(), ProcessEnd(), and ProcessStart().

mWorkerSettings

NonInterfering<SettingsAndCounter> RealtimeEffectState::mWorkerSettings

private

Updated with delay, but atomically, in the worker thread; skipped by the copy constructor so that there isn't a race when pushing an Undo state

Definition at line 172 of file RealtimeEffectState.h.

Referenced by AddTrack(), EnsureInstance(), Finalize(), IsActive(), Process(), ProcessEnd(), ProcessStart(), RealtimeEffectState::AccessState::FromMainSlot::Reader::Reader(), and RealtimeEffectState::AccessState::WorkerWrite().

---

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

• RealtimeEffectState.h
• RealtimeEffectState.cpp