#include <LV2Effect.h>

Inheritance diagram for LV2Effect:

Collaboration diagram for LV2Effect:

Public Member Functions
	LV2Effect (const LilvPlugin *plug)

virtual	~LV2Effect ()

PluginPath	GetPath () override

ComponentInterfaceSymbol	GetSymbol () override

VendorSymbol	GetVendor () override

wxString	GetVersion () override

TranslatableString	GetDescription () override

EffectType	GetType () override

EffectFamilySymbol	GetFamily () override

bool	IsInteractive () override

bool	IsDefault () override

bool	IsLegacy () override

bool	SupportsRealtime () override

bool	SupportsAutomation () override

bool	SetHost (EffectHostInterface *host) override

unsigned	GetAudioInCount () override

unsigned	GetAudioOutCount () override

int	GetMidiInCount () override

int	GetMidiOutCount () override

void	SetSampleRate (double rate) override

size_t	SetBlockSize (size_t maxBlockSize) override

size_t	GetBlockSize () const override

sampleCount	GetLatency () override

size_t	GetTailSize () override

bool	IsReady () override

bool	ProcessInitialize (sampleCount totalLen, ChannelNames chanMap=NULL) override

bool	ProcessFinalize () override

size_t	ProcessBlock (float inbuf, float outbuf, size_t size) override

bool	RealtimeInitialize () override

bool	RealtimeAddProcessor (unsigned numChannels, float sampleRate) override

bool	RealtimeFinalize () override

bool	RealtimeSuspend () override

bool	RealtimeResume () override

bool	RealtimeProcessStart () override

size_t	RealtimeProcess (int group, float inbuf, float outbuf, size_t numSamples) override

bool	RealtimeProcessEnd () override

bool	ShowInterface (wxWindow &parent, const EffectDialogFactory &factory, bool forceModal=false) override

bool	GetAutomationParameters (CommandParameters &parms) override

bool	SetAutomationParameters (CommandParameters &parms) override

void	SetHostUI (EffectUIHostInterface *host) override

bool	PopulateUI (ShuttleGui &S) override

bool	IsGraphicalUI () override

bool	ValidateUI () override

bool	HideUI () override

bool	CloseUI () override

bool	LoadUserPreset (const RegistryPath &name) override

bool	SaveUserPreset (const RegistryPath &name) override

RegistryPaths	GetFactoryPresets () override

bool	LoadFactoryPreset (int id) override

bool	LoadFactoryDefaults () override

bool	CanExportPresets () override

void	ExportPresets () override

void	ImportPresets () override

bool	HasOptions () override

void	ShowOptions () override

Public Member Functions inherited from EffectClientInterface
virtual	~EffectClientInterface ()

Public Member Functions inherited from EffectDefinitionInterface
virtual	~EffectDefinitionInterface ()

virtual EffectType	GetClassification ()

Public Member Functions inherited from ComponentInterface
virtual	~ComponentInterface ()

TranslatableString	GetName ()

virtual bool	DefineParams (ShuttleParams &WXUNUSED(S))

Public Member Functions inherited from EffectUIClientInterface
virtual	~EffectUIClientInterface ()

Private Member Functions
bool	LoadParameters (const RegistryPath &group)

bool	SaveParameters (const RegistryPath &group)

LV2Wrapper *	InitInstance (float sampleRate)

void	FreeInstance (LV2Wrapper *wrapper)

LV2_URID	URID_Map (const char *uri)

const char *	URID_Unmap (LV2_URID urid)

int	UIResize (int width, int height)

void	UIClosed ()

int	LogVPrintf (LV2_URID type, const char *fmt, va_list ap)

size_t	AddOption (LV2_URID, uint32_t size, LV2_URID, const void *value)

bool	ValidateOptions (const LilvNode *subject)

bool	CheckOptions (const LilvNode subject, const LilvNode predicate, bool required)

LV2_Feature *	AddFeature (const char uri, void data)

bool	ValidateFeatures (const LilvNode *subject)

bool	CheckFeatures (const LilvNode subject, const LilvNode predicate, bool required)

bool	BuildFancy ()

bool	BuildPlain ()

bool	TransferDataToWindow ()

bool	TransferDataFromWindow ()

void	SetSlider (const LV2ControlPortPtr &port)

void	OnTrigger (wxCommandEvent &evt)

void	OnToggle (wxCommandEvent &evt)

void	OnChoice (wxCommandEvent &evt)

void	OnText (wxCommandEvent &evt)

void	OnSlider (wxCommandEvent &evt)

void	OnTimer (wxTimerEvent &evt)

void	OnIdle (wxIdleEvent &evt)

void	OnSize (wxSizeEvent &evt)

void	OnSizeWindow (wxCommandEvent &evt)

void	SuilPortWrite (uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer)

uint32_t	SuilPortIndex (const char *port_symbol)

const void *	GetPortValue (const char port_symbol, uint32_t size, uint32_t *type)

void	SetPortValue (const char port_symbol, const void value, uint32_t size, uint32_t type)

Static Private Member Functions
static uint32_t	uri_to_id (LV2_URI_Map_Callback_Data callback_data, const char map, const char uri)

static LV2_URID	urid_map (LV2_URID_Map_Handle handle, const char *uri)

static LV2_URID	Lookup_URI (URIDMap &map, const char *uri, bool add=true)

static const char *	urid_unmap (LV2_URID_Unmap_Handle handle, LV2_URID urid)

static int	ui_resize (LV2UI_Feature_Handle handle, int width, int height)

static void	ui_closed (LV2UI_Controller controller)

static int	log_printf (LV2_Log_Handle handle, LV2_URID type, const char *fmt,...)

static int	log_vprintf (LV2_Log_Handle handle, LV2_URID type, const char *fmt, va_list ap)

static void	suil_port_write_func (SuilController controller, uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer)

static uint32_t	suil_port_index_func (SuilController controller, const char *port_symbol)

static const void *	get_value_func (const char port_symbol, void user_data, uint32_t size, uint32_t type)

static void	set_value_func (const char port_symbol, void user_data, const void *value, uint32_t size, uint32_t type)

Private Attributes
URIDMap	mURIDMap

URIDLIST const LilvPlugin *	mPlug

EffectHostInterface *	mHost

float	mSampleRate

int	mBlockSize

int	mSeqSize

int	mMinBlockSize

int	mMaxBlockSize

int	mUserBlockSize

std::unordered_map< uint32_t, LV2ControlPortPtr >	mControlPortMap

LV2ControlPortArray	mControlPorts

LV2AudioPortArray	mAudioPorts

unsigned	mAudioIn

unsigned	mAudioOut

LV2AtomPortArray	mAtomPorts

LV2AtomPortPtr	mControlIn

LV2AtomPortPtr	mControlOut

unsigned	mMidiIn

unsigned	mMidiOut

LV2CVPortArray	mCVPorts

unsigned	mCVIn

unsigned	mCVOut

std::unordered_map< wxString, std::vector< int > >	mGroupMap

wxArrayString	mGroups

bool	mWantsOptionsInterface

bool	mWantsStateInterface

bool	mWantsWorkerInterface

bool	mNoResize

bool	mUseLatency

int	mLatencyPort

bool	mLatencyDone

bool	mRolling

bool	mActivated

LV2Wrapper *	mMaster

LV2Wrapper *	mProcess

std::vector< LV2Wrapper * >	mSlaves

FloatBuffers	mMasterIn

FloatBuffers	mMasterOut

size_t	mNumSamples

size_t	mFramePos

FloatBuffers	mCVInBuffers

FloatBuffers	mCVOutBuffers

float	mPositionSpeed

float	mPositionFrame

double	mLength

wxTimer	mTimer

wxDialog *	mDialog

wxWindow *	mParent

EffectUIHostInterface *	mUIHost

bool	mUseGUI

LV2_URI_Map_Feature	mUriMapFeature

LV2_URID_Map	mURIDMapFeature

LV2_URID_Unmap	mURIDUnmapFeature

LV2UI_Resize	mUIResizeFeature

LV2_Log_Log	mLogFeature

LV2_Extension_Data_Feature	mExtensionDataFeature

LV2_External_UI_Host	mExternalUIHost

LV2_External_UI_Widget *	mExternalWidget

bool	mExternalUIClosed

LV2_Atom_Forge	mForge

std::vector< LV2_Options_Option >	mOptions

size_t	mBlockSizeOption

size_t	mSampleRateOption

bool	mSupportsNominalBlockLength

bool	mSupportsSampleRate

std::vector< std::unique_ptr< LV2_Feature > >	mFeatures

LV2_Feature *	mInstanceAccessFeature

LV2_Feature *	mParentFeature

LV2_Feature *	mWorkerScheduleFeature

bool	mFreewheeling

SuilHost *	mSuilHost

SuilInstance *	mSuilInstance

NativeWindow *	mNativeWin

wxSize	mNativeWinInitialSize

wxSize	mNativeWinLastSize

bool	mResizing

LV2UI_Idle_Interface *	mUIIdleInterface

LV2UI_Show_Interface *	mUIShowInterface

NumericTextCtrl *	mDuration

bool	mFactoryPresetsLoaded

RegistryPaths	mFactoryPresetNames

wxArrayString	mFactoryPresetUris

Static Private Attributes
static URIDMap	gURIDMap

Friends
class	LV2Wrapper

class	LV2EffectSettingsDialog

class	LV2EffectsModule

Additional Inherited Members
Public Types inherited from EffectClientInterface
using	EffectDialogFactory = std::function< wxDialog (wxWindow &parent, EffectHostInterface , EffectUIClientInterface *) >

Detailed Description

Definition at line 255 of file LV2Effect.h.

Constructor & Destructor Documentation

◆ LV2Effect()

LV2Effect::LV2Effect ( const LilvPlugin * plug )

Definition at line 363 of file LV2Effect.cpp.

 {
    mPlug = plug;
  
    mHost = NULL;
    mMaster = NULL;
    mProcess = NULL;
    mSuilInstance = NULL;
  
    mSampleRate = 44100;
    mBlockSize = DEFAULT_BLOCKSIZE;
    mSeqSize = DEFAULT_SEQSIZE;
  
    mMinBlockSize = 1;
    mMaxBlockSize = mBlockSize;
    mUserBlockSize = mBlockSize;
  
    mLatencyPort = -1;
    mLatencyDone = false;
    mRolling = false;
    mActivated = false;
  
    mDialog = NULL;
  
    mUIIdleInterface = NULL;
    mUIShowInterface = NULL;
  
    mAudioIn = 0;
    mAudioOut = 0;
    mMidiIn = 0;
    mMidiOut = 0;
  
    mControlIn.reset();
    mControlOut.reset();
  
    mPositionSpeed = 1.0;
    mPositionFrame = 0.0;
    
    mNativeWin = NULL;
    mNativeWinInitialSize = wxDefaultSize;
    mNativeWinLastSize = wxDefaultSize;
    mResizing = false;
 #if defined(__WXGTK__)
    mResized = false;
 #endif
  
    mExternalUIHost.plugin_human_id = NULL;
    mExternalWidget = NULL;
    mExternalUIClosed = false;
  
    mNoResize = false;
  
    mSupportsNominalBlockLength = false;
    mSupportsSampleRate = false;
  
    mFactoryPresetsLoaded = false;
 }

References DEFAULT_BLOCKSIZE, and DEFAULT_SEQSIZE.

◆ ~LV2Effect()

LV2Effect::~LV2Effect ( )

virtual

Definition at line 421 of file LV2Effect.cpp.

422 {

423 }

Member Function Documentation

◆ AddFeature()

LV2_Feature * LV2Effect::AddFeature	(	const char *	uri,
		void *	data
	)

private

Definition at line 1857 of file LV2Effect.cpp.

 {
    size_t ndx = mFeatures.size();
    mFeatures.resize(1 + ndx);
  
    if (uri)
    {
       mFeatures[ndx].reset(safenew LV2_Feature);
       mFeatures[ndx]->URI = uri;
       mFeatures[ndx]->data = data;
    }
  
    return mFeatures[ndx].get();
 }

References mFeatures, and safenew.

Referenced by LV2Wrapper::Instantiate(), and SetHost().

Here is the caller graph for this function:

◆ AddOption()

size_t LV2Effect::AddOption	(	LV2_URID	key,
		uint32_t	size,
		LV2_URID	type,
		const void *	value
	)

private

Definition at line 1837 of file LV2Effect.cpp.

 {
    int ndx = mOptions.size();
    mOptions.resize(1 + ndx);
  
    memset(&mOptions[ndx], 0, sizeof(mOptions[ndx]));
  
    if (key != 0)
    {
       mOptions[ndx].context = LV2_OPTIONS_INSTANCE;
       mOptions[ndx].subject = 0;
       mOptions[ndx].key = key;
       mOptions[ndx].size = size;
       mOptions[ndx].type = type;
       mOptions[ndx].value = value;
    }
  
    return ndx;
 }

References key, and mOptions.

Referenced by SetHost().

Here is the caller graph for this function:

◆ BuildFancy()

bool LV2Effect::BuildFancy ( )

private

