#include <VST3Wrapper.h>

Collaboration diagram for VST3Wrapper:

Public Member Functions
	VST3Wrapper (VST3::Hosting::Module &module, VST3::UID effectUID)

	~VST3Wrapper ()

	VST3Wrapper (const VST3Wrapper &)=delete

	VST3Wrapper (VST3Wrapper &&)=delete

VST3Wrapper &	operator= (const VST3Wrapper &)=delete

VST3Wrapper &	operator= (VST3Wrapper &&)=delete

VST3::Hosting::Module &	GetModule () const

bool	IsActive () const noexcept

void	FetchSettings (EffectSettings &)
	Fetch state from settings object, may change internal runtime data. More...

void	StoreSettings (EffectSettings &) const
	Saves current state inside settings object, clears all runtime data. More...

bool	LoadPreset (Steinberg::IBStream *fileStream)

bool	SavePreset (Steinberg::IBStream *fileStream) const

bool	Initialize (EffectSettings &settings, Steinberg::Vst::SampleRate sampleRate, Steinberg::int32 processMode, Steinberg::int32 maxSamplesPerBlock)
	Initializes effect for processing using settings. More...

void	Finalize (EffectSettings *settings)

void	ProcessBlockStart (const EffectSettings &settings)
	Prepares effect to process next block with changes written to the settings object. More...

void	FlushParameters (EffectSettings &settings, bool *hasChanges=nullptr)

size_t	Process (const float const inBlock, float const outBlock, size_t blockLen)

void	SuspendProcessing ()

void	ResumeProcessing ()

void	BeginParameterEdit (EffectSettingsAccess &access)

void	EndParameterEdit ()

Steinberg::int32	GetLatencySamples () const

Static Public Member Functions
static EffectSettings	MakeSettings ()

static void	LoadSettings (const CommandParameters &parms, EffectSettings &settings)

static void	SaveSettings (const EffectSettings &settings, CommandParameters &parms)

static OptionalMessage	LoadUserPreset (const EffectDefinitionInterface &effect, const RegistryPath &name, EffectSettings &settings)

static void	SaveUserPreset (const EffectDefinitionInterface &effect, const RegistryPath &name, const EffectSettings &settings)

static void	CopySettingsContents (const EffectSettings &src, EffectSettings &dst)

Public Attributes
Steinberg::IPtr< Steinberg::Vst::IAudioProcessor >	mAudioProcessor

Steinberg::Vst::ProcessSetup	mSetup

Steinberg::IPtr< Steinberg::Vst::IComponent >	mEffectComponent

Steinberg::IPtr< Steinberg::Vst::IEditController >	mEditController

Steinberg::IPtr< Steinberg::Vst::IConnectionPoint >	mComponentConnectionProxy

Steinberg::IPtr< Steinberg::Vst::IConnectionPoint >	mControllerConnectionProxy

Steinberg::IPtr< Steinberg::Vst::IComponentHandler >	mComponentHandler

std::function< void(Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue)>	ParamChangedHandler

Private Member Functions
void	ConsumeChanges (const EffectSettings &settings)

Private Attributes
EffectSettings	mDefaultSettings

VST3::Hosting::Module &	mModule

bool	mActive {false}

const VST3::UID	mEffectUID

std::vector< std::pair< Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue > >	mParameters

std::unique_ptr< SingleInputParameterValue[]>	mParameterQueues

Detailed Description

Definition at line 53 of file VST3Wrapper.h.

Constructor & Destructor Documentation

◆ VST3Wrapper() [1/3]

VST3Wrapper::VST3Wrapper	(	VST3::Hosting::Module &	module,
		VST3::UID	effectUID
	)