Definition at line 2070 of file LV2Effect.cpp.

 {
    // Set the native UI type
    const char *nativeType =
 #if defined(__WXGTK3__)
       LV2_UI__Gtk3UI;
 #elif defined(__WXGTK__)
       LV2_UI__GtkUI;
 #elif defined(__WXMSW__)
       LV2_UI__WindowsUI;
 #elif defined(__WXMAC__)
       LV2_UI__CocoaUI;
 #endif
  
    // Determine if the plugin has a supported UI
    const LilvUI *ui = NULL;
    const LilvNode *uiType = NULL;
    LilvUIs *uis = lilv_plugin_get_uis(mPlug);
    if (uis)
    {
       LilvNode *containerType = lilv_new_uri(gWorld, nativeType);
       if (containerType)
       {
          LILV_FOREACH(uis, iter, uis)
          {
             ui = lilv_uis_get(uis, iter);
             if (lilv_ui_is_supported(ui, suil_ui_supported, containerType, &uiType))
             {
                break;
             }
             if (lilv_ui_is_a(ui, node_Gtk) || lilv_ui_is_a(ui, node_Gtk3))
             {
                uiType = node_Gtk;
                break;
             }
  
             ui = NULL;
          }
  
          lilv_node_free(containerType);
       }
    }
  
    // Check for other supported UIs
    if (ui == NULL)
    {
       LILV_FOREACH(uis, iter, uis)
       {
          ui = lilv_uis_get(uis, iter);
          if (lilv_ui_is_a(ui, node_ExternalUI) || lilv_ui_is_a(ui, node_ExternalUIOld))
          {
             uiType = node_ExternalUI;
             break;
          }
          ui = NULL;
       }
    }
  
    // No usable UI found
    if (ui == NULL)
    {
       lilv_uis_free(uis);
       return false;
    }
  
    const LilvNode *uinode = lilv_ui_get_uri(ui);
    lilv_world_load_resource(gWorld, uinode);
    if (!ValidateFeatures(uinode))
    {
       lilv_uis_free(uis);
       return false;
    }
  
    const char *containerType;
  
    if (uiType == node_ExternalUI)
    {
       containerType = LV2_EXTERNAL_UI__Widget;
    }
    else
    {
       containerType = nativeType;
       mParentFeature->data = mParent->GetHandle();
  
 #if defined(__WXGTK__)
       // Make sure the parent has a window
       if (!gtk_widget_get_window(GTK_WIDGET(mParent->m_wxwindow)))
       {
          gtk_widget_realize(GTK_WIDGET(mParent->m_wxwindow));
       }
 #endif
    }
  
    LilvInstance *instance = mMaster->GetInstance();
    mInstanceAccessFeature->data = lilv_instance_get_handle(instance);
    mExtensionDataFeature.data_access = lilv_instance_get_descriptor(instance)->extension_data;
  
    // Set before creating the UI instance so the initial size (if any) can be captured
    mNativeWinInitialSize = wxDefaultSize;
    mNativeWinLastSize = wxDefaultSize;
  
    // Create the suil host
    mSuilHost = suil_host_new(LV2Effect::suil_port_write_func,
                              LV2Effect::suil_port_index_func,
                              NULL,
                              NULL);
    if (!mSuilHost)
    {
       lilv_uis_free(uis);
       return false;
    }
  
 #if defined(__WXMSW__)
    // Plugins may have dependencies that need to be loaded from the same path
    // as the main DLL, so add this plugin's path to the DLL search order.
    char *libPath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)), NULL);
    wxString path = wxPathOnly(libPath);
    SetDllDirectory(path.c_str());
    lilv_free(libPath);
 #endif
  
    char *bundlePath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_bundle_uri(ui)), NULL);
    char *binaryPath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)), NULL);
  
    mSuilInstance = suil_instance_new(mSuilHost,
                                      this,
                                      containerType,
                                      lilv_node_as_uri(lilv_plugin_get_uri(mPlug)),
                                      lilv_node_as_uri(lilv_ui_get_uri(ui)),
                                      lilv_node_as_uri(uiType),
                                      bundlePath,
                                      binaryPath,
                                      reinterpret_cast<const LV2_Feature * const *>(mFeatures.data()));
  
    lilv_free(binaryPath);
    lilv_free(bundlePath);
    lilv_uis_free(uis);
  
    // Bail if the instance (no compatible UI) couldn't be created
    if (!mSuilInstance)
    {
 #if defined(__WXMSW__)
       SetDllDirectory(NULL);
 #endif
  
       suil_host_free(mSuilHost);
       mSuilHost = NULL;
  
       return false;
    }
  
    if (uiType == node_ExternalUI)
    {
       mParent->SetMinSize(wxDefaultSize);
  
       mExternalWidget = (LV2_External_UI_Widget *) suil_instance_get_widget(mSuilInstance);
       mTimer.SetOwner(this, ID_TIMER);
       mTimer.Start(20);
  
       LV2_EXTERNAL_UI_SHOW(mExternalWidget);
    }
    else
    {
       WXWidget widget = (WXWidget) suil_instance_get_widget(mSuilInstance);
  
 #if defined(__WXGTK__)
       // Needed by some plugins (e.g., Invada) to ensure the display is fully
       // populated.
       gtk_widget_show_all(widget);
  
       // See note at size_request()
       g_signal_connect(widget, "size-request", G_CALLBACK(LV2Effect::size_request), this);
 #endif
  
       Destroy_ptr< NativeWindow > uNativeWin{ safenew NativeWindow() };
       if ( !uNativeWin->Create(mParent, widget) )
          return false;
       mNativeWin = uNativeWin.release();
  
       mNativeWin->Bind(wxEVT_SIZE, &LV2Effect::OnSize, this);
  
       // The plugin called the LV2UI_Resize::ui_resize function to set the size before
       // the native window was created, so set the size now.
       if (mNativeWinInitialSize != wxDefaultSize)
       {
          mNativeWin->SetMinSize(mNativeWinInitialSize);
       }
  
       wxSizerItem *si = NULL;
       auto vs = std::make_unique<wxBoxSizer>(wxVERTICAL);
       if (vs)
       {
          auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
          if (hs)
          {
             if (mNoResize)
             {
                si = hs->Add(mNativeWin, 0, wxCENTER);
                vs->Add(hs.release(), 1, wxCENTER);
             }
             else
             {
                si = hs->Add(mNativeWin, 1, wxEXPAND);
                vs->Add(hs.release(), 1, wxEXPAND);
             }
          }
       }
  
       if (!si)
       {
          lilv_uis_free(uis);
          return false;
       }
  
       mParent->SetSizerAndFit(vs.release());
    }
  
    mUIIdleInterface = (LV2UI_Idle_Interface *)
       suil_instance_extension_data(mSuilInstance, LV2_UI__idleInterface);
  
    mUIShowInterface = (LV2UI_Show_Interface *)
       suil_instance_extension_data(mSuilInstance, LV2_UI__showInterface);
  
    if (mUIShowInterface)
    {
 //      mUIShowInterface->show(suil_instance_get_handle(mSuilInstance));
    }
  
    TransferDataToWindow();
  
 #ifdef __WXMAC__
 #ifdef __WX_EVTLOOP_BUSY_WAITING__
    wxEventLoop::SetBusyWaiting(true);
 #endif
 #endif
  
 #if defined(__WXMSW__)
    SetDllDirectory(NULL);
 #endif
  
    return true;
 }

References LV2Wrapper::GetInstance(), gWorld, ID_TIMER, LV2_EXTERNAL_UI__Widget, LV2_EXTERNAL_UI_SHOW, mExtensionDataFeature, mExternalWidget, mFeatures, mInstanceAccessFeature, mMaster, mNativeWin, mNativeWinInitialSize, mNativeWinLastSize, mNoResize, mParent, mParentFeature, mPlug, mSuilHost, mSuilInstance, mTimer, mUIIdleInterface, mUIShowInterface, OnSize(), safenew, suil_port_index_func(), suil_port_write_func(), TransferDataToWindow(), and ValidateFeatures().

Referenced by PopulateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ BuildPlain()

bool LV2Effect::BuildPlain ( )

private

Definition at line 2313 of file LV2Effect.cpp.

 {
    int numCols = 5;
    wxSizer *innerSizer;
  
    wxASSERT(mParent); // To justify safenew
    wxScrolledWindow *const w = safenew 
       wxScrolledWindow(mParent,
                        wxID_ANY,
                        wxDefaultPosition,
                        wxDefaultSize,
                        wxVSCROLL | wxTAB_TRAVERSAL);
  
    {
       auto outerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
       w->SetScrollRate(0, 20);
  
       // This fools NVDA into not saying "Panel" when the dialog gets focus
       w->SetName(wxT("\a"));
       w->SetLabel(wxT("\a"));
  
       outerSizer->Add(w, 1, wxEXPAND);
  
       {
          auto uInnerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
          innerSizer = uInnerSizer.get();
  
          if (GetType() == EffectTypeGenerate)
          {
             // Add the length control
             auto groupSizer = std::make_unique<wxStaticBoxSizer>(wxVERTICAL, w, _("Generator"));
  
             auto sizer = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
  
             wxWindow *item = safenew wxStaticText(w, 0, _("&Duration:"));
             sizer->Add(item, 0, wxALIGN_CENTER | wxALL, 5);
             mDuration = safenew
                NumericTextCtrl(w, ID_Duration,
                                NumericConverter::TIME,
                                mHost->GetDurationFormat(),
                                mHost->GetDuration(),
                                mSampleRate,
                                NumericTextCtrl::Options {}
             .AutoPos(true));
             mDuration->SetName( XO("Duration") );
             sizer->Add(mDuration, 0, wxALIGN_CENTER | wxALL, 5);
  
             groupSizer->Add(sizer.release(), 0, wxALIGN_CENTER | wxALL, 5);
             innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
          }
  
          std::sort(mGroups.begin(), mGroups.end());
  
          for (size_t i = 0, groupCount = mGroups.size(); i < groupCount; i++)
          {
             wxString label = mGroups[i];
             auto groupSizer = std::make_unique<wxStaticBoxSizer>(wxVERTICAL, w, label);
  
             auto gridSizer = std::make_unique<wxFlexGridSizer>(numCols, 5, 5);
             gridSizer->AddGrowableCol(3);
  
             for (auto & p : mGroupMap[mGroups[i]])
             {
                auto & port = mControlPorts[p];
  
                if (port->mNotOnGui)
                {
                   continue;
                }
  
                wxString labelText = port->mName;
                if (!port->mUnits.empty())
                {
                   labelText += wxT(" (") + port->mUnits + wxT(")");
                }
  
                if (port->mTrigger)
                {
                   gridSizer->Add(1, 1, 0);
  
                   wxASSERT(w); // To justify safenew
                   wxButton *b = safenew wxButton(w, ID_Triggers + p, labelText);
                   gridSizer->Add(b, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
                   port->mCtrl.button = b;
  
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                   continue;
                }
  
                wxWindow *item = safenew wxStaticText(w, wxID_ANY, labelText + wxT(":"),
                                                      wxDefaultPosition, wxDefaultSize,
                                                      wxALIGN_RIGHT);
                gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
  
                if (port->mToggle)
                {
                   wxCheckBox *c = safenew wxCheckBox(w, ID_Toggles + p, wxT(""));
                   c->SetName(labelText);
                   c->SetValue(port->mVal > 0);
                   gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
                   port->mCtrl.checkbox = c;
  
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                }
                else if (port->mEnumeration)      // Check before integer
                {
                   int s;
                   for (s = (int) port->mScaleValues.size() - 1; s >= 0; s--)
                   {
                      if (port->mVal >= port->mScaleValues[s])
                      {
                         break;
                      }
                   }
  
                   if (s < 0)
                   {
                      s = 0;
                   }
  
                   wxChoice *c = safenew wxChoice(w, ID_Choices + p);
                   c->SetName(labelText);
                   c->Append(port->mScaleLabels);
                   c->SetSelection(s);
                   gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
                   port->mCtrl.choice = c;
  
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
                }
                else if (!port->mIsInput)
                {
                   gridSizer->Add(1, 1, 0);
                   gridSizer->Add(1, 1, 0);
  
                   LV2EffectMeter *m = safenew LV2EffectMeter(w, port);
                   gridSizer->Add(m, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
                   port->mCtrl.meter = m;
  
                   gridSizer->Add(1, 1, 0);
                }
                else
                {
                   wxTextCtrl *t = safenew wxTextCtrl(w, ID_Texts + p, wxT(""));
                   t->SetName(labelText);
                   gridSizer->Add(t, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
                   port->mText = t;
  
                   float rate = port->mSampleRate ? mSampleRate : 1.0;
  
                   port->mLo = port->mMin * rate;
                   port->mHi = port->mMax * rate;
                   port->mTmp = port->mVal * rate;
  
                   if (port->mInteger)
                   {
                      IntegerValidator<float> vld(&port->mTmp);
                      vld.SetRange(port->mLo, port->mHi);
                      t->SetValidator(vld);
                   }
                   else
                   {
                      FloatingPointValidator<float> vld(6, &port->mTmp);
                      vld.SetRange(port->mLo, port->mHi);
  
                      // Set number of decimal places
                      float range = port->mHi - port->mLo;
                      auto style = range < 10
                                   ? NumValidatorStyle::THREE_TRAILING_ZEROES
                                   : range < 100
                                     ? NumValidatorStyle::TWO_TRAILING_ZEROES
                                     : NumValidatorStyle::ONE_TRAILING_ZERO;
                      vld.SetStyle(style);
  
                      t->SetValidator(vld);
                   }
  
                   if (port->mHasLo)
                   {
                      wxString str;
                      if (port->mInteger || port->mSampleRate)
                      {
                         str.Printf(wxT("%d"), (int) lrintf(port->mLo));
                      }
                      else
                      {
                         str = Internat::ToDisplayString(port->mLo);
                      }
                      item = safenew wxStaticText(w, wxID_ANY, str);
                      gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
                   }
                   else
                   {
                      gridSizer->Add(1, 1, 0);
                   }
  
                   wxSlider *s = safenew wxSliderWrapper(w, ID_Sliders + p,
                                                         0, 0, 1000,
                                                         wxDefaultPosition,
                                                         wxSize(150, -1));
                   s->SetName(labelText);
                   gridSizer->Add(s, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
                   port->mCtrl.slider = s;
  
                   if (port->mHasHi)
                   {
                      wxString str;
                      if (port->mInteger || port->mSampleRate)
                      {
                         str.Printf(wxT("%d"), (int) lrintf(port->mHi));
                      }
                      else
                      {
                         str = Internat::ToDisplayString(port->mHi);
                      }
                      item = safenew wxStaticText(w, wxID_ANY, str);
                      gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
                   }
                   else
                   {
                      gridSizer->Add(1, 1, 0);
                   }
                }
             }
  
             groupSizer->Add(gridSizer.release(), 1, wxEXPAND | wxALL, 5);
             innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
          }
  
          innerSizer->Layout();
  
          // Calculate the maximum width of all columns (bypass Generator sizer)
          std::vector<int> widths(numCols);
  
          size_t cnt = innerSizer->GetChildren().GetCount();
          for (size_t i = (GetType() == EffectTypeGenerate); i < cnt; i++)
          {
             wxSizer *groupSizer = innerSizer->GetItem(i)->GetSizer();
             wxFlexGridSizer *gridSizer = (wxFlexGridSizer *) groupSizer->GetItem((size_t) 0)->GetSizer();
  
             size_t items = gridSizer->GetChildren().GetCount();
             int cols = gridSizer->GetCols();
  
             for (size_t j = 0; j < items; j++)
             {
                wxSizerItem *item = gridSizer->GetItem(j);
                widths[j % cols] = wxMax(widths[j % cols], item->GetSize().GetWidth());
             }
          }
  
          // Set each column in all of the groups to the same width.
          for (size_t i = (GetType() == EffectTypeGenerate); i < cnt; i++)
          {
             wxSizer *groupSizer = innerSizer->GetItem(i)->GetSizer();
             wxFlexGridSizer *gridSizer = (wxFlexGridSizer *) groupSizer->GetItem((size_t) 0)->GetSizer();
  
             size_t items = gridSizer->GetChildren().GetCount();
             int cols = gridSizer->GetCols();
  
             for (size_t j = 0; j < items; j++)
             {
                wxSizerItem *item = gridSizer->GetItem(j);
  
                int flags = item->GetFlag();
                if (flags & wxEXPAND)
                {
                   continue;
                }
  
                if (flags & wxALIGN_RIGHT)
                {
                   flags = (flags & ~wxALL) | wxLEFT;
                }
                else
                {
                   flags = (flags & ~wxALL) | wxRIGHT;
                }
                item->SetFlag(flags);
  
                item->SetBorder(widths[j % cols] - item->GetMinSize().GetWidth());
             }
          }
  
          w->SetSizer(uInnerSizer.release());
       }
  
       mParent->SetSizer(outerSizer.release());
    }
  
    // Try to give the window a sensible default/minimum size
    wxSize sz1 = innerSizer->GetMinSize();
    wxSize sz2 = mParent->GetMinSize();
    w->SetMinSize( { -1, std::min(sz1.y, sz2.y) } );
  
    // And let the parent reduce to the NEW minimum if possible
    mParent->SetMinSize(w->GetMinSize());
  
    TransferDataToWindow();
  
    return true;
 }

References _, NumericTextCtrl::Options::AutoPos(), EffectTypeGenerate, EffectHostInterface::GetDuration(), EffectHostInterface::GetDurationFormat(), GetType(), ID_Choices, ID_Duration, ID_Sliders, ID_Texts, ID_Toggles, ID_Triggers, label, lrintf, mControlPorts, mDuration, mGroupMap, mGroups, mHost, min(), mParent, mSampleRate, safenew, NumericTextCtrl::SetName(), NumericConverter::TIME, Internat::ToDisplayString(), TransferDataToWindow(), and XO.

Referenced by PopulateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanExportPresets()

bool LV2Effect::CanExportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1768 of file LV2Effect.cpp.

 {
    return false;
 }

◆ CheckFeatures()

bool LV2Effect::CheckFeatures	(	const LilvNode *	subject,
		const LilvNode *	predicate,
		bool	required
	)

private

Definition at line 1882 of file LV2Effect.cpp.

 {
    bool supported = true;
  
    LilvNodes *nodes = lilv_world_find_nodes(gWorld, subject, predicate, NULL);
    if (nodes)
    {
       LILV_FOREACH(nodes, i, nodes)
       {
          const LilvNode *node = lilv_nodes_get(nodes, i);
          const char *uri = lilv_node_as_string(node);
  
          if ((strcmp(uri, LV2_UI__noUserResize) == 0) ||
              (strcmp(uri, LV2_UI__fixedSize) == 0))
          {
             mNoResize = true;
          }
          else if (strcmp(uri, LV2_WORKER__schedule) == 0)
          {
             /* Supported but handled in LV2Wrapper */
          }
          else
          {
             supported = false;
  
             for (auto & feature : mFeatures)
             {
                if (feature && strcmp(feature->URI, uri) == 0)
                {
                   supported = true;
                   break;
                }
             }
  
             if (!supported)
             {
                if (required)
                {
                   wxLogError(wxT("%s requires unsupported feature %s"), lilv_node_as_string(lilv_plugin_get_uri(mPlug)), uri);
                   printf(_("%s requires unsupported feature %s\n"), lilv_node_as_string(lilv_plugin_get_uri(mPlug)), uri);
                   break;
                }
                supported = true;
             }
          }
       }
  
       lilv_nodes_free(nodes);
    }
  
  
    return supported;
 }

References _, gWorld, mFeatures, mNoResize, and mPlug.

Referenced by ValidateFeatures().

Here is the caller graph for this function:

◆ CheckOptions()

bool LV2Effect::CheckOptions	(	const LilvNode *	subject,
		const LilvNode *	predicate,
		bool	required
	)

private

Definition at line 1946 of file LV2Effect.cpp.

 {
    bool supported = true;
  
    LilvNodes *nodes = lilv_world_find_nodes(gWorld, subject, predicate, NULL);
    if (nodes)
    {
       LILV_FOREACH(nodes, i, nodes)
       {
          const LilvNode *node = lilv_nodes_get(nodes, i);
          const char *uri = lilv_node_as_string(node);
          LV2_URID urid = URID_Map(uri);
  
          if (urid == urid_NominalBlockLength)
          {
             mSupportsNominalBlockLength = true;
          }
          else if (urid == urid_SampleRate)
          {
             mSupportsSampleRate = true;
          }
          else
          {
             supported = false;
  
             for (auto & option : mOptions)
             {
                if (option.key == urid)
                {
                   supported = true;
                   break;
                }
             }
  
             if (!supported)
             {
                if (required)
                {
                   wxLogError(wxT("%s requires unsupported option %s"), lilv_node_as_string(lilv_plugin_get_uri(mPlug)), uri);
                   printf(_("%s requires unsupported option %s\n"), lilv_node_as_string(lilv_plugin_get_uri(mPlug)), uri);
                   break;
                }
                supported = true;
             }
          }
       }
  
       lilv_nodes_free(nodes);
    }
  
    return supported;
 }

References _, gWorld, mOptions, mPlug, mSupportsNominalBlockLength, mSupportsSampleRate, and URID_Map().

Referenced by ValidateOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CloseUI()

bool LV2Effect::CloseUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1629 of file LV2Effect.cpp.

 {
 #ifdef __WXMAC__
 #ifdef __WX_EVTLOOP_BUSY_WAITING__
    wxEventLoop::SetBusyWaiting(false);
 #endif
 #endif
  
    mParent->RemoveEventHandler(this);
  
    if (mSuilInstance)
    {
       if (mNativeWin)
       {
          mNativeWin->Destroy();
          mNativeWin = NULL;
       }
  
       mUIIdleInterface = NULL;
       mUIShowInterface = NULL;
       mExternalWidget = NULL;
  
       suil_instance_free(mSuilInstance);
       mSuilInstance = NULL;
    }
  
    if (mSuilHost)
    {
       suil_host_free(mSuilHost);
       mSuilHost = NULL;
    }
  
    if (mMaster)
    {
       FreeInstance(mMaster);
       mMaster = NULL;
    }
  
    mUIHost = NULL;
    mParent = NULL;
    mDialog = NULL;
  
    return true;
 }

References FreeInstance(), mDialog, mExternalWidget, mMaster, mNativeWin, mParent, mSuilHost, mSuilInstance, mUIHost, mUIIdleInterface, and mUIShowInterface.

Here is the call graph for this function:

◆ ExportPresets()

void LV2Effect::ExportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1773 of file LV2Effect.cpp.

1774 {

1775 }

◆ FreeInstance()

void LV2Effect::FreeInstance ( LV2Wrapper * wrapper )

private

Definition at line 2065 of file LV2Effect.cpp.

 {
    delete wrapper;
 }

Referenced by CloseUI(), ProcessFinalize(), and RealtimeFinalize().

Here is the caller graph for this function:

◆ get_value_func()

const void * LV2Effect::get_value_func	(	const char *	port_symbol,
		void *	user_data,
		uint32_t *	size,
		uint32_t *	type
	)

staticprivate

Definition at line 3165 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) user_data)->GetPortValue(port_symbol, size, type);
 }

◆ GetAudioInCount()

unsigned LV2Effect::GetAudioInCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 958 of file LV2Effect.cpp.

 {
    return mAudioIn;
 }

References mAudioIn.

Referenced by GetType().

Here is the caller graph for this function:

◆ GetAudioOutCount()

unsigned LV2Effect::GetAudioOutCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 963 of file LV2Effect.cpp.

 {
    return mAudioOut;
 }

References mAudioOut.

Referenced by GetType().

Here is the caller graph for this function:

◆ GetAutomationParameters()

bool LV2Effect::GetAutomationParameters ( CommandParameters & parms )

overridevirtual

Implements EffectClientInterface.

Definition at line 1493 of file LV2Effect.cpp.

 {
    for (auto & port : mControlPorts)
    {
       if (port->mIsInput)
       {
          if (!parms.Write(port->mName, port->mVal))
          {
             return false;
          }
       }
    }
  
    return true;
 }

References mControlPorts.

Referenced by SaveParameters().

Here is the caller graph for this function:

◆ GetBlockSize()

size_t LV2Effect::GetBlockSize ( ) const

overridevirtual

Implements EffectClientInterface.

Definition at line 1019 of file LV2Effect.cpp.

 {
    return mBlockSize;
 }

References mBlockSize.

◆ GetDescription()

TranslatableString LV2Effect::GetDescription ( )

overridevirtual

Implements ComponentInterface.

Definition at line 456 of file LV2Effect.cpp.

 {
    return XO("n/a");
 }

References XO.

◆ GetFactoryPresets()

RegistryPaths LV2Effect::GetFactoryPresets ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1689 of file LV2Effect.cpp.

 {
    if (mFactoryPresetsLoaded)
    {
       return mFactoryPresetNames;
    }
  
    LilvNodes *presets = lilv_plugin_get_related(mPlug, node_Preset);
    if (presets)
    {
       LILV_FOREACH(nodes, i, presets)
       {
          const LilvNode *preset = lilv_nodes_get(presets, i);
  
          mFactoryPresetUris.push_back(LilvString(preset));
  
          lilv_world_load_resource(gWorld, preset);
  
          LilvNodes *labels = lilv_world_find_nodes(gWorld, preset, node_Label, NULL);
          if (labels)
          {
             const LilvNode *label = lilv_nodes_get_first(labels);
  
             mFactoryPresetNames.push_back(LilvString(label));
  
             lilv_nodes_free(labels);
          }
          else
          {
             mFactoryPresetNames.push_back(LilvString(preset).AfterLast(wxT('#')));
          }
       }
  
       lilv_nodes_free(presets);
    }
  
    mFactoryPresetsLoaded = true;
  
    return mFactoryPresetNames;
 }

References gWorld, label, LilvString(), mFactoryPresetNames, mFactoryPresetsLoaded, mFactoryPresetUris, and mPlug.

Here is the call graph for this function:

◆ GetFamily()

EffectFamilySymbol LV2Effect::GetFamily ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 485 of file LV2Effect.cpp.

 {
    return LV2EFFECTS_FAMILY;
 }

References LV2EFFECTS_FAMILY.

◆ GetLatency()

sampleCount LV2Effect::GetLatency ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1024 of file LV2Effect.cpp.

 {
    if (mUseLatency && mLatencyPort >= 0 && !mLatencyDone)
    {
       mLatencyDone = true;
       return sampleCount(mMaster->GetLatency());
    }
  
    return 0;
 }

References LV2Wrapper::GetLatency(), mLatencyDone, mLatencyPort, mMaster, and mUseLatency.

Here is the call graph for this function:

◆ GetMidiInCount()

int LV2Effect::GetMidiInCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 968 of file LV2Effect.cpp.

 {
    return mMidiIn;
 }

References mMidiIn.

◆ GetMidiOutCount()

int LV2Effect::GetMidiOutCount ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 973 of file LV2Effect.cpp.

 {
    return mMidiOut;
 }

References mMidiOut.

◆ GetPath()

PluginPath LV2Effect::GetPath ( )

overridevirtual

Implements ComponentInterface.

Definition at line 429 of file LV2Effect.cpp.

 {
    return LilvString(lilv_plugin_get_uri(mPlug));
 }

References LilvString(), and mPlug.

Here is the call graph for this function:

◆ GetPortValue()

const void * LV2Effect::GetPortValue	(	const char *	port_symbol,
		uint32_t *	size,
		uint32_t *	type
	)

private

Definition at line 3173 of file LV2Effect.cpp.

 {
    wxString symbol = wxString::FromUTF8(port_symbol);
  
    for (auto & port : mControlPorts)
    {
       if (port->mSymbol == symbol)
       {
          *size = sizeof(float);
          *type = urid_Float;
          return (void *) &port->mVal;
       }
    }
  
    *size = 0;
    *type = 0;
  
    return NULL;
 }

References mControlPorts.

◆ GetSymbol()

ComponentInterfaceSymbol LV2Effect::GetSymbol ( )

overridevirtual

Implements ComponentInterface.

Definition at line 434 of file LV2Effect.cpp.

 {
    return LilvString(lilv_plugin_get_name(mPlug), true);
 }

References LilvString(), and mPlug.

Referenced by LogVPrintf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTailSize()

size_t LV2Effect::GetTailSize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1035 of file LV2Effect.cpp.

 {
    return 0;
 }

◆ GetType()

EffectType LV2Effect::GetType ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 465 of file LV2Effect.cpp.

 {
    if (GetAudioInCount() == 0 && GetAudioOutCount() == 0)
    {
       return EffectTypeTool;
    }
  
    if (GetAudioInCount() == 0)
    {
       return EffectTypeGenerate;
    }
  
    if (GetAudioOutCount() == 0)
    {
       return EffectTypeAnalyze;
    }
  
    return EffectTypeProcess;
 }

References EffectTypeAnalyze, EffectTypeGenerate, EffectTypeProcess, EffectTypeTool, GetAudioInCount(), and GetAudioOutCount().

Referenced by BuildPlain(), PopulateUI(), ShowInterface(), SupportsRealtime(), and ValidateUI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetVendor()

VendorSymbol LV2Effect::GetVendor ( )

overridevirtual

Implements ComponentInterface.

Definition at line 439 of file LV2Effect.cpp.

 {
    wxString vendor = LilvString(lilv_plugin_get_author_name(mPlug), true);
  
    if (vendor.empty())
    {
       return XO("n/a");
    }
  
    return {vendor};
 }

References LilvString(), mPlug, and XO.

Here is the call graph for this function:

◆ GetVersion()

wxString LV2Effect::GetVersion ( )

overridevirtual

Implements ComponentInterface.

Definition at line 451 of file LV2Effect.cpp.

 {
    return wxT("1.0");
 }

◆ HasOptions()

bool LV2Effect::HasOptions ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1781 of file LV2Effect.cpp.

 {
    return true;
 }

◆ HideUI()

bool LV2Effect::HideUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1621 of file LV2Effect.cpp.

 {
 #if 0
    // Nothing to do yet
 #endif
    return true;
 }

◆ ImportPresets()

void LV2Effect::ImportPresets ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1777 of file LV2Effect.cpp.

1778 {

1779 }

◆ InitInstance()

LV2Wrapper * LV2Effect::InitInstance ( float sampleRate )

private

Definition at line 1999 of file LV2Effect.cpp.

 {
    LV2Wrapper *wrapper = new LV2Wrapper(this);
    if (wrapper == NULL)
    {
       return NULL;
    }
    
    LilvInstance *instance = wrapper->Instantiate(mPlug, sampleRate, mFeatures);
    if (!instance)
    {
       delete wrapper;
       return NULL;
    }
  
    wrapper->SetBlockSize();
    wrapper->SetSampleRate();
  
    // Connect all control ports
    for (auto & port : mControlPorts)
    {
       // If it's not an input port and master has already been created
       // then connect the port to a dummy field since slave output port
       // values are unwanted as the master values will be used.
       //
       // Otherwise, connect it to the real value field.
       lilv_instance_connect_port(instance,
                                  port->mIndex,
                                  !port->mIsInput && mMaster
                                  ? &port->mDmy
                                  : &port->mVal);
    }
  
    // Connect all atom ports
    for (auto & port : mAtomPorts)
    {
       lilv_instance_connect_port(instance, port->mIndex, port->mBuffer.data());
    }
  
    // We don't fully support CV ports, so connect them to dummy buffers for now.
    for (auto & port : mCVPorts)
    {
       lilv_instance_connect_port(instance, port->mIndex, port->mBuffer.get());
    }
  
    // Give plugin a chance to initialize.  The SWH plugins (like AllPass) need
    // this before it can be safely deleted.
    lilv_instance_activate(instance);
    lilv_instance_deactivate(instance);
  
    for (auto & port : mAtomPorts)
    {
       if (!port->mIsInput)
       {
          ZixRing *ring = port->mRing;
  
          LV2_ATOM_SEQUENCE_FOREACH(( LV2_Atom_Sequence *) port->mBuffer.data(), ev)
          {
             zix_ring_write(ring, &ev->body, ev->body.size + sizeof(LV2_Atom));
          }
       }
    }
  
    return wrapper;
 }

References LV2Wrapper::Instantiate(), LV2Wrapper, mAtomPorts, mControlPorts, mCVPorts, mFeatures, mMaster, mPlug, LV2Wrapper::SetBlockSize(), LV2Wrapper::SetSampleRate(), ZixRingImpl::size, and zix_ring_write().

Referenced by PopulateUI(), ProcessInitialize(), and RealtimeAddProcessor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsDefault()

bool LV2Effect::IsDefault ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 495 of file LV2Effect.cpp.

 {
    return false;
 }

◆ IsGraphicalUI()

bool LV2Effect::IsGraphicalUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1601 of file LV2Effect.cpp.

 {
    return mUseGUI;
 }

References mUseGUI.

◆ IsInteractive()

bool LV2Effect::IsInteractive ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 490 of file LV2Effect.cpp.

 {
    return mControlPorts.size() != 0;
 }

References mControlPorts.

◆ IsLegacy()

bool LV2Effect::IsLegacy ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 500 of file LV2Effect.cpp.

 {
    return false;
 }

◆ IsReady()

bool LV2Effect::IsReady ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1040 of file LV2Effect.cpp.

 {
    return mMaster != NULL;
 }

References mMaster.

◆ LoadFactoryDefaults()

bool LV2Effect::LoadFactoryDefaults ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1758 of file LV2Effect.cpp.

 {
    if (!LoadParameters(mHost->GetFactoryDefaultsGroup()))
    {
       return false;
    }
  
    return TransferDataToWindow();
 }

References EffectHostInterface::GetFactoryDefaultsGroup(), LoadParameters(), mHost, and TransferDataToWindow().

Here is the call graph for this function:

◆ LoadFactoryPreset()

bool LV2Effect::LoadFactoryPreset ( int id )

overridevirtual

Implements EffectClientInterface.

Definition at line 1730 of file LV2Effect.cpp.

 {
    if (id < 0 || id >= (int) mFactoryPresetUris.size())
    {
       return false;
    }
  
    LilvNode *preset = lilv_new_uri(gWorld, mFactoryPresetUris[id].ToUTF8());
    if (!preset)
    {
       return false;
    }
  
    LilvState *state = lilv_state_new_from_world(gWorld, &mURIDMapFeature, preset);
    if (state)
    {
       lilv_state_restore(state, mMaster->GetInstance(), set_value_func, this, 0, NULL);
  
       lilv_state_free(state);
  
       TransferDataToWindow();
    }
  
    lilv_node_free(preset);
  
    return state != NULL;
 }

References LV2Wrapper::GetInstance(), gWorld, mFactoryPresetUris, mMaster, mURIDMapFeature, set_value_func(), audacity::ToUTF8(), and TransferDataToWindow().

Here is the call graph for this function:

◆ LoadParameters()

bool LV2Effect::LoadParameters ( const RegistryPath & group )

private

Definition at line 1803 of file LV2Effect.cpp.

 {
    wxString parms;
    if (!mHost->GetPrivateConfig(group, wxT("Parameters"), parms, wxEmptyString))
    {
       return false;
    }
  
    CommandParameters eap;
    if (!eap.SetParameters(parms))
    {
       return false;
    }
  
    return SetAutomationParameters(eap);
 }

References ConfigClientInterface::GetPrivateConfig(), mHost, SetAutomationParameters(), and CommandParameters::SetParameters().

Referenced by LoadFactoryDefaults(), LoadUserPreset(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LoadUserPreset()

bool LV2Effect::LoadUserPreset ( const RegistryPath & name )

overridevirtual

Implements EffectClientInterface.

Definition at line 1674 of file LV2Effect.cpp.

 {
    if (!LoadParameters(name))
    {
       return false;
    }
  
    return TransferDataToWindow();
 }

References LoadParameters(), name, and TransferDataToWindow().

Here is the call graph for this function:

◆ log_printf()

int LV2Effect::log_printf	(	LV2_Log_Handle	handle,
		LV2_URID	type,
		const char *	fmt,
			...
	)

staticprivate

Definition at line 3009 of file LV2Effect.cpp.

 {
    va_list ap;
    int len;
  
    va_start(ap, fmt);
    len = ((LV2Effect *) handle)->LogVPrintf(type, fmt, ap);
    va_end(ap);
  
    return len;
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ log_vprintf()

int LV2Effect::log_vprintf	(	LV2_Log_Handle	handle,
		LV2_URID	type,
		const char *	fmt,
		va_list	ap
	)

staticprivate

Definition at line 3022 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) handle)->LogVPrintf(type, fmt, ap);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ LogVPrintf()

int LV2Effect::LogVPrintf	(	LV2_URID	type,
		const char *	fmt,
		va_list	ap
	)

private

Definition at line 3027 of file LV2Effect.cpp.

 {
    long level = wxLOG_Error;
  
    if (type == urid_Error)
    {
       level = wxLOG_Error;
    }
    else if (type == urid_Note)
    {
       level = wxLOG_Info;
    }
    else if (type == urid_Trace)
    {
       level = wxLOG_Trace;
    }
    else if (type == urid_Warning)
    {
       level = wxLOG_Warning;
    }
    else
    {
       level = wxLOG_Message;
    }
  
    char *msg = NULL;
    int len = wxCRT_VsnprintfA(msg, 0, fmt, ap);
  
    msg = (char *) malloc(len + 1);
    if (msg)
    {
       wxCRT_VsnprintfA(msg, len, fmt, ap);
  
       wxString text(msg);
  
       wxLogGeneric(level, wxT("%s: %s"), GetSymbol().Msgid().Translation(), text);
  
       free(msg);
    }
  
    return len;
 }

References GetSymbol().

Here is the call graph for this function:

◆ Lookup_URI()

LV2_URID LV2Effect::Lookup_URI	(	URIDMap &	map,
		const char *	uri,
		bool	add = `true`
	)

staticprivate

Definition at line 2961 of file LV2Effect.cpp.

 {
    size_t ndx = map.size();
    for (size_t i = 0; i < ndx; i++)
    {
       if (strcmp(map[i].get(), uri) == 0)
       {
          return i + 1;
       }
    }
  
    if (add)
    {
       // Almost all compilers have strdup(), but VC++ and MinGW call it _strdup().
       map.push_back(MallocString<>(wxCRT_StrdupA(uri)));
       return ndx + 1;
    }
  
    return 0;
 }

Referenced by URID_Map().

Here is the caller graph for this function:

◆ OnChoice()

void LV2Effect::OnChoice ( wxCommandEvent & evt )

private

Definition at line 2732 of file LV2Effect.cpp.

 {
    auto & port = mControlPorts[evt.GetId() - ID_Choices];
  
    port->mVal = port->mScaleValues[evt.GetInt()];
 }

References ID_Choices, and mControlPorts.

◆ OnIdle()

void LV2Effect::OnIdle ( wxIdleEvent & evt )

private

Definition at line 2785 of file LV2Effect.cpp.

 {
    evt.Skip();
  
    if (!mSuilInstance)
    {
       return;
    }
  
    if (mExternalUIClosed)
    {
       mExternalUIClosed = false;
       mDialog->Close();
       return;
    }
  
    if (mUIIdleInterface)
    {
       SuilHandle handle = suil_instance_get_handle(mSuilInstance);
       if (mUIIdleInterface->idle(handle))
       {
          if (mUIShowInterface)
          {
             mUIShowInterface->hide(handle);
          }
          mDialog->Close();
          return;
       }
    }
  
    if (mControlOut)
    {
       ZixRing *ring = mControlOut->mRing;
  
       LV2_Atom *atom = (LV2_Atom *) malloc(mControlOut->mMinimumSize);
       if (atom)
       {
          while (zix_ring_read(ring, atom, sizeof(LV2_Atom)))
          {
             uint32_t size = lv2_atom_total_size(atom);
  
             if (size < mControlOut->mMinimumSize)
             {
                zix_ring_read(ring, LV2_ATOM_CONTENTS(LV2_Atom, atom), atom->size);
                suil_instance_port_event(mSuilInstance,
                                         mControlOut->mIndex,
                                         size,
                                         urid_EventTransfer,
                                         atom);
             }
             else
             {
                zix_ring_skip(ring, atom->size);
                wxLogError(wxT("LV2 sequence buffer overflow"));
             }
          }
          free(atom);
       }
    }
  
    for (auto & port : mControlPorts)
    {
       // Let UI know that a port's value has changed
       if (port->mVal != port->mLst)
       {
          suil_instance_port_event(mSuilInstance,
                                   port->mIndex,
                                   sizeof(port->mVal),
                                   0,
                                   &port->mVal);
          port->mLst = port->mVal;
       }
    }
 }

References mControlOut, mControlPorts, mDialog, mExternalUIClosed, mSuilInstance, mUIIdleInterface, mUIShowInterface, ZixRingImpl::size, zix_ring_read(), and zix_ring_skip().

Here is the call graph for this function:

◆ OnSize()

void LV2Effect::OnSize ( wxSizeEvent & evt )

private

Definition at line 2860 of file LV2Effect.cpp.

 {
    evt.Skip();
  
    // Don't do anything here if we're recursing
    if (mResizing)
    {
       return;
    }
  
    // Indicate resizing is occurring
    mResizing = true;
  
    // Can only resize AFTER the dialog has been completely created and
    // there's no need to resize if we're already at the desired size.
    if (mDialog && evt.GetSize() != mNativeWinLastSize)
    {
       // Save the desired size and set the native window to match
       mNativeWinLastSize = evt.GetSize();
       mNativeWin->SetMinSize(mNativeWinLastSize);
  
       // Clear the minimum size of the parent window to allow the following
       // Fit() to make proper adjustments
       mParent->SetMinSize(wxDefaultSize);
  
 #if defined(__WXGTK__)
       // If the user resized the native window, then we need to also
       // clear the dialogs minimum size.  If this isn't done, the dialog
       // will not resize properly when going from a larger size to a smaller
       // size (due to the minimum size constraint).
       //
       // In this case, mResized has been set by the "size_request()" function
       // to indicate that this is a plugin generated resize request.
       if (mResized)
       {
         mDialog->SetMinSize(wxDefaultSize);
       }
  
       // Resize dialog
       mDialog->Fit();
  
       // Reestablish the minimum (and maximum) now that the dialog
       // has is desired size.
       if (mResized)
       {
          mDialog->SetMinSize(mDialog->GetSize());
          if (mNoResize)
          {
             mDialog->SetMaxSize(mDialog->GetSize());
          }
       }
  
       // Tell size_request() that the native window was just resized.
       mResized = true;
 #else
       // Resize the dialog to fit its content.
       mDialog->Fit();
 #endif
    }
  
    // No longer resizing
    mResizing = false;
 }

References mDialog, mNativeWin, mNativeWinLastSize, mNoResize, mParent, and mResizing.

Referenced by BuildFancy().

Here is the caller graph for this function:

◆ OnSizeWindow()

void LV2Effect::OnSizeWindow ( wxCommandEvent & evt )

private

◆ OnSlider()

void LV2Effect::OnSlider ( wxCommandEvent & evt )

private

Definition at line 2751 of file LV2Effect.cpp.

 {
    auto & port = mControlPorts[evt.GetId() - ID_Sliders];
  
    float lo = port->mLo;
    float hi = port->mHi;
  
    if (port->mLogarithmic)
    {
       lo = logf(lo);
       hi = logf(hi);
    }
  
    port->mTmp = (((float) evt.GetInt()) / 1000.0) * (hi - lo) + lo;
    port->mTmp = port->mLogarithmic ? expf(port->mTmp) : port->mTmp;
  
    port->mTmp = port->mTmp < port->mLo ? port->mLo : port->mTmp;
    port->mTmp = port->mTmp > port->mHi ? port->mHi : port->mTmp;
  
    port->mVal = port->mSampleRate ? port->mTmp / mSampleRate : port->mTmp;
  
    port->mText->GetValidator()->TransferToWindow();
 }

References ID_Sliders, mControlPorts, and mSampleRate.

◆ OnText()

void LV2Effect::OnText ( wxCommandEvent & evt )

private

Definition at line 2739 of file LV2Effect.cpp.

 {
    auto & port = mControlPorts[evt.GetId() - ID_Texts];
  
    if (port->mText->GetValidator()->TransferFromWindow())
    {
       port->mVal = port->mSampleRate ? port->mTmp / mSampleRate : port->mTmp;
  
       SetSlider(port);
    }
 }

References ID_Texts, mControlPorts, mSampleRate, and SetSlider().

Here is the call graph for this function:

◆ OnTimer()

void LV2Effect::OnTimer ( wxTimerEvent & evt )

private

Definition at line 2775 of file LV2Effect.cpp.

 {
    evt.Skip();
  
    if (mExternalWidget)
    {
       LV2_EXTERNAL_UI_RUN(mExternalWidget);
    }
 }

References LV2_EXTERNAL_UI_RUN, and mExternalWidget.

◆ OnToggle()

void LV2Effect::OnToggle ( wxCommandEvent & evt )

private

Definition at line 2725 of file LV2Effect.cpp.

 {
    auto & port = mControlPorts[evt.GetId() - ID_Toggles];
  
    port->mVal = evt.GetInt() ? 1.0 : 0.0;
 }

References ID_Toggles, and mControlPorts.

◆ OnTrigger()

void LV2Effect::OnTrigger ( wxCommandEvent & evt )

private

Definition at line 2718 of file LV2Effect.cpp.

 {
    auto & port = mControlPorts[evt.GetId() - ID_Triggers];
  
    port->mVal = port->mDef;
 }

References ID_Triggers, and mControlPorts.

◆ PopulateUI()

bool LV2Effect::PopulateUI ( ShuttleGui & S )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1558 of file LV2Effect.cpp.

 {
    auto parent = S.GetParent();
    mParent = parent;
  
    mParent->PushEventHandler(this);
  
    mSuilHost = NULL;
    mSuilInstance = NULL;
  
    mMaster = InitInstance(mSampleRate);
    if (mMaster == NULL)
    {
       AudacityMessageBox( XO("Couldn't instantiate effect") );
       return false;
    }
  
    // Determine if the GUI editor is supposed to be used or not
    mHost->GetSharedConfig(wxT("Settings"),
                           wxT("UseGUI"),
                           mUseGUI,
                           true);
  
    // Until I figure out where to put the "Duration" control in the
    // graphical editor, force usage of plain editor.
    if (GetType() == EffectTypeGenerate)
    {
       mUseGUI = false;
    }
  
    if (mUseGUI)
    {
       mUseGUI = BuildFancy();
    }
  
    if (!mUseGUI)
    {
       return BuildPlain();
    }
  
    return true;
 }

References AudacityMessageBox(), BuildFancy(), BuildPlain(), EffectTypeGenerate, ShuttleGuiBase::GetParent(), ConfigClientInterface::GetSharedConfig(), GetType(), InitInstance(), mHost, mMaster, mParent, mSampleRate, mSuilHost, mSuilInstance, mUseGUI, and XO.

Here is the call graph for this function:

◆ ProcessBlock()

size_t LV2Effect::ProcessBlock	(	float **	inbuf,
		float **	outbuf,
		size_t	size
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1077 of file LV2Effect.cpp.

 {
    wxASSERT(size <= ( size_t) mBlockSize);
  
    LilvInstance *instance = mProcess->GetInstance();
  
    int i = 0;
    int o = 0;
    for (auto & port : mAudioPorts)
    {
       lilv_instance_connect_port(instance,
                                  port->mIndex,
                                  (port->mIsInput ? inbuf[i++] : outbuf[o++]));
    }
  
    // Transfer incoming events from the ring buffer to the event buffer for each
    // atom input port.  These will be made available to each slave in the chain and
    // to the master once all slaves have run.
    //
    // In addition, reset the output Atom ports.
    for (auto & port : mAtomPorts)
    {
       uint8_t *buf = port->mBuffer.data();
  
       if (port->mIsInput)
       {
          lv2_atom_forge_set_buffer(&mForge,
                                    buf,
                                    port->mBuffer.size());
  
          LV2_Atom_Forge_Frame seqFrame;
          LV2_Atom_Sequence *seq = ( LV2_Atom_Sequence *)
             lv2_atom_forge_sequence_head(&mForge, &seqFrame, 0);
  
          if (port->mWantsPosition)
          {
             lv2_atom_forge_frame_time(&mForge, mPositionFrame);
  
             LV2_Atom_Forge_Frame posFrame;
             lv2_atom_forge_object(&mForge, &posFrame, 0, urid_Position);
             lv2_atom_forge_key(&mForge, urid_Speed);
             lv2_atom_forge_float(&mForge, mPositionSpeed);
             lv2_atom_forge_key(&mForge, urid_Frame);
             lv2_atom_forge_long(&mForge, mPositionFrame);
             lv2_atom_forge_pop(&mForge, &posFrame);
          }
  
          ZixRing *ring = port->mRing;
          LV2_Atom atom;
          while (zix_ring_read(ring, &atom, sizeof(atom)))
          {
             if (mForge.offset + sizeof(LV2_Atom_Event) + atom.size < mForge.size)
             {
                lv2_atom_forge_frame_time(&mForge, mPositionFrame);
  
                lv2_atom_forge_write(&mForge, &atom, sizeof(atom));
                zix_ring_read(ring, &mForge.buf[mForge.offset], atom.size);
                mForge.offset += atom.size;
                seq->atom.size += atom.size;
             }
             else
             {
                zix_ring_skip(ring, atom.size);
                wxLogError(wxT("LV2 sequence buffer overflow"));
             }
          }
  
          lv2_atom_forge_pop(&mForge, &seqFrame);
       }
       else
       {
          port->mBuffer.resize(port->mMinimumSize);
          *(( LV2_Atom *) buf) =
          {
             port->mMinimumSize,
             urid_Chunk
          };
       }
    }
  
    lilv_instance_run(instance, size);
  
    mProcess->SendResponses();
  
    for (auto & port : mAtomPorts)
    {
       if (!port->mIsInput)
       {
          port->mBuffer.resize(port->mMinimumSize);
  
          LV2_Atom *chunk = ( LV2_Atom *) port->mBuffer.data();
          chunk->size = port->mMinimumSize;
          chunk->type = urid_Chunk;
       }
    }
  
    return size;
 }

References LV2Wrapper::GetInstance(), mAtomPorts, mAudioPorts, mBlockSize, mForge, mPositionFrame, mPositionSpeed, mProcess, LV2Wrapper::SendResponses(), ZixRingImpl::size, zix_ring_read(), and zix_ring_skip().

Here is the call graph for this function:

◆ ProcessFinalize()

bool LV2Effect::ProcessFinalize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1066 of file LV2Effect.cpp.

 {
    if (mProcess)
    {
       FreeInstance(mProcess);
       mProcess = NULL;
    }
  
    return true;
 }

References FreeInstance(), and mProcess.

Here is the call graph for this function:

◆ ProcessInitialize()

bool LV2Effect::ProcessInitialize	(	sampleCount	totalLen,
		ChannelNames	chanMap = `NULL`
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1045 of file LV2Effect.cpp.

 {
    mProcess = InitInstance(mSampleRate);
    if (!mProcess)
    {
       return false;
    }
  
    for (auto & port : mCVPorts)
    {
       port->mBuffer.reinit((unsigned) mBlockSize, port->mIsInput);
    }
  
    lilv_instance_activate(mProcess->GetInstance());
    mActivated = true;
  
    mLatencyDone = false;
  
    return true;
 }

References LV2Wrapper::GetInstance(), InitInstance(), mActivated, mBlockSize, mCVPorts, mLatencyDone, mProcess, and mSampleRate.

Here is the call graph for this function:

◆ RealtimeAddProcessor()

bool LV2Effect::RealtimeAddProcessor	(	unsigned	numChannels,
		float	sampleRate
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1217 of file LV2Effect.cpp.

 {
    LV2Wrapper *slave = InitInstance(sampleRate);
    if (!slave)
    {
       return false;
    }
  
    mSlaves.push_back(slave);
  
    lilv_instance_activate(slave->GetInstance());
    mActivated = true;
  
    return true;
 }

References LV2Wrapper::GetInstance(), InitInstance(), mActivated, and mSlaves.

Here is the call graph for this function:

◆ RealtimeFinalize()

bool LV2Effect::RealtimeFinalize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1192 of file LV2Effect.cpp.

 {
    for (auto & slave : mSlaves)
    {
       FreeInstance(slave);
    }
    mSlaves.clear();
  
    if (mActivated)
    {
       lilv_instance_deactivate(mMaster->GetInstance());
       mActivated = false;
    }
  
    for (auto & port : mCVPorts)
    {
       port->mBuffer.reset();
    }
  
    mMasterIn.reset();
    mMasterOut.reset();
  
    return true;
 }

References FreeInstance(), LV2Wrapper::GetInstance(), mActivated, mCVPorts, mMaster, mMasterIn, mMasterOut, and mSlaves.

Here is the call graph for this function:

◆ RealtimeInitialize()

bool LV2Effect::RealtimeInitialize ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1176 of file LV2Effect.cpp.

 {
    mMasterIn.reinit(mAudioIn, (unsigned int) mBlockSize);
    mMasterOut.reinit(mAudioOut, (unsigned int) mBlockSize);
  
    for (auto & port : mCVPorts)
    {
       port->mBuffer.reinit((unsigned) mBlockSize, port->mIsInput);
    }
  
    lilv_instance_activate(mMaster->GetInstance());
    mActivated = true;
  
    return true;
 }

References LV2Wrapper::GetInstance(), mActivated, mAudioIn, mAudioOut, mBlockSize, mCVPorts, mMaster, mMasterIn, mMasterOut, and ArraysOf< X >::reinit().

Here is the call graph for this function:

◆ RealtimeProcess()

size_t LV2Effect::RealtimeProcess	(	int	group,
		float **	inbuf,
		float **	outbuf,
		size_t	numSamples
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1338 of file LV2Effect.cpp.

 {
    wxASSERT(group >= 0 && group < (int) mSlaves.size());
    wxASSERT(numSamples <= (size_t) mBlockSize);
  
    if (group < 0 || group >= (int) mSlaves.size())
    {
       return 0;
    }
  
    LV2Wrapper *slave = mSlaves[group];
    LilvInstance *instance = slave->GetInstance();
  
    int i = 0;
    int o = 0;
    for (auto & port : mAudioPorts)
    {
       if (port->mIsInput)
       {
          for (decltype(numSamples) s = 0; s < numSamples; s++)
          {
             mMasterIn[i][s] += inbuf[i][s];
          }
       }
  
       lilv_instance_connect_port(instance,
                                  port->mIndex,
                                  (port->mIsInput ? inbuf[i++] : outbuf[o++]));
    }
  
    mNumSamples = wxMax(numSamples, mNumSamples);
  
    if (mRolling)
    {
       lilv_instance_run(instance, numSamples);
    }
    else
    {
       while (--i >= 0)
       {
          for (decltype(numSamples) s = 0; s < numSamples; s++)
          {
             outbuf[i][s] = inbuf[i][s];
          }
       }
    }
  
    slave->SendResponses();
  
    for (auto & port : mAtomPorts)
    {
       uint8_t *buf = port->mBuffer.data();
  
       if (!port->mIsInput)
       {
          port->mBuffer.resize(port->mMinimumSize);
  
          LV2_Atom *chunk = ( LV2_Atom *) buf;
          chunk->size = port->mMinimumSize;
          chunk->type = urid_Chunk;
       }
    }
  
    if (group == 0)
    {
       mPositionFrame += numSamples;
    }
  
    return numSamples;
 }

References LV2Wrapper::GetInstance(), mAtomPorts, mAudioPorts, mBlockSize, mMasterIn, mNumSamples, mPositionFrame, mRolling, mSlaves, and LV2Wrapper::SendResponses().

Here is the call graph for this function:

◆ RealtimeProcessEnd()

bool LV2Effect::RealtimeProcessEnd ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1409 of file LV2Effect.cpp.

 {
    // Nothing to do if we did process any samples
    if (mNumSamples == 0)
    {
       return true;
    }
  
    int i = 0;
    int o = 0;
    for (auto & port : mAudioPorts)
    {
       lilv_instance_connect_port(mMaster->GetInstance(),
                                  port->mIndex,
                                  (port->mIsInput ? mMasterIn[i++].get() : mMasterOut[o++].get()));
    }
  
    if (mRolling)
    {
       lilv_instance_run(mMaster->GetInstance(), mNumSamples);
    }
  
    for (auto & port : mAtomPorts)
    {
       if (!port->mIsInput)
       {
          ZixRing *ring = port->mRing;
  
          LV2_ATOM_SEQUENCE_FOREACH((LV2_Atom_Sequence *) port->mBuffer.data(), ev)
          {
             zix_ring_write(ring, &ev->body, ev->body.size + sizeof(LV2_Atom));
          }
       }
    }
  
    mNumSamples = 0;
  
    return true;
 }

References LV2Wrapper::GetInstance(), mAtomPorts, mAudioPorts, mMaster, mMasterIn, mMasterOut, mNumSamples, mRolling, ZixRingImpl::size, and zix_ring_write().

Here is the call graph for this function:

◆ RealtimeProcessStart()

bool LV2Effect::RealtimeProcessStart ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1251 of file LV2Effect.cpp.

 {
    int i = 0;
    for (auto & port : mAudioPorts)
    {
       if (port->mIsInput)
       {
          memset(mMasterIn[i++].get(), 0, mBlockSize * sizeof(float));
       }
    }
  
    mNumSamples = 0;
  
    // Transfer incoming events from the ring buffer to the event buffer for each
    // atom input port.  These will be made available to each slave in the chain and
    // to the master once all slaves have run.
    //
    // In addition, reset the output Atom ports.
    for (auto & port : mAtomPorts)
    {
       uint8_t *buf = port->mBuffer.data();
  
       if (port->mIsInput)
       {
          lv2_atom_forge_set_buffer(&mForge,
                                    buf,
                                    port->mBuffer.size());
  
          LV2_Atom_Forge_Frame seqFrame;
          LV2_Atom_Sequence *seq = (LV2_Atom_Sequence *)
             lv2_atom_forge_sequence_head(&mForge, &seqFrame, 0);
  
          if (port->mWantsPosition)
          {
             lv2_atom_forge_frame_time(&mForge, mPositionFrame);
  
             LV2_Atom_Forge_Frame posFrame;
             lv2_atom_forge_object(&mForge, &posFrame, 0, urid_Position);
             lv2_atom_forge_key(&mForge, urid_Speed);
             lv2_atom_forge_float(&mForge, mPositionSpeed);
             lv2_atom_forge_key(&mForge, urid_Frame);
             lv2_atom_forge_long(&mForge, mPositionFrame);
             lv2_atom_forge_pop(&mForge, &posFrame);
          }
  
          ZixRing *ring = port->mRing;
          LV2_Atom atom;
          while (zix_ring_read(ring, &atom, sizeof(atom)))
          {
             if (mForge.offset + sizeof(LV2_Atom_Event) + atom.size < mForge.size)
             {
                lv2_atom_forge_frame_time(&mForge, mPositionFrame);
  
                lv2_atom_forge_write(&mForge, &atom, sizeof(atom));
                zix_ring_read(ring, &mForge.buf[mForge.offset], atom.size);
                mForge.offset += atom.size;
                seq->atom.size += atom.size;
             }
             else
             {
                zix_ring_skip(ring, atom.size);
                wxLogError(wxT("LV2 sequence buffer overflow"));
             }
          }
          lv2_atom_forge_pop(&mForge, &seqFrame);
 #if 0
          LV2_ATOM_SEQUENCE_FOREACH(seq, ev)
          {
             LV2_Atom_Object *o = (LV2_Atom_Object *) &ev->body;
             wxLogDebug(wxT("ev = %lld ev.size %d ev.type %d"), ev->time.frames, ev->body.size, ev->body.type);
          }
 #endif
       }
       else
       {
          port->mBuffer.resize(port->mMinimumSize);
          *((LV2_Atom *) buf) =
          {
             port->mMinimumSize,
             urid_Chunk
          };
       }
    }
  
    return true;
 }

References mAtomPorts, mAudioPorts, mBlockSize, mForge, mMasterIn, mNumSamples, mPositionFrame, mPositionSpeed, ZixRingImpl::size, zix_ring_read(), and zix_ring_skip().

Here is the call graph for this function:

◆ RealtimeResume()

bool LV2Effect::RealtimeResume ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1242 of file LV2Effect.cpp.

 {
    mPositionSpeed = 1.0;
    mPositionFrame = 0.0;
    mRolling = true;
  
    return true;
 }

References mPositionFrame, mPositionSpeed, and mRolling.

◆ RealtimeSuspend()

bool LV2Effect::RealtimeSuspend ( )

overridevirtual

Implements EffectClientInterface.

Definition at line 1233 of file LV2Effect.cpp.

 {
    mPositionSpeed = 0.0;
    mPositionFrame = 0.0;
    mRolling = false;
  
    return true;
 }

References mPositionFrame, mPositionSpeed, and mRolling.

◆ SaveParameters()

bool LV2Effect::SaveParameters ( const RegistryPath & group )

private

Definition at line 1820 of file LV2Effect.cpp.

 {
    CommandParameters eap;
    if (!GetAutomationParameters(eap))
    {
       return false;
    }
  
    wxString parms;
    if (!eap.GetParameters(parms))
    {
       return false;
    }
  
    return mHost->SetPrivateConfig(group, wxT("Parameters"), parms);
 }

References GetAutomationParameters(), CommandParameters::GetParameters(), mHost, and ConfigClientInterface::SetPrivateConfig().

Referenced by SaveUserPreset(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SaveUserPreset()

bool LV2Effect::SaveUserPreset ( const RegistryPath & name )

overridevirtual

Implements EffectClientInterface.

Definition at line 1684 of file LV2Effect.cpp.

 {
    return SaveParameters(name);
 }

References name, and SaveParameters().

Here is the call graph for this function:

◆ set_value_func()

void LV2Effect::set_value_func	(	const char *	port_symbol,
		void *	user_data,
		const void *	value,
		uint32_t	size,
		uint32_t	type
	)

staticprivate

Definition at line 3196 of file LV2Effect.cpp.

 {
    ((LV2Effect *) user_data)->SetPortValue(port_symbol, value, size, type);
 }

Referenced by LoadFactoryPreset().

Here is the caller graph for this function:

◆ SetAutomationParameters()

bool LV2Effect::SetAutomationParameters ( CommandParameters & parms )

overridevirtual

Implements EffectClientInterface.

Definition at line 1509 of file LV2Effect.cpp.

 {
    // First pass validates values
    for (auto & port : mControlPorts)
    {
       if (port->mIsInput)
       {
          double d = 0.0;
          if (!parms.Read(port->mName, &d))
          {
             return false;
          }
  
          // Use unscaled range here
          if (d < port->mMin || d > port->mMax)
          {
             return false;
          }
       }
    }
  
    // Second pass actually sets the values
    for (auto & port : mControlPorts)
    {
       if (port->mIsInput)
       {
          double d = 0.0;
          if (!parms.Read(port->mName, &d))
          {
             return false;
          }
  
          port->mVal = d;
          port->mTmp = port->mVal * (port->mSampleRate ? mSampleRate : 1.0);
       }
    }
  
    return true;
 }

References mControlPorts, and mSampleRate.

Referenced by LoadParameters().

Here is the caller graph for this function:

◆ SetBlockSize()

size_t LV2Effect::SetBlockSize ( size_t maxBlockSize )

overridevirtual

Implements EffectClientInterface.

Definition at line 993 of file LV2Effect.cpp.

 {
    mBlockSize = std::min(std::min((int)maxBlockSize, mUserBlockSize), mMaxBlockSize);
  
    if (mBlockSize < mMinBlockSize)
    {
       mBlockSize = mMinBlockSize;
    }
    if (mBlockSize > mMaxBlockSize)
    {
       mBlockSize = mMaxBlockSize;
    }
  
    if (mMaster)
    {
       mMaster->SetBlockSize();
    }
  
    for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
    {
       mSlaves[i]->SetBlockSize();
    }
  
    return mBlockSize;
 }

References mBlockSize, min(), mMaster, mMaxBlockSize, mMinBlockSize, mSlaves, mUserBlockSize, and LV2Wrapper::SetBlockSize().

Here is the call graph for this function:

◆ SetHost()

bool LV2Effect::SetHost ( EffectHostInterface * host )

overridevirtual

Implements EffectClientInterface.

Definition at line 518 of file LV2Effect.cpp.

 {
    mHost = host;
  
    AddOption(urid_SequenceSize, sizeof(mSeqSize), urid_Int, &mSeqSize);
    AddOption(urid_MinBlockLength, sizeof(mMinBlockSize), urid_Int, &mMinBlockSize);
    AddOption(urid_MaxBlockLength, sizeof(mMaxBlockSize), urid_Int, &mMaxBlockSize);
  
    mBlockSizeOption = AddOption(urid_NominalBlockLength,
                                 sizeof(mBlockSize),
                                 urid_Int,
                                 &mBlockSize);
    mSampleRateOption = AddOption(urid_SampleRate,
                                  sizeof(mSampleRate),
                                  urid_Float,
                                  &mSampleRate);
    AddOption(0, 0, 0, NULL);
  
    if (!ValidateOptions(lilv_plugin_get_uri(mPlug)))
    {
       return false;
    }
  
    mUriMapFeature.callback_data = this;
    mUriMapFeature.uri_to_id = LV2Effect::uri_to_id;
  
    mURIDMapFeature.handle = this;
    mURIDMapFeature.map = LV2Effect::urid_map;
  
    mURIDUnmapFeature.handle = this;
    mURIDUnmapFeature.unmap = LV2Effect::urid_unmap;
  
    mUIResizeFeature.handle = this;
    mUIResizeFeature.ui_resize = LV2Effect::ui_resize;
  
    mLogFeature.handle = this;
    mLogFeature.printf = LV2Effect::log_printf;
    mLogFeature.vprintf = LV2Effect::log_vprintf;
  
    mExternalUIHost.ui_closed = LV2Effect::ui_closed;
  
    LilvNode *pluginName = lilv_plugin_get_name(mPlug);
    mExternalUIHost.plugin_human_id = lilv_node_as_string(pluginName);
    lilv_node_free(pluginName);
  
    AddFeature(LV2_UI__noUserResize, NULL);
    AddFeature(LV2_UI__fixedSize, NULL);
    AddFeature(LV2_UI__idleInterface, NULL);
    AddFeature(LV2_UI__makeResident, NULL);
    AddFeature(LV2_BUF_SIZE__boundedBlockLength, NULL);
    AddFeature(LV2_BUF_SIZE__fixedBlockLength, NULL);
    AddFeature(LV2_OPTIONS__options, mOptions.data());
    AddFeature(LV2_URI_MAP_URI, &mUriMapFeature);
    AddFeature(LV2_URID__map, &mURIDMapFeature);
    AddFeature(LV2_URID__unmap, &mURIDUnmapFeature);
    AddFeature(LV2_UI__resize, &mUIResizeFeature);
    AddFeature(LV2_DATA_ACCESS_URI, &mExtensionDataFeature);
    AddFeature(LV2_LOG__log, &mLogFeature);
    AddFeature(LV2_EXTERNAL_UI__Host, &mExternalUIHost);
    AddFeature(LV2_EXTERNAL_UI_DEPRECATED_URI, &mExternalUIHost);
    // Some plugins specify this as a feature
    AddFeature(LV2_EXTERNAL_UI__Widget, NULL);
  
    mInstanceAccessFeature = AddFeature(LV2_INSTANCE_ACCESS_URI, NULL);
    mParentFeature = AddFeature(LV2_UI__parent, NULL);
  
    AddFeature(NULL, NULL);
  
    if (!ValidateFeatures(lilv_plugin_get_uri(mPlug)))
    {
       return false;
    }
  
    auto minLength = lilv_world_get(gWorld, lilv_plugin_get_uri(mPlug), node_MinBlockLength, NULL);
    if (minLength)
    {
       if (lilv_node_is_int(minLength))
       {
          int val = lilv_node_as_int(minLength);
          if (mMinBlockSize < val)
          {
             mMinBlockSize = val;
          }
       }
       lilv_node_free(minLength);
    }
  
    auto maxLength = lilv_world_get(gWorld, lilv_plugin_get_uri(mPlug), node_MaxBlockLength, NULL);
    if (maxLength)
    {
       if (lilv_node_is_int(maxLength))
       {
          int val = lilv_node_as_int(maxLength);
          if (mMaxBlockSize > val)
          {
             mMaxBlockSize = val;
          }
       }
       lilv_node_free(maxLength);
    }
  
    if (mMinBlockSize > mMaxBlockSize)
    {
       mMaxBlockSize = mMinBlockSize;
    }
  
    auto numPorts = lilv_plugin_get_num_ports(mPlug);
  
    // Allocate buffers for the port indices and the default control values
    Floats minimumVals {numPorts};
    Floats maximumVals {numPorts};
    Floats defaultVals {numPorts};
  
    // Retrieve the port ranges for all ports (some values may be NaN)
    lilv_plugin_get_port_ranges_float(mPlug,
                                      minimumVals.get(),
                                      maximumVals.get(),
                                      defaultVals.get());
  
    // Get info about all ports
    for (size_t i = 0; i < numPorts; i++)
    {
       const LilvPort *port = lilv_plugin_get_port_by_index(mPlug, i);
       int index = lilv_port_get_index(mPlug, port);
  
       // It must be input or output, anything else is bogus
       bool isInput;
       if (lilv_port_is_a(mPlug, port, node_InputPort))
       {
          isInput = true;
       }
       else if (lilv_port_is_a(mPlug, port, node_OutputPort))
       {
          isInput = false;
       }
       else
       {
          assert(false);
          return false;
       }
  
       // Get the port name and symbol
       wxString symbol = LilvString(lilv_port_get_symbol(mPlug, port));
       wxString name = LilvString(lilv_port_get_name(mPlug, port), true);
  
       // Get the group to which this port belongs or default to the main group
       wxString groupName = wxEmptyString;
       LilvNode *group = lilv_port_get(mPlug, port, node_Group);
       if (group)
       {
          groupName = LilvString(lilv_world_get(gWorld, group, node_Label, NULL), true);
          if (groupName.empty())
          {
             groupName = LilvString(lilv_world_get(gWorld, group, node_Name, NULL), true);
          }
  
          if (groupName.empty())
          {
             groupName = LilvString(group);
          }
  
          lilv_node_free(group);
       }
       else
       {
          groupName = _("Effect Settings");
       }
  
       // Get the latency port
       uint32_t latencyIndex = lilv_plugin_get_latency_port_index(mPlug);
  
       // Get the ports designation (must be freed)
       LilvNode *designation = lilv_port_get(mPlug, port, node_Designation);
  
       // Check for audio ports
       if (lilv_port_is_a(mPlug, port, node_AudioPort))
       {
          mAudioPorts.push_back(std::make_shared<LV2AudioPort>(port, index, isInput, symbol, name, groupName));
  
          isInput ? mAudioIn++ : mAudioOut++;
       }
       // Check for Control ports
       else if (lilv_port_is_a(mPlug, port, node_ControlPort))
       {
          // Add group if not previously done
          if (mGroupMap.find(groupName) == mGroupMap.end())
          {
             mGroups.push_back(groupName);
          }
          mGroupMap[groupName].push_back(mControlPorts.size());
  
          mControlPorts.push_back(std::make_shared<LV2ControlPort>(port, index, isInput, symbol, name, groupName));
          LV2ControlPortPtr controlPort = mControlPorts.back();
  
          // Get any unit descriptor
          LilvNode *unit = lilv_port_get(mPlug, port, node_Unit);
          if (unit)
          {
             // Really should use lilv_world_get_symbol()
             LilvNode *symbol = lilv_world_get_symbol(gWorld, unit);
             if (symbol)
             {
                controlPort->mUnits = LilvString(symbol);
                lilv_node_free(symbol);
             }
             lilv_node_free(unit);
          }
  
          // Get the scale points
          LilvScalePoints *points = lilv_port_get_scale_points(mPlug, port);
          LILV_FOREACH(scale_points, j, points)
          {
             const LilvScalePoint *point = lilv_scale_points_get(points, j);
  
             controlPort->mScaleValues.push_back(lilv_node_as_float(lilv_scale_point_get_value(point)));
             controlPort->mScaleLabels.push_back(LilvString(lilv_scale_point_get_label(point)));
          }
          lilv_scale_points_free(points);
  
          // Collect the value and range info
          controlPort->mHasLo = !std::isnan(minimumVals[i]);
          controlPort->mHasHi = !std::isnan(maximumVals[i]);
          controlPort->mMin = controlPort->mHasLo ? minimumVals[i] : 0.0;
          controlPort->mMax = controlPort->mHasHi ? maximumVals[i] : 1.0;
          controlPort->mLo = controlPort->mMin;
          controlPort->mHi = controlPort->mMax;
          controlPort->mDef = !std::isnan(defaultVals[i])
                      ? defaultVals[i]
                      : controlPort->mHasLo
                        ? controlPort->mLo
                        : controlPort->mHasHi
                          ? controlPort->mHi
                          : 0.0;
          controlPort->mVal = controlPort->mDef;
          controlPort->mLst = controlPort->mVal;
  
          // Figure out the type of port we have
          if (isInput)
          {
             if (lilv_port_has_property(mPlug, port, node_Toggled))
             {
                controlPort->mToggle = true;
             }
             else if (lilv_port_has_property(mPlug, port, node_Enumeration))
             {
                controlPort->mEnumeration = true;
             }
             else if (lilv_port_has_property(mPlug, port, node_Integer))
             {
                controlPort->mInteger = true;
             }
             else if (lilv_port_has_property(mPlug, port, node_SampleRate))
             {
                controlPort->mSampleRate = true;
             }
  
             // Trigger properties can be combined with other types, but it
             // seems mostly to be combined with toggle.  So, we turn the
             // checkbox into a button.
             if (lilv_port_has_property(mPlug, port, node_Trigger))
             {
                controlPort->mTrigger = true;
             }
  
             // We'll make the slider logarithmic
             if (lilv_port_has_property(mPlug, port, node_Logarithmic))
             {
                controlPort->mLogarithmic = true;
             }
  
             if (lilv_port_has_property(mPlug, port, node_Enumeration))
             {
                controlPort->mEnumeration = true;
             }
  
             mControlPortMap[controlPort->mIndex] = controlPort;
          }
          else
          {
             if (controlPort->mIndex == latencyIndex)
             {
                mLatencyPort = i;
             }
          }
       }
       // Check for atom ports
       else if (lilv_port_is_a(mPlug, port, node_AtomPort))
       {
          mAtomPorts.push_back(std::make_shared<LV2AtomPort>(port, index, isInput, symbol, name, groupName));
          std::shared_ptr<LV2AtomPort> atomPort = mAtomPorts.back();
  
          atomPort->mMinimumSize = 8192;
          LilvNode *min = lilv_port_get(mPlug, port, node_MinimumSize);
          if (min)
          {
             if (lilv_node_is_int(min))
             {
                uint32_t val = lilv_node_as_int(min);
                if (atomPort->mMinimumSize < val)
                {
                   atomPort->mMinimumSize = val;
                }
             }
             lilv_node_free(min);
          }
  
          atomPort->mBuffer.resize(atomPort->mMinimumSize);
          atomPort->mRing = zix_ring_new(atomPort->mMinimumSize);
          zix_ring_mlock(atomPort->mRing);
  
          if (lilv_port_supports_event(mPlug, port, node_Position))
          {
             atomPort->mWantsPosition = true;
          }
  
          if (lilv_port_supports_event(mPlug, port, node_MidiEvent))
          {
             atomPort->mIsMidi = true;
             (isInput ? mMidiIn : mMidiOut) += 1;
          }
  
          bool isControl = lilv_node_equals(designation, node_Control);
          if (isInput)
          {
             if (!mControlIn || isControl)
             {
                mControlIn = atomPort;
             }
          }
          else
          {
             if (!mControlOut || isControl)
             {
                mControlOut = atomPort;
             }
          }
       }
       // Check for CV ports
       else if (lilv_port_is_a(mPlug, port, node_CVPort))
       {
          mCVPorts.push_back(std::make_shared<LV2CVPort>(port, index, isInput, symbol, name, groupName));
          std::shared_ptr<LV2CVPort> cvPort = mCVPorts.back();
       
          // Collect the value and range info
          if (!std::isnan(minimumVals[i]))
          {
             cvPort->mHasLo = true;
             cvPort->mMin = minimumVals[i];
          }
  
          if (!std::isnan(maximumVals[i]))
          {
             cvPort->mHasHi = true;
             cvPort->mMax = maximumVals[i];
          }
  
          if (!std::isnan(defaultVals[i]))
          {
             cvPort->mDef = defaultVals[i];
          }
          else if (cvPort->mHasLo)
          {
             cvPort->mDef = cvPort->mMin;
          }
          else if (cvPort->mHasHi)
          {
             cvPort->mDef = cvPort->mMax;
          }
       }
  
       // Free the designation node
       if (designation)
       {
          lilv_node_free(designation);
       }
    }
  
    // Ignore control designation if one of them is missing
    if ((mControlIn && !mControlOut) || (!mControlIn && mControlOut))
    {
       mControlIn.reset();
       mControlOut.reset();
    }
  
    // Determine available extensions
    mWantsOptionsInterface = false;
    mWantsWorkerInterface = false;
    mWantsStateInterface = false;
  
    LilvNodes *extdata = lilv_plugin_get_extension_data(mPlug);
    if (extdata)
    {
       LILV_FOREACH(nodes, i, extdata)
       {
          const LilvNode *node = lilv_nodes_get(extdata, i);
          const char *uri = lilv_node_as_string(node);
  
          if (strcmp(uri, LV2_OPTIONS__interface) == 0)
          {
             mWantsOptionsInterface = true;
          }
          else if (strcmp(uri, LV2_WORKER__interface) == 0)
          {
             mWantsWorkerInterface = true;
          }
          else if (strcmp(uri, LV2_STATE__interface) == 0)
          {
             mWantsStateInterface = true;
          }
       }
       lilv_nodes_free(extdata);
    }
  
    // mHost will be null during registration
    if (mHost)
    {
       int userBlockSize;
       mHost->GetSharedConfig(wxT("Settings"), wxT("BufferSize"), userBlockSize, 8192);
       mUserBlockSize = std::max(1, userBlockSize);
       mHost->GetSharedConfig(wxT("Settings"), wxT("UseLatency"), mUseLatency, true);
       mHost->GetSharedConfig(wxT("Settings"), wxT("UseGUI"), mUseGUI, true);
  
       mBlockSize = mUserBlockSize;
  
       bool haveDefaults;
       mHost->GetPrivateConfig(mHost->GetFactoryDefaultsGroup(), wxT("Initialized"), haveDefaults, false);
       if (!haveDefaults)
       {
          SaveParameters(mHost->GetFactoryDefaultsGroup());
          mHost->SetPrivateConfig(mHost->GetFactoryDefaultsGroup(), wxT("Initialized"), true);
       }
  
       LoadParameters(mHost->GetCurrentSettingsGroup());
    }
  
    lv2_atom_forge_init(&mForge, &mURIDMapFeature);
  
    return true;
 }

References _, AddFeature(), AddOption(), EffectHostInterface::GetCurrentSettingsGroup(), EffectHostInterface::GetFactoryDefaultsGroup(), ConfigClientInterface::GetPrivateConfig(), ConfigClientInterface::GetSharedConfig(), gWorld, LilvString(), LoadParameters(), log_printf(), log_vprintf(), LV2_EXTERNAL_UI__Host, LV2_EXTERNAL_UI__Widget, LV2_EXTERNAL_UI_DEPRECATED_URI, LV2_UI__makeResident, mAtomPorts, mAudioIn, mAudioOut, mAudioPorts, mBlockSize, mBlockSizeOption, LV2AtomPort::mBuffer, mControlIn, mControlOut, mControlPortMap, mControlPorts, mCVPorts, LV2CVPort::mDef, mExtensionDataFeature, mExternalUIHost, mForge, mGroupMap, mGroups, LV2CVPort::mHasHi, LV2CVPort::mHasLo, mHost, min(), mInstanceAccessFeature, LV2AtomPort::mIsMidi, mLatencyPort, mLogFeature, LV2CVPort::mMax, mMaxBlockSize, mMidiIn, mMidiOut, LV2CVPort::mMin, mMinBlockSize, LV2AtomPort::mMinimumSize, mOptions, mParentFeature, mPlug, LV2AtomPort::mRing, mSampleRate, mSampleRateOption, mSeqSize, mUIResizeFeature, mURIDMapFeature, mURIDUnmapFeature, mUriMapFeature, mUseGUI, mUseLatency, mUserBlockSize, mWantsOptionsInterface, LV2AtomPort::mWantsPosition, mWantsStateInterface, mWantsWorkerInterface, name, _LV2_External_UI_Host::plugin_human_id, SaveParameters(), ConfigClientInterface::SetPrivateConfig(), ui_closed(), _LV2_External_UI_Host::ui_closed, ui_resize(), uri_to_id(), urid_map(), urid_unmap(), ValidateFeatures(), ValidateOptions(), zix_ring_mlock(), and zix_ring_new().

Referenced by LV2EffectsModule::DiscoverPluginsAtPath().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHostUI()

void LV2Effect::SetHostUI ( EffectUIHostInterface * host )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1553 of file LV2Effect.cpp.

 {
    mUIHost = host;
 }

References mUIHost.

◆ SetPortValue()

void LV2Effect::SetPortValue	(	const char *	port_symbol,
		const void *	value,
		uint32_t	size,
		uint32_t	type
	)

private

Definition at line 3205 of file LV2Effect.cpp.

 {
    wxString symbol = wxString::FromUTF8(port_symbol);
  
    for (auto & port : mControlPorts)
    {
       if (port->mSymbol == symbol)
       {
          if (type == urid_Bool && size == sizeof(bool))
          {
             port->mVal = (float) (*((const bool *) value)) ? 1.0f : 0.0f;
          }
          else if (type == urid_Double && size == sizeof(double))
          {
             port->mVal = (float) (*((const double *) value));
          }
          else if (type == urid_Float && size == sizeof(float))
          {
             port->mVal = (float) (*((const float *) value));
          }
          else if (type == urid_Int && size == sizeof(int32_t))
          {
             port->mVal = (float) (*((const int32_t *) value));
          }
          else if (type == urid_Long && size == sizeof(int64_t))
          {
             port->mVal = (float) (*((const int64_t *) value));
          }
  
          break;
       }
    }
 }

References mControlPorts.

◆ SetSampleRate()

void LV2Effect::SetSampleRate ( double rate )

overridevirtual

Implements EffectClientInterface.

Definition at line 978 of file LV2Effect.cpp.

 {
    mSampleRate = (float) rate;
  
    if (mMaster)
    {
       mMaster->SetSampleRate();
    }
  
    for (size_t i = 0, cnt = mSlaves.size(); i < cnt; i++)
    {
       mSlaves[i]->SetSampleRate();
    }
 }

References mMaster, mSampleRate, mSlaves, and LV2Wrapper::SetSampleRate().

Here is the call graph for this function:

◆ SetSlider()

void LV2Effect::SetSlider ( const LV2ControlPortPtr & port )

private

Definition at line 2702 of file LV2Effect.cpp.

 {
    float lo = port->mLo;
    float hi = port->mHi;
    float val = port->mTmp;
  
    if (port->mLogarithmic)
    {
       lo = logf(lo);
       hi = logf(hi);
       val = logf(val);
    }
  
    port->mCtrl.slider->SetValue(lrintf((val - lo) / (hi - lo) * 1000.0));
 }

References lrintf.

Referenced by OnText(), and TransferDataToWindow().

Here is the caller graph for this function:

◆ ShowInterface()

bool LV2Effect::ShowInterface	(	wxWindow &	parent,
		const EffectDialogFactory &	factory,
		bool	forceModal = `false`
	)

overridevirtual

Implements EffectClientInterface.

Definition at line 1449 of file LV2Effect.cpp.

 {
    if (mDialog)
    {
       if (mDialog->Close(true))
       {
          mDialog = nullptr;
       }
       return false;
    }
  
    // mDialog is null
    auto cleanup = valueRestorer(mDialog);
  
    if ( factory )
       mDialog = factory(parent, mHost, this);
    if (!mDialog)
    {
       return false;
    }
  
    // Try to give the window a sensible default/minimum size
    mDialog->Layout();
    mDialog->Fit();
    mDialog->SetMinSize(mDialog->GetSize());
    if (mNoResize)
    {
       mDialog->SetMaxSize(mDialog->GetSize());
    }
  
    if ((SupportsRealtime() || GetType() == EffectTypeAnalyze) && !forceModal)
    {
       mDialog->Show();
       cleanup.release();
  
       return false;
    }
  
    bool res = mDialog->ShowModal() != 0;
  
    return res;
 }

References EffectTypeAnalyze, factory, GetType(), mDialog, mHost, mNoResize, SupportsRealtime(), and valueRestorer().

Here is the call graph for this function:

◆ ShowOptions()

void LV2Effect::ShowOptions ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1786 of file LV2Effect.cpp.

 {
    LV2EffectSettingsDialog dlg(mParent, this);
    if (dlg.ShowModal() == wxID_OK)
    {
       // Reinitialize configuration settings
       int userBlockSize;
       mHost->GetSharedConfig(wxT("Settings"), wxT("BufferSize"), userBlockSize, DEFAULT_BLOCKSIZE);
       mUserBlockSize = std::max(1, userBlockSize);
       mHost->GetSharedConfig(wxT("Settings"), wxT("UseLatency"), mUseLatency, true);
    }
 }

References DEFAULT_BLOCKSIZE, ConfigClientInterface::GetSharedConfig(), mHost, mParent, mUseLatency, and mUserBlockSize.

Here is the call graph for this function:

◆ suil_port_index_func()

uint32_t LV2Effect::suil_port_index_func	(	SuilController	controller,
		const char *	port_symbol
	)

staticprivate

Definition at line 3144 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) controller)->SuilPortIndex(port_symbol);
 }

Referenced by BuildFancy().

Here is the caller graph for this function:

◆ suil_port_write_func()

void LV2Effect::suil_port_write_func	(	SuilController	controller,
		uint32_t	port_index,
		uint32_t	buffer_size,
		uint32_t	protocol,
		const void *	buffer
	)

staticprivate

Definition at line 3108 of file LV2Effect.cpp.

 {
    ((LV2Effect *) controller)->SuilPortWrite(port_index, buffer_size, protocol, buffer);
 }

Referenced by BuildFancy().

Here is the caller graph for this function:

◆ SuilPortIndex()

uint32_t LV2Effect::SuilPortIndex ( const char * port_symbol )

private

Definition at line 3150 of file LV2Effect.cpp.

 {
    for (size_t i = 0, cnt = lilv_plugin_get_num_ports(mPlug); i < cnt; i++)
    {
       const LilvPort *port = lilv_plugin_get_port_by_index(mPlug, i);
       if (strcmp(port_symbol, lilv_node_as_string(lilv_port_get_symbol(mPlug, port))) == 0)
       {
          return lilv_port_get_index(mPlug, port);
       }
    }
  
    return LV2UI_INVALID_PORT_INDEX;
 }

References mPlug.

◆ SuilPortWrite()

void LV2Effect::SuilPortWrite	(	uint32_t	port_index,
		uint32_t	buffer_size,
		uint32_t	protocol,
		const void *	buffer
	)

private

Definition at line 3117 of file LV2Effect.cpp.

 {
    // Handle implicit floats
    if (protocol == 0 && buffer_size == sizeof(float))
    {
       auto it = mControlPortMap.find(port_index);
       if (it != mControlPortMap.end())
       {
          it->second->mVal = *((const float *) buffer);
       }
    }
    // Handle event transfers
    else if (protocol == urid_EventTransfer)
    {
       if (mControlIn && port_index == mControlIn->mIndex)
       {
          zix_ring_write(mControlIn->mRing, buffer, buffer_size);
       }
    }
  
    return;
 }

References mControlIn, mControlPortMap, and zix_ring_write().

Here is the call graph for this function:

◆ SupportsAutomation()

bool LV2Effect::SupportsAutomation ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 510 of file LV2Effect.cpp.

 {
    return true;
 }

◆ SupportsRealtime()

bool LV2Effect::SupportsRealtime ( )

overridevirtual

Implements EffectDefinitionInterface.

Definition at line 505 of file LV2Effect.cpp.

 {
    return GetType() == EffectTypeProcess;
 }

References EffectTypeProcess, and GetType().

Referenced by ShowInterface().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TransferDataFromWindow()

bool LV2Effect::TransferDataFromWindow ( )

private

Definition at line 2692 of file LV2Effect.cpp.

 {
    if (!mParent->Validate() || !mParent->TransferDataFromWindow())
    {
       return false;
    }
  
    return true;
 }

References mParent.

◆ TransferDataToWindow()

bool LV2Effect::TransferDataToWindow ( )

private

Definition at line 2620 of file LV2Effect.cpp.

 {
    if (mUseGUI)
    {
       if (mSuilInstance)
       {
          for (auto & port : mControlPorts)
          {
             if (port->mIsInput)
             {
                suil_instance_port_event(mSuilInstance,
                                         port->mIndex,
                                         sizeof(float),
                                         0,
                                         &port->mVal);
             }
          }
       }
  
       return true;
    }
  
    for (auto & group : mGroups)
    {
       const auto & params = mGroupMap[group];
       for (auto & param : params)
       {
          auto & port = mControlPorts[param];
  
          if (port->mTrigger)
          {
             continue;
          }
  
          if (port->mToggle)
          {
             port->mCtrl.checkbox->SetValue(port->mVal > 0);
          }
          else if (port->mEnumeration)      // Check before integer
          {
             int s;
             for (s = (int) port->mScaleValues.size() - 1; s >= 0; s--)
             {
                if (port->mVal >= port->mScaleValues[s])
                {
                   break;
                }
             }
  
             if (s < 0)
             {
                s = 0;
             }
  
             port->mCtrl.choice->SetSelection(s);
          }
          else if (port->mIsInput)
          {
             port->mTmp = port->mVal * (port->mSampleRate ? mSampleRate : 1.0);
             SetSlider(port);
          }
       }
    }
  
    if (mParent && !mParent->TransferDataToWindow())
    {
       return false;
    }
  
    return true;
 }

References mControlPorts, mGroupMap, mGroups, mParent, mSampleRate, mSuilInstance, mUseGUI, params, and SetSlider().

Referenced by BuildFancy(), BuildPlain(), LoadFactoryDefaults(), LoadFactoryPreset(), and LoadUserPreset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ui_closed()

void LV2Effect::ui_closed ( LV2UI_Controller controller )

staticprivate

Definition at line 3095 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) controller)->UIClosed();
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ ui_resize()

int LV2Effect::ui_resize	(	LV2UI_Feature_Handle	handle,
		int	width,
		int	height
	)

staticprivate

Definition at line 3071 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) handle)->UIResize(width, height);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ UIClosed()