Definition at line 380 of file VST3Wrapper.cpp.

   : mEffectUID(std::move(effectUID))
   , mModule{ module }
{
   using namespace Steinberg;
 
   //Preinitialize with some default values in case if parameters
   //flush happens before processing initialized
   mSetup.maxSamplesPerBlock = 512;
   mSetup.processMode = Vst::kOffline;
   mSetup.symbolicSampleSize = Vst::kSample32;
   mSetup.sampleRate = 44100.0;
 
   const auto& pluginFactory = module.getFactory();
 
   auto effectComponent = pluginFactory.createInstance<Vst::IComponent>(mEffectUID);
   if(!effectComponent)
      throw std::runtime_error("Cannot create VST3 effect component");
   if(effectComponent->initialize(&AudacityVst3HostApplication::Get()) != kResultOk)
      throw std::runtime_error("Cannot initialize VST3 effect component");
 
   auto audioProcessor = FUnknownPtr<Vst::IAudioProcessor>(effectComponent);
   if(!audioProcessor)
      //It's stated that "This interface must always be supported by audio processing plug-ins."
      throw std::runtime_error("VST3 plugin does not provide audio processor interface");
   
   if(audioProcessor->canProcessSampleSize(Vst::kSample32) != kResultTrue)
      throw std::runtime_error("32-bit sample size not supported");
 
   mEffectComponent = effectComponent;
   mAudioProcessor = audioProcessor;
 
   if(!SetupProcessing(*mEffectComponent, mSetup))
      throw std::runtime_error("bus configuration not supported");
 
   auto editController = FUnknownPtr<Vst::IEditController>(mEffectComponent);
   if(editController.get() == nullptr)
   {
      TUID controllerCID;
            
      if (mEffectComponent->getControllerClassId (controllerCID) == kResultTrue)
         editController = pluginFactory.createInstance<Vst::IEditController>(VST3::UID(controllerCID));
   }
 
   if(editController.get() == nullptr)
      throw std::runtime_error("Failed to instantiate edit controller");
   
   mEditController = editController;
   mEditController->initialize(&AudacityVst3HostApplication::Get());
 
   mComponentHandler = owned(safenew ComponentHandler(*this));
   mEditController->setComponentHandler(mComponentHandler);
 
   const auto componentConnectionPoint = FUnknownPtr<Vst::IConnectionPoint>{ mEffectComponent };
   const auto controllerConnectionPoint = FUnknownPtr<Vst::IConnectionPoint>{ mEditController };
 
   if (componentConnectionPoint && controllerConnectionPoint)
   {
      mComponentConnectionProxy = owned(safenew internal::ConnectionProxy(componentConnectionPoint));
      mControllerConnectionProxy = owned(safenew internal::ConnectionProxy(controllerConnectionPoint));
 
      mComponentConnectionProxy->connect(controllerConnectionPoint);
      mControllerConnectionProxy->connect(componentConnectionPoint);
   }
 
   mParameterQueues = std::make_unique<SingleInputParameterValue[]>(mEditController->getParameterCount());
   mParameters.reserve(mEditController->getParameterCount());
 
   Steinberg::MemoryStream stateStream;
   if(mEffectComponent->getState(&stateStream) == kResultOk)
   {
      int64 unused;
      stateStream.seek(0, IBStream::kIBSeekSet, &unused);
      mEditController->setComponentState(&stateStream);
   }
 
   mDefaultSettings = MakeSettings();
   StoreSettings(mDefaultSettings);
 
   
   static_cast<ComponentHandler*>(mComponentHandler.get())
      ->LoadCurrentParamValues();
}

References AudacityVst3HostApplication::Get(), MakeSettings(), mAudioProcessor, mComponentConnectionProxy, mComponentHandler, mControllerConnectionProxy, mDefaultSettings, mEditController, mEffectComponent, mEffectUID, mParameterQueues, mParameters, mSetup, safenew, Steinberg::MemoryStream::seek(), anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing(), and StoreSettings().

Here is the call graph for this function:

◆ ~VST3Wrapper()

VST3Wrapper::~VST3Wrapper ( )

Definition at line 464 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   if(mComponentConnectionProxy)
      mComponentConnectionProxy->disconnect(FUnknownPtr<Vst::IConnectionPoint>(mEditController));
   if(mControllerConnectionProxy)
      mControllerConnectionProxy->disconnect(FUnknownPtr<Vst::IConnectionPoint>(mEffectComponent));
 
   if(mEditController)
   {
      mEditController->setComponentHandler(nullptr);
      mEditController->terminate();
   }
   if(mEffectComponent)
      mEffectComponent->terminate();
}