void LV2Effect::UIClosed ( )

private

Definition at line 3100 of file LV2Effect.cpp.

 {
    mExternalUIClosed = true;
  
    return;
 }

References mExternalUIClosed.

◆ UIResize()

int LV2Effect::UIResize	(	int	width,
		int	height
	)

private

Definition at line 3076 of file LV2Effect.cpp.

 {
    // Queue a wxSizeEvent to resize the plugins UI
    if (mNativeWin)
    {
       wxSizeEvent sw(wxSize(width, height));
       sw.SetEventObject(mNativeWin);
       mNativeWin->GetEventHandler()->AddPendingEvent(sw);
    }
    // The window hasn't been created yet, so record the desired size
    else
    {
       mNativeWinInitialSize = wxSize(width, height);
    }
  
    return 0;
 }

References mNativeWin, and mNativeWinInitialSize.

◆ uri_to_id()

uint32_t LV2Effect::uri_to_id	(	LV2_URI_Map_Callback_Data	callback_data,
		const char *	map,
		const char *	uri
	)

staticprivate

Definition at line 2929 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) callback_data)->URID_Map(uri);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ URID_Map()

LV2_URID LV2Effect::URID_Map ( const char * uri )

private

Definition at line 2942 of file LV2Effect.cpp.

 {
    LV2_URID urid;
    
    urid = Lookup_URI(gURIDMap, uri, false);
    if (urid > 0)
    {
       return urid;
    }
  
    urid = Lookup_URI(mURIDMap, uri);
    if (urid > 0)
    {
       return urid + gURIDMap.size();
    }
  
    return 0;
 }

References gURIDMap, Lookup_URI(), and mURIDMap.

Referenced by CheckOptions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ urid_map()

LV2_URID LV2Effect::urid_map	(	LV2_URID_Map_Handle	handle,
		const char *	uri
	)

staticprivate

Definition at line 2937 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) handle)->URID_Map(uri);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ URID_Unmap()

const char * LV2Effect::URID_Unmap ( LV2_URID urid )

private

Definition at line 2988 of file LV2Effect.cpp.

 {
    if (urid > 0)
    {
       if (urid <= (LV2_URID) gURIDMap.size())
       {
          return mURIDMap[urid - 1].get();
       }
  
       urid -= gURIDMap.size();
  
       if (urid <= (LV2_URID) mURIDMap.size())
       {
          return mURIDMap[urid - 1].get();
       }
    }
  
    return NULL;
 }

References gURIDMap, and mURIDMap.

◆ urid_unmap()

const char * LV2Effect::urid_unmap	(	LV2_URID_Unmap_Handle	handle,
		LV2_URID	urid
	)

staticprivate

Definition at line 2983 of file LV2Effect.cpp.

 {
    return ((LV2Effect *) handle)->URID_Unmap(urid);
 }

Referenced by SetHost().

Here is the caller graph for this function:

◆ ValidateFeatures()