References mComponentConnectionProxy, mControllerConnectionProxy, mEditController, and mEffectComponent.

◆ VST3Wrapper() [2/3]

VST3Wrapper::VST3Wrapper ( const VST3Wrapper & )

delete

◆ VST3Wrapper() [3/3]

VST3Wrapper::VST3Wrapper ( VST3Wrapper && )

delete

Member Function Documentation

◆ BeginParameterEdit()

void VST3Wrapper::BeginParameterEdit ( EffectSettingsAccess & access )

Definition at line 782 of file VST3Wrapper.cpp.

{
   static_cast<ComponentHandler*>(mComponentHandler.get())->SetAccess(&access);
}

References mComponentHandler.

Referenced by VST3UIValidator::VST3UIValidator().

Here is the caller graph for this function:

◆ ConsumeChanges()

void VST3Wrapper::ConsumeChanges ( const EffectSettings & settings )

private

Definition at line 629 of file VST3Wrapper.cpp.

{
   const auto& vst3settings = GetSettings(settings);
   for(auto& p : vst3settings.parameterChanges)
   {
      auto it = std::find_if(mParameters.begin(), mParameters.end(), [&p](const auto& v) { return v.first == p.first; });
      if(it != mParameters.end())
         it->second = p.second;
      else
         mParameters.push_back(p);
   }
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mParameters, and settings().

Referenced by Finalize(), FlushParameters(), Initialize(), and ProcessBlockStart().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopySettingsContents()

void VST3Wrapper::CopySettingsContents	(	const EffectSettings &	src,
		EffectSettings &	dst
	)

static

Definition at line 869 of file VST3Wrapper.cpp.

{
   auto& from = GetSettings(*const_cast<EffectSettings*>(&src));
   auto& to = GetSettings(dst);
 
   //Don't allocate in worker
   std::swap(from.parameterChanges, to.parameterChanges);
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3Effect::CopySettingsContents().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EndParameterEdit()

void VST3Wrapper::EndParameterEdit ( )

Definition at line 787 of file VST3Wrapper.cpp.

{
   auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
   componentHandler->SetAccess(nullptr);
}

References mComponentHandler.

Referenced by VST3UIValidator::OnClose().

Here is the caller graph for this function:

◆ FetchSettings()

void VST3Wrapper::FetchSettings ( EffectSettings & settings )

Fetch state from settings object, may change internal runtime data.

Definition at line 487 of file VST3Wrapper.cpp.

{
   //TODO: perform version check
   {
      auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
      componentHandler->ResetCache();
      componentHandler->BeginStateChange(settings);
      auto cleanup = finally([&] { componentHandler->EndStateChange(); });
 
      //Restore state
      const auto* vst3settings = &GetSettings(settings);
      if(!vst3settings->processorState.has_value())
         vst3settings = &GetSettings(mDefaultSettings);
 
      if(vst3settings->processorState.has_value())
      {
         auto processorState = PresetsBufferStream::fromString(*vst3settings->processorState);
         processorState->seek(0, Steinberg::IBStream::kIBSeekSet);
         if(mEffectComponent->setState(processorState) == Steinberg::kResultOk)
         {
            processorState->seek(0, Steinberg::IBStream::kIBSeekSet);
            if(mEditController->setComponentState(processorState) == Steinberg::kResultOk)
            {
               if(vst3settings->controllerState.has_value())
               {
                  auto controllerState = PresetsBufferStream::fromString(*vst3settings->controllerState);
                  controllerState->seek(0, Steinberg::IBStream::kIBSeekSet);
                  mEditController->setState(controllerState);
               }
            }
         }
      }
   }
   //restore parameters if present
   auto& vst3setting = GetSettings(settings);
   for(auto& p : vst3setting.parameterChanges)
      mEditController->setParamNormalized(p.first, p.second);
}

References PresetsBufferStream::fromString(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mComponentHandler, mDefaultSettings, mEditController, mEffectComponent, and settings().

Referenced by Initialize(), and VST3UIValidator::UpdateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Finalize()

void VST3Wrapper::Finalize ( EffectSettings * settings )

Frees up resources allocated for processing, should be called after processing is complete. Optionally settings object may be passed to update runtime data with current internal state.

Definition at line 607 of file VST3Wrapper.cpp.

{
   //Could be FlushParameters but processor is already configured
   //If no calls to process were performed deliver changes here
   if(settings != nullptr)
   {
      ConsumeChanges(*settings);
      Process(nullptr, nullptr, 0);
   }
   mAudioProcessor->setProcessing(false);
   mEffectComponent->setActive(false);
   mActive = false;
 
   if(settings != nullptr)
      StoreSettings(*settings);
}

References ConsumeChanges(), mActive, mAudioProcessor, mEffectComponent, Process(), settings(), and StoreSettings().

Here is the call graph for this function:

◆ FlushParameters()

void VST3Wrapper::FlushParameters	(	EffectSettings &	settings,
		bool *	hasChanges = `nullptr`
	)

Parameters

hasChanges optional output variable, set to true if flushing has changed the DSP model state

Definition at line 651 of file VST3Wrapper.cpp.

{
   if(!mActive)
   {
      auto componentHandler = static_cast<ComponentHandler*>(mComponentHandler.get());
      componentHandler->FlushCache(settings);
 
      const auto doProcessing = !GetSettings(settings).parameterChanges.empty();
 
      if(hasChanges != nullptr)
         *hasChanges = doProcessing;
 
      if(!doProcessing)
         return;
 
      SetupProcessing(*mEffectComponent, mSetup);
      mActive = true;
      if(mEffectComponent->setActive(true) == Steinberg::kResultOk)
      {
         ConsumeChanges(settings);
         if(mAudioProcessor->setProcessing(true) != Steinberg::kResultFalse)
         {
            Process(nullptr, nullptr, 0);
            mAudioProcessor->setProcessing(false);
         }
      }
      mEffectComponent->setActive(false);
      mActive = false;
   }
   else if(hasChanges != nullptr)
      *hasChanges = false;
}

References ConsumeChanges(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mActive, mAudioProcessor, mComponentHandler, mEffectComponent, mSetup, anonymous_namespace{VST3Wrapper.cpp}::VST3EffectSettings::parameterChanges, Process(), settings(), and anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing().

Referenced by VST3UIValidator::OnClose(), VST3UIValidator::OnIdle(), and VST3UIValidator::ValidateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLatencySamples()

Steinberg::int32 VST3Wrapper::GetLatencySamples ( ) const

Definition at line 795 of file VST3Wrapper.cpp.

{
   return mAudioProcessor->getLatencySamples();
}

References mAudioProcessor.

◆ GetModule()

VST3::Hosting::Module & VST3Wrapper::GetModule ( ) const

inline

Definition at line 74 of file VST3Wrapper.h.

74{ return mModule; }

References mModule.

◆ Initialize()

bool VST3Wrapper::Initialize	(	EffectSettings &	settings,
		Steinberg::Vst::SampleRate	sampleRate,
		Steinberg::int32	processMode,
		Steinberg::int32	maxSamplesPerBlock
	)

Initializes effect for processing using settings.

Definition at line 574 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   Vst::ProcessSetup setup = {
      processMode,
      Vst::kSample32,
      maxSamplesPerBlock,
      sampleRate
   };
   
   if(!SetupProcessing(*mEffectComponent.get(), setup))
      return false;
 
   mSetup = setup;
 
   FetchSettings(settings);
 
   if(mEffectComponent->setActive(true) == kResultOk)
   {
      if(mAudioProcessor->setProcessing(true) != kResultFalse)
      {
         mActive = true;
         ConsumeChanges(settings);
         //make zero-flush, to make sure parameters are delivered to the processor...
         Process(nullptr, nullptr, 0);
         StoreSettings(settings);
         return true;
      }
   }
   return false;
}

References ConsumeChanges(), FetchSettings(), mActive, mAudioProcessor, mEffectComponent, mSetup, Process(), settings(), anonymous_namespace{VST3Wrapper.cpp}::SetupProcessing(), and StoreSettings().

Here is the call graph for this function:

◆ IsActive()

bool VST3Wrapper::IsActive ( ) const

noexcept

Definition at line 482 of file VST3Wrapper.cpp.

{
   return mActive;
}

References mActive.

Referenced by VST3UIValidator::OnIdle(), and anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::performEdit().

Here is the caller graph for this function:

◆ LoadPreset()

bool VST3Wrapper::LoadPreset ( Steinberg::IBStream * fileStream )

Definition at line 546 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   return Vst::PresetFile::loadPreset
   (
      fileStream,
      FUID::fromTUID(mEffectUID.data()),
      mEffectComponent.get(),
      mEditController.get()
   );
}

References mEditController, mEffectComponent, and mEffectUID.

◆ LoadSettings()

void VST3Wrapper::LoadSettings	(	const CommandParameters &	parms,
		EffectSettings &	settings
	)

static

Definition at line 805 of file VST3Wrapper.cpp.

{
   VST3EffectSettings vst3settings;
 
   if(parms.HasEntry(processorStateKey))
   {
      vst3settings.processorState = parms.Read(processorStateKey);
      if(parms.HasEntry(controllerStateKey))
         vst3settings.controllerState = parms.Read(controllerStateKey);
   }
   if(parms.HasEntry(parametersKey))
      vst3settings.parameterChanges = ParametersFromString(parms.Read(parametersKey));
 
   std::swap(vst3settings, GetSettings(settings));
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), CommandParameters::HasEntry(), anonymous_namespace{VST3Wrapper.cpp}::ParametersFromString(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, settings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3Effect::LoadSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadUserPreset()

OptionalMessage VST3Wrapper::LoadUserPreset	(	const EffectDefinitionInterface &	effect,
		const RegistryPath &	name,
		EffectSettings &	settings
	)

static

Definition at line 833 of file VST3Wrapper.cpp.

{
   VST3EffectSettings vst3settings;
   
   wxString processorStateStr;
   if(GetConfig(effect, PluginSettings::Private, name, processorStateKey, processorStateStr, wxEmptyString))
   {
      vst3settings.processorState = processorStateStr;
      wxString controllerStateStr;
      if(GetConfig(effect, PluginSettings::Private, name, controllerStateKey, controllerStateStr, wxEmptyString))
         vst3settings.controllerState = controllerStateStr;
   }
   wxString parametersStr;
   if(GetConfig(effect, PluginSettings::Private, name, parametersKey, parametersStr, wxEmptyString))
      vst3settings.parameterChanges = ParametersFromString(parametersStr);
 
   std::swap(vst3settings, GetSettings(settings));
   return { nullptr };
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, PluginSettings::GetConfig(), anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), name, anonymous_namespace{VST3Wrapper.cpp}::ParametersFromString(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, PluginSettings::Private, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, settings(), and anonymous_namespace{NoteTrack.cpp}::swap().

Referenced by VST3Effect::LoadUserPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MakeSettings()

EffectSettings VST3Wrapper::MakeSettings ( )

static

Definition at line 800 of file VST3Wrapper.cpp.

{
   return EffectSettings::Make<VST3EffectSettings>();
}

Referenced by VST3Effect::MakeSettings(), and VST3Wrapper().

Here is the caller graph for this function:

◆ operator=() [1/2]

VST3Wrapper & VST3Wrapper::operator= ( const VST3Wrapper & )

delete

◆ operator=() [2/2]

VST3Wrapper & VST3Wrapper::operator= ( VST3Wrapper && )

delete

◆ Process()

size_t VST3Wrapper::Process	(	const float const	inBlock,
		float const	outBlock,
		size_t	blockLen
	)

Definition at line 684 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
   
   InputParameterChanges inputParameterChanges(mParameters, mParameterQueues.get());
   mParameters.clear();
 
   Vst::ProcessData data;
   data.processMode = mSetup.processMode;
   data.symbolicSampleSize = mSetup.symbolicSampleSize;
   data.inputParameterChanges = &inputParameterChanges;
 
   static_assert(std::numeric_limits<decltype(blockLen)>::max()
      >= std::numeric_limits<decltype(data.numSamples)>::max());
 
   data.numSamples = static_cast<decltype(data.numSamples)>(std::min(
      blockLen, 
      static_cast<decltype(blockLen)>(mSetup.maxSamplesPerBlock)
   ));
 
   data.numInputs = inBlock == nullptr ? 0 : mEffectComponent->getBusCount(Vst::kAudio, Vst::kInput);
   data.numOutputs = outBlock == nullptr ? 0 : mEffectComponent->getBusCount(Vst::kAudio, Vst::kOutput);
 
   if(data.numInputs > 0)
   {
      int inputBlocksOffset {0};
 
      data.inputs = static_cast<Vst::AudioBusBuffers*>(
         alloca(sizeof(Vst::AudioBusBuffers) * data.numInputs));
 
      for(int busIndex = 0; busIndex < data.numInputs; ++busIndex)
      {
         Vst::BusInfo busInfo { };
         if(mEffectComponent->getBusInfo(Vst::kAudio, Vst::kInput, busIndex, busInfo) != kResultOk)
         {
            return 0;
         }
         if(busInfo.busType == Vst::kMain)
         {
            data.inputs[busIndex].numChannels = busInfo.channelCount;
            data.inputs[busIndex].channelBuffers32 = const_cast<float**>(inBlock + inputBlocksOffset);
            inputBlocksOffset += busInfo.channelCount;
         }
         else
         {
            //aux is not yet supported
            data.inputs[busIndex].numChannels = 0;
            data.inputs[busIndex].channelBuffers32 = nullptr;
         }
         data.inputs[busIndex].silenceFlags = 0UL;
      }
   }
   if(data.numOutputs > 0)
   {
      int outputBlocksOffset {0};
 
      data.outputs = static_cast<Vst::AudioBusBuffers*>(
         alloca(sizeof(Vst::AudioBusBuffers) * data.numOutputs));
      for(int busIndex = 0; busIndex < data.numOutputs; ++busIndex)
      {
         Vst::BusInfo busInfo { };
         if(mEffectComponent->getBusInfo(Vst::kAudio, Vst::kOutput, busIndex, busInfo) != kResultOk)
         {
            return 0;
         }
         if(busInfo.busType == Vst::kMain)
         {
            data.outputs[busIndex].numChannels = busInfo.channelCount;
            data.outputs[busIndex].channelBuffers32 = const_cast<float**>(outBlock + outputBlocksOffset);
            outputBlocksOffset += busInfo.channelCount;
         }
         else
         {
            //aux is not yet supported
            data.outputs[busIndex].numChannels = 0;
            data.outputs[busIndex].channelBuffers32 = nullptr;
         }
         data.outputs[busIndex].silenceFlags = 0UL;
      }
   }
 
   const auto processResult = mAudioProcessor->process(data);
   
   return processResult == kResultOk ?
      data.numSamples : 0;
}

References mAudioProcessor, mEffectComponent, min(), mParameterQueues, mParameters, and mSetup.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ProcessBlockStart()

void VST3Wrapper::ProcessBlockStart ( const EffectSettings & settings )

Prepares effect to process next block with changes written to the settings object.

Definition at line 624 of file VST3Wrapper.cpp.

{
   ConsumeChanges(settings);
}

References ConsumeChanges(), and settings().

Here is the call graph for this function:

◆ ResumeProcessing()

void VST3Wrapper::ResumeProcessing ( )

Definition at line 777 of file VST3Wrapper.cpp.

{
   mAudioProcessor->setProcessing(true);
}

References mAudioProcessor.

◆ SavePreset()

bool VST3Wrapper::SavePreset ( Steinberg::IBStream * fileStream ) const

Definition at line 560 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   return Vst::PresetFile::savePreset
   (
      fileStream,
      FUID::fromTUID(mEffectUID.data()),
      mEffectComponent.get(),
 
      mEditController.get()
   );
}

References mEditController, mEffectComponent, and mEffectUID.

◆ SaveSettings()

void VST3Wrapper::SaveSettings	(	const EffectSettings &	settings,
		CommandParameters &	parms
	)

static

Definition at line 821 of file VST3Wrapper.cpp.

{
   const auto& vst3settings = GetSettings(settings);
 
   if(vst3settings.processorState.has_value())
      parms.Write(processorStateKey, *vst3settings.processorState);
   if(vst3settings.controllerState.has_value())
      parms.Write(controllerStateKey, *vst3settings.controllerState);
   if(!vst3settings.parameterChanges.empty())
      parms.Write(parametersKey, ParametersToString(vst3settings.parameterChanges)); 
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::ParametersToString(), anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, and settings().

Referenced by VST3Effect::SaveSettings().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveUserPreset()

void VST3Wrapper::SaveUserPreset	(	const EffectDefinitionInterface &	effect,
		const RegistryPath &	name,
		const EffectSettings &	settings
	)

static

Definition at line 854 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
 
   const auto& vst3settings = GetSettings(settings);
   if(vst3settings.processorState.has_value())
   {
      SetConfig(effect, PluginSettings::Private, name, processorStateKey, *vst3settings.processorState);
      if(vst3settings.controllerState.has_value())
         SetConfig(effect, PluginSettings::Private, name, controllerStateKey, *vst3settings.controllerState);
   }
   if(!vst3settings.parameterChanges.empty())
      SetConfig(effect, PluginSettings::Private, name, parametersKey, ParametersToString(vst3settings.parameterChanges));
}

References anonymous_namespace{VST3Wrapper.cpp}::controllerStateKey, anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), name, anonymous_namespace{VST3Wrapper.cpp}::parametersKey, anonymous_namespace{VST3Wrapper.cpp}::ParametersToString(), PluginSettings::Private, anonymous_namespace{VST3Wrapper.cpp}::processorStateKey, PluginSettings::SetConfig(), and settings().

Referenced by VST3Effect::SaveUserPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StoreSettings()

void VST3Wrapper::StoreSettings ( EffectSettings & settings ) const

Saves current state inside settings object, clears all runtime data.

Definition at line 526 of file VST3Wrapper.cpp.

{
   using namespace Steinberg;
   
   VST3EffectSettings vst3settings;
 
   {
      PresetsBufferStream processorState;
      if(mEffectComponent->getState(&processorState) == kResultOk)
         vst3settings.processorState = processorState.toString();
   }
   {
      PresetsBufferStream controllerState;
      if(mEditController->getState(&controllerState) == kResultOk)
         vst3settings.controllerState = controllerState.toString();
   }
   
   std::swap(vst3settings, GetSettings(settings));
}

References anonymous_namespace{VST3Wrapper.cpp}::GetSettings(), mEditController, mEffectComponent, settings(), anonymous_namespace{NoteTrack.cpp}::swap(), and PresetsBufferStream::toString().

Referenced by Finalize(), Initialize(), VST3UIValidator::OnClose(), VST3UIValidator::OnIdle(), VST3UIValidator::ValidateUI(), and VST3Wrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SuspendProcessing()

void VST3Wrapper::SuspendProcessing ( )

Definition at line 772 of file VST3Wrapper.cpp.

{
   mAudioProcessor->setProcessing(false);
}

References mAudioProcessor.

Member Data Documentation

◆ mActive

bool VST3Wrapper::mActive {false}

private

Definition at line 133 of file VST3Wrapper.h.

Referenced by Finalize(), FlushParameters(), Initialize(), and IsActive().

◆ mAudioProcessor

Steinberg::IPtr<Steinberg::Vst::IAudioProcessor> VST3Wrapper::mAudioProcessor

Definition at line 58 of file VST3Wrapper.h.

Referenced by Finalize(), FlushParameters(), GetLatencySamples(), Initialize(), Process(), ResumeProcessing(), SuspendProcessing(), and VST3Wrapper().

◆ mComponentConnectionProxy

Steinberg::IPtr<Steinberg::Vst::IConnectionPoint> VST3Wrapper::mComponentConnectionProxy

Definition at line 62 of file VST3Wrapper.h.

Referenced by VST3Wrapper(), and ~VST3Wrapper().

◆ mComponentHandler

Steinberg::IPtr<Steinberg::Vst::IComponentHandler> VST3Wrapper::mComponentHandler

Definition at line 64 of file VST3Wrapper.h.

Referenced by BeginParameterEdit(), EndParameterEdit(), FetchSettings(), FlushParameters(), VST3UIValidator::VST3UIValidator(), and VST3Wrapper().

◆ mControllerConnectionProxy

Steinberg::IPtr<Steinberg::Vst::IConnectionPoint> VST3Wrapper::mControllerConnectionProxy

Definition at line 63 of file VST3Wrapper.h.

Referenced by VST3Wrapper(), and ~VST3Wrapper().

◆ mDefaultSettings

EffectSettings VST3Wrapper::mDefaultSettings

private

Definition at line 55 of file VST3Wrapper.h.

Referenced by FetchSettings(), and VST3Wrapper().

◆ mEditController

Steinberg::IPtr<Steinberg::Vst::IEditController> VST3Wrapper::mEditController

Definition at line 61 of file VST3Wrapper.h.

Referenced by FetchSettings(), anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::LoadCurrentParamValues(), LoadPreset(), SavePreset(), StoreSettings(), VST3UIValidator::TryLoadNativeUI(), VST3UIValidator::VST3UIValidator(), VST3Wrapper(), and ~VST3Wrapper().

◆ mEffectComponent

Steinberg::IPtr<Steinberg::Vst::IComponent> VST3Wrapper::mEffectComponent

Definition at line 60 of file VST3Wrapper.h.

Referenced by FetchSettings(), Finalize(), FlushParameters(), Initialize(), LoadPreset(), Process(), SavePreset(), StoreSettings(), VST3Wrapper(), and ~VST3Wrapper().

◆ mEffectUID

const VST3::UID VST3Wrapper::mEffectUID

private

Definition at line 134 of file VST3Wrapper.h.

Referenced by LoadPreset(), SavePreset(), and VST3Wrapper().

◆ mModule

VST3::Hosting::Module& VST3Wrapper::mModule

private

Definition at line 56 of file VST3Wrapper.h.

Referenced by GetModule().

◆ mParameterQueues

std::unique_ptr<SingleInputParameterValue[]> VST3Wrapper::mParameterQueues

private

Definition at line 141 of file VST3Wrapper.h.

Referenced by Process(), and VST3Wrapper().

◆ mParameters

std::vector<std::pair<Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue> > VST3Wrapper::mParameters

private

Definition at line 136 of file VST3Wrapper.h.

Referenced by ConsumeChanges(), Process(), and VST3Wrapper().

◆ mSetup

Steinberg::Vst::ProcessSetup VST3Wrapper::mSetup

Definition at line 59 of file VST3Wrapper.h.

Referenced by FlushParameters(), Initialize(), Process(), VST3UIValidator::VST3UIValidator(), and VST3Wrapper().

◆ ParamChangedHandler

std::function<void (Steinberg::Vst::ParamID, Steinberg::Vst::ParamValue)> VST3Wrapper::ParamChangedHandler

Definition at line 126 of file VST3Wrapper.h.

Referenced by anonymous_namespace{VST3Wrapper.cpp}::ComponentHandler::NotifyParamChange(), VST3UIValidator::OnClose(), VST3UIValidator::VST3UIValidator(), and VST3UIValidator::~VST3UIValidator().

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

Public Member Functions

Static Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ VST3Wrapper() [1/3]

◆ ~VST3Wrapper()

◆ VST3Wrapper() [2/3]

◆ VST3Wrapper() [3/3]

Member Function Documentation

◆ BeginParameterEdit()

◆ ConsumeChanges()

◆ CopySettingsContents()

◆ EndParameterEdit()

◆ FetchSettings()

◆ Finalize()

◆ FlushParameters()

◆ GetLatencySamples()

◆ GetModule()

◆ Initialize()

◆ IsActive()

◆ LoadPreset()

◆ LoadSettings()

◆ LoadUserPreset()

◆ MakeSettings()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ Process()

◆ ProcessBlockStart()

◆ ResumeProcessing()

◆ SavePreset()

◆ SaveSettings()

◆ SaveUserPreset()

◆ StoreSettings()

◆ SuspendProcessing()

Member Data Documentation

◆ mActive

◆ mAudioProcessor

◆ mComponentConnectionProxy

◆ mComponentHandler

◆ mControllerConnectionProxy

◆ mDefaultSettings

◆ mEditController

◆ mEffectComponent

◆ mEffectUID

◆ mModule

◆ mParameterQueues

◆ mParameters

◆ mSetup

◆ ParamChangedHandler