bool LV2Effect::ValidateFeatures ( const LilvNode * subject )

private

Definition at line 1872 of file LV2Effect.cpp.

 {
    if (CheckFeatures(subject, node_RequiredFeature, true))
    {
       return CheckFeatures(subject, node_OptionalFeature, false);
    }
  
    return false;
 }

References CheckFeatures().

Referenced by BuildFancy(), and SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ValidateOptions()

bool LV2Effect::ValidateOptions ( const LilvNode * subject )

private

Definition at line 1936 of file LV2Effect.cpp.

 {
    if (CheckOptions(subject, node_RequiredOption, true))
    {
       return CheckOptions(subject, node_SupportedOption, false);
    }
  
    return false;
 }

References CheckOptions().

Referenced by SetHost().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ValidateUI()

bool LV2Effect::ValidateUI ( )

overridevirtual

Implements EffectUIClientInterface.

Definition at line 1606 of file LV2Effect.cpp.

 {
    if (!mParent->Validate() || !mParent->TransferDataFromWindow())
    {
       return false;
    }
  
    if (GetType() == EffectTypeGenerate)
    {
       mHost->SetDuration(mDuration->GetValue());
    }
  
    return true;
 }

References EffectTypeGenerate, GetType(), NumericConverter::GetValue(), mDuration, mHost, mParent, and EffectHostInterface::SetDuration().

Here is the call graph for this function:

Friends And Related Function Documentation

◆ LV2EffectSettingsDialog

friend class LV2EffectSettingsDialog

friend

Definition at line 568 of file LV2Effect.h.

◆ LV2EffectsModule

friend class LV2EffectsModule

friend

Definition at line 569 of file LV2Effect.h.

◆ LV2Wrapper

friend class LV2Wrapper

friend

Definition at line 567 of file LV2Effect.h.

Referenced by InitInstance().

Member Data Documentation

◆ gURIDMap

URIDMap LV2Effect::gURIDMap

staticprivate

Definition at line 436 of file LV2Effect.h.

Referenced by URID_Map(), and URID_Unmap().

◆ mActivated

bool LV2Effect::mActivated

private

Definition at line 490 of file LV2Effect.h.

Referenced by ProcessInitialize(), RealtimeAddProcessor(), RealtimeFinalize(), RealtimeInitialize(), and LV2Wrapper::~LV2Wrapper().

◆ mAtomPorts

LV2AtomPortArray LV2Effect::mAtomPorts

private

Definition at line 468 of file LV2Effect.h.

Referenced by InitInstance(), ProcessBlock(), RealtimeProcess(), RealtimeProcessEnd(), RealtimeProcessStart(), and SetHost().

◆ mAudioIn

unsigned LV2Effect::mAudioIn

private

Definition at line 465 of file LV2Effect.h.

Referenced by GetAudioInCount(), RealtimeInitialize(), and SetHost().

◆ mAudioOut

unsigned LV2Effect::mAudioOut

private

Definition at line 466 of file LV2Effect.h.

Referenced by GetAudioOutCount(), RealtimeInitialize(), and SetHost().

◆ mAudioPorts

LV2AudioPortArray LV2Effect::mAudioPorts

private

Definition at line 464 of file LV2Effect.h.

Referenced by ProcessBlock(), RealtimeProcess(), RealtimeProcessEnd(), RealtimeProcessStart(), and SetHost().

◆ mBlockSize

int LV2Effect::mBlockSize

private

Definition at line 454 of file LV2Effect.h.

Referenced by GetBlockSize(), ProcessBlock(), ProcessInitialize(), RealtimeInitialize(), RealtimeProcess(), RealtimeProcessStart(), SetBlockSize(), and SetHost().

◆ mBlockSizeOption

size_t LV2Effect::mBlockSizeOption

private

Definition at line 532 of file LV2Effect.h.

Referenced by LV2Wrapper::SetBlockSize(), and SetHost().

◆ mControlIn

LV2AtomPortPtr LV2Effect::mControlIn

private

Definition at line 469 of file LV2Effect.h.

Referenced by SetHost(), and SuilPortWrite().

◆ mControlOut

LV2AtomPortPtr LV2Effect::mControlOut

private

Definition at line 470 of file LV2Effect.h.

Referenced by OnIdle(), and SetHost().

◆ mControlPortMap

std::unordered_map<uint32_t, LV2ControlPortPtr> LV2Effect::mControlPortMap

private

Definition at line 461 of file LV2Effect.h.

Referenced by SetHost(), and SuilPortWrite().

◆ mControlPorts

LV2ControlPortArray LV2Effect::mControlPorts

private

Definition at line 462 of file LV2Effect.h.

Referenced by BuildPlain(), GetAutomationParameters(), GetPortValue(), InitInstance(), IsInteractive(), OnChoice(), OnIdle(), OnSlider(), OnText(), OnToggle(), OnTrigger(), SetAutomationParameters(), SetHost(), SetPortValue(), and TransferDataToWindow().

◆ mCVIn

unsigned LV2Effect::mCVIn

private

Definition at line 475 of file LV2Effect.h.

◆ mCVInBuffers

FloatBuffers LV2Effect::mCVInBuffers

private

Definition at line 500 of file LV2Effect.h.

◆ mCVOut

unsigned LV2Effect::mCVOut

private

Definition at line 476 of file LV2Effect.h.

◆ mCVOutBuffers

FloatBuffers LV2Effect::mCVOutBuffers

private

Definition at line 501 of file LV2Effect.h.

◆ mCVPorts

LV2CVPortArray LV2Effect::mCVPorts

private

Definition at line 474 of file LV2Effect.h.

Referenced by InitInstance(), ProcessInitialize(), RealtimeFinalize(), RealtimeInitialize(), and SetHost().

◆ mDialog

wxDialog* LV2Effect::mDialog

private

Definition at line 511 of file LV2Effect.h.

Referenced by CloseUI(), OnIdle(), OnSize(), and ShowInterface().

◆ mDuration

NumericTextCtrl* LV2Effect::mDuration

private

Definition at line 559 of file LV2Effect.h.

Referenced by BuildPlain(), and ValidateUI().

◆ mExtensionDataFeature

LV2_Extension_Data_Feature LV2Effect::mExtensionDataFeature

private

Definition at line 523 of file LV2Effect.h.

Referenced by BuildFancy(), and SetHost().

◆ mExternalUIClosed

bool LV2Effect::mExternalUIClosed

private

Definition at line 527 of file LV2Effect.h.

Referenced by OnIdle(), and UIClosed().

◆ mExternalUIHost

LV2_External_UI_Host LV2Effect::mExternalUIHost

private

Definition at line 525 of file LV2Effect.h.

Referenced by SetHost().

◆ mExternalWidget

LV2_External_UI_Widget* LV2Effect::mExternalWidget

private

Definition at line 526 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), and OnTimer().

◆ mFactoryPresetNames

RegistryPaths LV2Effect::mFactoryPresetNames

private

Definition at line 562 of file LV2Effect.h.

Referenced by GetFactoryPresets().

◆ mFactoryPresetsLoaded

bool LV2Effect::mFactoryPresetsLoaded

private

Definition at line 561 of file LV2Effect.h.

Referenced by GetFactoryPresets().

◆ mFactoryPresetUris

wxArrayString LV2Effect::mFactoryPresetUris

private

Definition at line 563 of file LV2Effect.h.

Referenced by GetFactoryPresets(), and LoadFactoryPreset().

◆ mFeatures

std::vector<std::unique_ptr<LV2_Feature> > LV2Effect::mFeatures

private

Definition at line 537 of file LV2Effect.h.

Referenced by AddFeature(), BuildFancy(), CheckFeatures(), and InitInstance().

◆ mForge

LV2_Atom_Forge LV2Effect::mForge

private

Definition at line 529 of file LV2Effect.h.

Referenced by ProcessBlock(), RealtimeProcessStart(), and SetHost().

◆ mFramePos

size_t LV2Effect::mFramePos

private

Definition at line 498 of file LV2Effect.h.

◆ mFreewheeling

bool LV2Effect::mFreewheeling

private

Definition at line 543 of file LV2Effect.h.

◆ mGroupMap

std::unordered_map<wxString, std::vector<int> > LV2Effect::mGroupMap

private

Definition at line 478 of file LV2Effect.h.

Referenced by BuildPlain(), SetHost(), and TransferDataToWindow().

◆ mGroups

wxArrayString LV2Effect::mGroups

private

Definition at line 479 of file LV2Effect.h.

Referenced by BuildPlain(), SetHost(), and TransferDataToWindow().

◆ mHost

EffectHostInterface* LV2Effect::mHost

private

Definition at line 451 of file LV2Effect.h.

Referenced by BuildPlain(), LoadFactoryDefaults(), LoadParameters(), LV2EffectSettingsDialog::OnOk(), PopulateUI(), SaveParameters(), SetHost(), ShowInterface(), ShowOptions(), and ValidateUI().

◆ mInstanceAccessFeature

LV2_Feature* LV2Effect::mInstanceAccessFeature

private

Definition at line 539 of file LV2Effect.h.

Referenced by BuildFancy(), and SetHost().

◆ mLatencyDone

bool LV2Effect::mLatencyDone

private

Definition at line 488 of file LV2Effect.h.

Referenced by GetLatency(), and ProcessInitialize().

◆ mLatencyPort

int LV2Effect::mLatencyPort

private

Definition at line 487 of file LV2Effect.h.

Referenced by GetLatency(), LV2Wrapper::Instantiate(), and SetHost().

◆ mLength

double LV2Effect::mLength

private

Definition at line 507 of file LV2Effect.h.

◆ mLogFeature

LV2_Log_Log LV2Effect::mLogFeature

private

Definition at line 522 of file LV2Effect.h.

Referenced by SetHost().

◆ mMaster

LV2Wrapper* LV2Effect::mMaster

private

Definition at line 492 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), GetLatency(), InitInstance(), IsReady(), LoadFactoryPreset(), PopulateUI(), RealtimeFinalize(), RealtimeInitialize(), RealtimeProcessEnd(), SetBlockSize(), and SetSampleRate().

◆ mMasterIn

FloatBuffers LV2Effect::mMasterIn

private

Definition at line 496 of file LV2Effect.h.

Referenced by RealtimeFinalize(), RealtimeInitialize(), RealtimeProcess(), RealtimeProcessEnd(), and RealtimeProcessStart().

◆ mMasterOut

FloatBuffers LV2Effect::mMasterOut

private

Definition at line 496 of file LV2Effect.h.

Referenced by RealtimeFinalize(), RealtimeInitialize(), and RealtimeProcessEnd().

◆ mMaxBlockSize

int LV2Effect::mMaxBlockSize

private

Definition at line 458 of file LV2Effect.h.

Referenced by SetBlockSize(), and SetHost().

◆ mMidiIn

unsigned LV2Effect::mMidiIn

private

Definition at line 471 of file LV2Effect.h.

Referenced by GetMidiInCount(), and SetHost().

◆ mMidiOut

unsigned LV2Effect::mMidiOut

private

Definition at line 472 of file LV2Effect.h.

Referenced by GetMidiOutCount(), and SetHost().

◆ mMinBlockSize

int LV2Effect::mMinBlockSize

private

Definition at line 457 of file LV2Effect.h.

Referenced by SetBlockSize(), and SetHost().

◆ mNativeWin

NativeWindow* LV2Effect::mNativeWin

private

Definition at line 548 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), OnSize(), and UIResize().

◆ mNativeWinInitialSize

wxSize LV2Effect::mNativeWinInitialSize

private

Definition at line 549 of file LV2Effect.h.

Referenced by BuildFancy(), and UIResize().

◆ mNativeWinLastSize

wxSize LV2Effect::mNativeWinLastSize

private

Definition at line 550 of file LV2Effect.h.

Referenced by BuildFancy(), and OnSize().

◆ mNoResize

bool LV2Effect::mNoResize

private

Definition at line 484 of file LV2Effect.h.

Referenced by BuildFancy(), CheckFeatures(), OnSize(), and ShowInterface().

◆ mNumSamples

size_t LV2Effect::mNumSamples

private

Definition at line 497 of file LV2Effect.h.

Referenced by RealtimeProcess(), RealtimeProcessEnd(), and RealtimeProcessStart().

◆ mOptions

std::vector<LV2_Options_Option> LV2Effect::mOptions

private

Definition at line 531 of file LV2Effect.h.

Referenced by AddOption(), CheckOptions(), LV2Wrapper::SetBlockSize(), SetHost(), and LV2Wrapper::SetSampleRate().

◆ mParent

wxWindow* LV2Effect::mParent

private

Definition at line 512 of file LV2Effect.h.

Referenced by BuildFancy(), BuildPlain(), CloseUI(), OnSize(), PopulateUI(), ShowOptions(), TransferDataFromWindow(), TransferDataToWindow(), and ValidateUI().

◆ mParentFeature

LV2_Feature* LV2Effect::mParentFeature

private

Definition at line 540 of file LV2Effect.h.

Referenced by BuildFancy(), and SetHost().

◆ mPlug

URIDLIST const LilvPlugin* LV2Effect::mPlug

private

Definition at line 449 of file LV2Effect.h.

Referenced by BuildFancy(), CheckFeatures(), CheckOptions(), GetFactoryPresets(), GetPath(), GetSymbol(), GetVendor(), InitInstance(), SetHost(), and SuilPortIndex().

◆ mPositionFrame

float LV2Effect::mPositionFrame

private

Definition at line 505 of file LV2Effect.h.

Referenced by ProcessBlock(), RealtimeProcess(), RealtimeProcessStart(), RealtimeResume(), and RealtimeSuspend().

◆ mPositionSpeed

float LV2Effect::mPositionSpeed

private

Definition at line 504 of file LV2Effect.h.

Referenced by ProcessBlock(), RealtimeProcessStart(), RealtimeResume(), and RealtimeSuspend().

◆ mProcess

LV2Wrapper* LV2Effect::mProcess

private

Definition at line 493 of file LV2Effect.h.

Referenced by ProcessBlock(), ProcessFinalize(), and ProcessInitialize().

◆ mResizing

bool LV2Effect::mResizing

private

Definition at line 551 of file LV2Effect.h.

Referenced by OnSize().

◆ mRolling

bool LV2Effect::mRolling

private

Definition at line 489 of file LV2Effect.h.

Referenced by RealtimeProcess(), RealtimeProcessEnd(), RealtimeResume(), and RealtimeSuspend().

◆ mSampleRate

float LV2Effect::mSampleRate

private

Definition at line 453 of file LV2Effect.h.

Referenced by BuildPlain(), OnSlider(), OnText(), PopulateUI(), ProcessInitialize(), SetAutomationParameters(), SetHost(), SetSampleRate(), and TransferDataToWindow().

◆ mSampleRateOption

size_t LV2Effect::mSampleRateOption

private

Definition at line 533 of file LV2Effect.h.

Referenced by SetHost(), and LV2Wrapper::SetSampleRate().

◆ mSeqSize

int LV2Effect::mSeqSize

private

Definition at line 455 of file LV2Effect.h.

Referenced by SetHost().

◆ mSlaves

std::vector<LV2Wrapper *> LV2Effect::mSlaves

private

Definition at line 494 of file LV2Effect.h.

Referenced by RealtimeAddProcessor(), RealtimeFinalize(), RealtimeProcess(), SetBlockSize(), and SetSampleRate().

◆ mSuilHost

SuilHost* LV2Effect::mSuilHost

private

Definition at line 545 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), and PopulateUI().

◆ mSuilInstance

SuilInstance* LV2Effect::mSuilInstance

private

Definition at line 546 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), OnIdle(), PopulateUI(), and TransferDataToWindow().

◆ mSupportsNominalBlockLength

bool LV2Effect::mSupportsNominalBlockLength

private

Definition at line 534 of file LV2Effect.h.

Referenced by CheckOptions(), and LV2Wrapper::SetBlockSize().

◆ mSupportsSampleRate

bool LV2Effect::mSupportsSampleRate

private

Definition at line 535 of file LV2Effect.h.

Referenced by CheckOptions(), and LV2Wrapper::SetSampleRate().

◆ mTimer

wxTimer LV2Effect::mTimer

private

Definition at line 509 of file LV2Effect.h.

Referenced by BuildFancy().

◆ mUIHost

EffectUIHostInterface* LV2Effect::mUIHost

private

Definition at line 513 of file LV2Effect.h.

Referenced by CloseUI(), and SetHostUI().

◆ mUIIdleInterface

LV2UI_Idle_Interface* LV2Effect::mUIIdleInterface

private

Definition at line 556 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), and OnIdle().

◆ mUIResizeFeature

LV2UI_Resize LV2Effect::mUIResizeFeature

private

Definition at line 521 of file LV2Effect.h.

Referenced by SetHost().

◆ mUIShowInterface

LV2UI_Show_Interface* LV2Effect::mUIShowInterface

private

Definition at line 557 of file LV2Effect.h.

Referenced by BuildFancy(), CloseUI(), and OnIdle().

◆ mURIDMap

URIDMap LV2Effect::mURIDMap

private

Definition at line 437 of file LV2Effect.h.

Referenced by URID_Map(), and URID_Unmap().

◆ mURIDMapFeature

LV2_URID_Map LV2Effect::mURIDMapFeature

private

Definition at line 519 of file LV2Effect.h.

Referenced by LoadFactoryPreset(), and SetHost().

◆ mURIDUnmapFeature

LV2_URID_Unmap LV2Effect::mURIDUnmapFeature

private

Definition at line 520 of file LV2Effect.h.

Referenced by SetHost().

◆ mUriMapFeature

LV2_URI_Map_Feature LV2Effect::mUriMapFeature

private

Definition at line 518 of file LV2Effect.h.

Referenced by SetHost().

◆ mUseGUI

bool LV2Effect::mUseGUI

private

Definition at line 515 of file LV2Effect.h.

Referenced by IsGraphicalUI(), PopulateUI(), SetHost(), and TransferDataToWindow().

◆ mUseLatency

bool LV2Effect::mUseLatency

private

Definition at line 486 of file LV2Effect.h.

Referenced by GetLatency(), SetHost(), and ShowOptions().

◆ mUserBlockSize

int LV2Effect::mUserBlockSize

private

Definition at line 459 of file LV2Effect.h.

Referenced by SetBlockSize(), SetHost(), and ShowOptions().

◆ mWantsOptionsInterface

bool LV2Effect::mWantsOptionsInterface

private

Definition at line 481 of file LV2Effect.h.

Referenced by SetHost().

◆ mWantsStateInterface

bool LV2Effect::mWantsStateInterface

private

Definition at line 482 of file LV2Effect.h.

Referenced by SetHost().

◆ mWantsWorkerInterface

bool LV2Effect::mWantsWorkerInterface

private

Definition at line 483 of file LV2Effect.h.

Referenced by LV2Wrapper::Instantiate(), and SetHost().

◆ mWorkerScheduleFeature

LV2_Feature* LV2Effect::mWorkerScheduleFeature

private

Definition at line 541 of file LV2Effect.h.

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ LV2Effect()

◆ ~LV2Effect()

Member Function Documentation

◆ AddFeature()

◆ AddOption()

◆ BuildFancy()

◆ BuildPlain()

◆ CanExportPresets()

◆ CheckFeatures()

◆ CheckOptions()

◆ CloseUI()

◆ ExportPresets()

◆ FreeInstance()

◆ get_value_func()

◆ GetAudioInCount()

◆ GetAudioOutCount()

◆ GetAutomationParameters()

◆ GetBlockSize()

◆ GetDescription()

◆ GetFactoryPresets()

◆ GetFamily()

◆ GetLatency()

◆ GetMidiInCount()

◆ GetMidiOutCount()

◆ GetPath()

◆ GetPortValue()

◆ GetSymbol()

◆ GetTailSize()

◆ GetType()

◆ GetVendor()

◆ GetVersion()

◆ HasOptions()

◆ HideUI()

◆ ImportPresets()

◆ InitInstance()

◆ IsDefault()

◆ IsGraphicalUI()

◆ IsInteractive()

◆ IsLegacy()

◆ IsReady()

◆ LoadFactoryDefaults()

◆ LoadFactoryPreset()

◆ LoadParameters()

◆ LoadUserPreset()

◆ log_printf()

◆ log_vprintf()

◆ LogVPrintf()

◆ Lookup_URI()

◆ OnChoice()

◆ OnIdle()

◆ OnSize()

◆ OnSizeWindow()

◆ OnSlider()

◆ OnText()

◆ OnTimer()

◆ OnToggle()

◆ OnTrigger()

◆ PopulateUI()

◆ ProcessBlock()

◆ ProcessFinalize()

◆ ProcessInitialize()

◆ RealtimeAddProcessor()

◆ RealtimeFinalize()

◆ RealtimeInitialize()

◆ RealtimeProcess()

◆ RealtimeProcessEnd()

◆ RealtimeProcessStart()

◆ RealtimeResume()

◆ RealtimeSuspend()

◆ SaveParameters()

◆ SaveUserPreset()