17#pragma GCC diagnostic ignored "-Wparentheses"
18#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
19#elif defined(__clang__)
20#pragma clang diagnostic ignored "-Wparentheses"
21#pragma clang diagnostic ignored "-Wdeprecated-declarations"
30#include <wx/checkbox.h>
32#include <wx/dcbuffer.h>
36#include <wx/msgqueue.h>
39#include <wx/evtloop.h>
44#include <wx/statbox.h>
45#include <wx/stattext.h>
46#include <wx/tokenzr.h>
48#include <wx/scrolwin.h>
52#include "../../ShuttleGui.h"
53#include "../../widgets/valnum.h"
54#include "../../widgets/AudacityMessageBox.h"
55#include "../../widgets/wxPanelWrapper.h"
56#include "../../widgets/NumericTextCtrl.h"
58#include "lv2/buf-size/buf-size.h"
59#include "lv2/instance-access/instance-access.h"
66#include <wx/msw/wrapwin.h>
70#define DEFAULT_BLOCKSIZE 1048576
73#define DEFAULT_SEQSIZE 8192
88 void OnErase(wxEraseEvent &evt);
89 void OnPaint(wxPaintEvent &evt);
90 void OnIdle(wxIdleEvent &evt);
91 void OnSize(wxSizeEvent &evt);
108: wxWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxDEFAULT_CONTROL_BORDER),
111 mLastValue = -mControlPort->mVal;
113 SetBackgroundColour(*wxWHITE);
136 std::unique_ptr<wxDC> dc {wxAutoBufferedPaintDCFactory(
this)};
139 wxRect r = GetClientRect();
140 wxCoord x = r.GetLeft();
141 wxCoord y = r.GetTop();
142 wxCoord w = r.GetWidth();
143 wxCoord h = r.GetHeight();
151 if (val < mControlPort->mMin)
158 dc->SetPen(*wxTRANSPARENT_PEN);
159 dc->SetBrush(wxColour(100, 100, 220));
186 void OnOk(wxCommandEvent &evt);
194 DECLARE_EVENT_TABLE()
207 wxT(
"BufferSize"), mBufferSize, 8192);
209 wxT(
"UseLatency"), mUseLatency,
true);
211 wxT(
"UseGUI"), mUseGUI,
true);
214 PopulateOrExchange(
S);
224 S.StartHorizontalLay(wxEXPAND, 1);
226 S.StartVerticalLay(
false);
232 S.StartStatic(
XO(
"Buffer Size"));
237 S.AddVariableText(
XO(
238"The buffer size controls the number of samples sent to the effect "
239"on each iteration. Smaller values will cause slower processing and "
240"some effects require 8192 samples or less to work properly. However "
241"most effects can accept large buffers and using them will greatly "
242"reduce processing time."),
245 S.StartHorizontalLay(wxALIGN_LEFT);
248 t =
S.TieNumericTextBox(
249 XXO(
"&Buffer Size (8 to %d) samples:")
253 t->SetMinSize(wxSize(100, -1));
254 t->SetValidator(vld);
256 S.EndHorizontalLay();
260 S.StartStatic(
XO(
"Latency Compensation"));
262 S.AddVariableText(
XO(
263"As part of their processing, some LV2 effects must delay returning "
264"audio to Audacity. When not compensating for this delay, you will "
265"notice that small silences have been inserted into the audio. "
266"Enabling this setting will provide that compensation, but it may "
267"not work for all LV2 effects."),
270 S.StartHorizontalLay(wxALIGN_LEFT);
272 S.TieCheckBox(
XXO(
"Enable &compensation"),
275 S.EndHorizontalLay();
279 S.StartStatic(
XO(
"Graphical Mode"));
281 S.AddVariableText(
XO(
282"LV2 effects can have a graphical interface for setting parameter values."
283" A basic text-only method is also available. "
284" Reopen the effect for this to take effect."),
286 S.TieCheckBox(
XXO(
"Enable &graphical interface"),
293 S.EndHorizontalLay();
295 S.AddStandardButtons();
339BEGIN_EVENT_TABLE(
LV2Effect, wxEvtHandler)
356 mSuilInstance = NULL;
363 mMaxBlockSize = mBlockSize;
364 mUserBlockSize = mBlockSize;
367 mLatencyDone =
false;
371 mUIIdleInterface = NULL;
372 mUIShowInterface = NULL;
382 mPositionSpeed = 1.0;
383 mPositionFrame = 0.0;
386 mNativeWinInitialSize = wxDefaultSize;
387 mNativeWinLastSize = wxDefaultSize;
389#if defined(__WXGTK__)
393 mExternalUIHost.plugin_human_id = NULL;
394 mExternalWidget = NULL;
395 mExternalUIClosed =
false;
399 mSupportsNominalBlockLength =
false;
400 mSupportsSampleRate =
false;
423 wxString vendor =
LilvString(lilv_plugin_get_author_name(
mPlug),
true);
535 LilvNode *pluginName = lilv_plugin_get_name(
mPlug);
537 lilv_node_free(pluginName);
543 AddFeature(LV2_BUF_SIZE__boundedBlockLength, NULL);
544 AddFeature(LV2_BUF_SIZE__fixedBlockLength, NULL);
567 auto minLength = lilv_world_get(
gWorld, lilv_plugin_get_uri(
mPlug), node_MinBlockLength, NULL);
570 if (lilv_node_is_int(minLength))
572 int val = lilv_node_as_int(minLength);
578 lilv_node_free(minLength);
581 auto maxLength = lilv_world_get(
gWorld, lilv_plugin_get_uri(
mPlug), node_MaxBlockLength, NULL);
584 if (lilv_node_is_int(maxLength))
586 int val = lilv_node_as_int(maxLength);
592 lilv_node_free(maxLength);
600 auto numPorts = lilv_plugin_get_num_ports(
mPlug);
603 Floats minimumVals {numPorts};
604 Floats maximumVals {numPorts};
605 Floats defaultVals {numPorts};
608 lilv_plugin_get_port_ranges_float(
mPlug,
614 for (
size_t i = 0; i < numPorts; i++)
616 const LilvPort *port = lilv_plugin_get_port_by_index(
mPlug, i);
617 int index = lilv_port_get_index(
mPlug, port);
621 if (lilv_port_is_a(
mPlug, port, node_InputPort))
625 else if (lilv_port_is_a(
mPlug, port, node_OutputPort))
641 if (
auto group = lilv_port_get(
mPlug, port, node_Group)) {
643 gWorld, group, node_Label, NULL),
true);
644 if (groupMsg.empty())
646 gWorld, group, node_Name, NULL),
true);
647 if (groupMsg.empty())
650 lilv_node_free(group);
653 groupName =
XO(
"Effect Settings");
656 uint32_t latencyIndex = lilv_plugin_get_latency_port_index(
mPlug);
659 LilvNode *designation = lilv_port_get(
mPlug, port, node_Designation);
662 if (lilv_port_is_a(
mPlug, port, node_AudioPort))
664 mAudioPorts.push_back(std::make_shared<LV2AudioPort>(port, index, isInput, symbol,
name, groupName));
669 else if (lilv_port_is_a(
mPlug, port, node_ControlPort))
678 mControlPorts.push_back(std::make_shared<LV2ControlPort>(port, index, isInput, symbol,
name, groupName));
682 LilvNode *unit = lilv_port_get(
mPlug, port, node_Unit);
686 LilvNode *symbol = lilv_world_get_symbol(
gWorld, unit);
690 lilv_node_free(symbol);
692 lilv_node_free(unit);
696 LilvScalePoints *points = lilv_port_get_scale_points(
mPlug, port);
697 LILV_FOREACH(scale_points, j, points)
699 const LilvScalePoint *point = lilv_scale_points_get(points, j);
701 controlPort->mScaleValues.push_back(lilv_node_as_float(lilv_scale_point_get_value(point)));
702 controlPort->mScaleLabels.push_back(
LilvString(lilv_scale_point_get_label(point)));
704 lilv_scale_points_free(points);
707 controlPort->mHasLo = !std::isnan(minimumVals[i]);
708 controlPort->mHasHi = !std::isnan(maximumVals[i]);
709 controlPort->mMin = controlPort->mHasLo ? minimumVals[i] : 0.0;
710 controlPort->mMax = controlPort->mHasHi ? maximumVals[i] : 1.0;
711 controlPort->mLo = controlPort->mMin;
712 controlPort->mHi = controlPort->mMax;
713 controlPort->mDef = !std::isnan(defaultVals[i])
715 : controlPort->mHasLo
717 : controlPort->mHasHi
720 controlPort->mVal = controlPort->mDef;
721 controlPort->mLst = controlPort->mVal;
726 if (lilv_port_has_property(
mPlug, port, node_Toggled))
728 controlPort->mToggle =
true;
730 else if (lilv_port_has_property(
mPlug, port, node_Enumeration))
732 controlPort->mEnumeration =
true;
734 else if (lilv_port_has_property(
mPlug, port, node_Integer))
736 controlPort->mInteger =
true;
738 else if (lilv_port_has_property(
mPlug, port, node_SampleRate))
740 controlPort->mSampleRate =
true;
746 if (lilv_port_has_property(
mPlug, port, node_Trigger))
748 controlPort->mTrigger =
true;
752 if (lilv_port_has_property(
mPlug, port, node_Logarithmic))
754 controlPort->mLogarithmic =
true;
757 if (lilv_port_has_property(
mPlug, port, node_Enumeration))
759 controlPort->mEnumeration =
true;
766 if (controlPort->mIndex == latencyIndex)
773 else if (lilv_port_is_a(
mPlug, port, node_AtomPort))
775 mAtomPorts.push_back(std::make_shared<LV2AtomPort>(port, index, isInput, symbol,
name, groupName));
776 std::shared_ptr<LV2AtomPort> atomPort =
mAtomPorts.back();
778 atomPort->mMinimumSize = 8192;
779 LilvNode *
min = lilv_port_get(
mPlug, port, node_MinimumSize);
782 if (lilv_node_is_int(
min))
784 uint32_t val = lilv_node_as_int(
min);
785 if (atomPort->mMinimumSize < val)
787 atomPort->mMinimumSize = val;
793 atomPort->mBuffer.resize(atomPort->mMinimumSize);
797 if (lilv_port_supports_event(
mPlug, port, node_Position))
799 atomPort->mWantsPosition =
true;
802 if (lilv_port_supports_event(
mPlug, port, node_MidiEvent))
804 atomPort->mIsMidi =
true;
808 bool isControl = lilv_node_equals(designation, node_Control);
825 else if (lilv_port_is_a(
mPlug, port, node_CVPort))
827 mCVPorts.push_back(std::make_shared<LV2CVPort>(port, index, isInput, symbol,
name, groupName));
828 std::shared_ptr<LV2CVPort> cvPort =
mCVPorts.back();
831 if (!std::isnan(minimumVals[i]))
833 cvPort->mHasLo =
true;
834 cvPort->mMin = minimumVals[i];
837 if (!std::isnan(maximumVals[i]))
839 cvPort->mHasHi =
true;
840 cvPort->mMax = maximumVals[i];
843 if (!std::isnan(defaultVals[i]))
845 cvPort->mDef = defaultVals[i];
847 else if (cvPort->mHasLo)
849 cvPort->mDef = cvPort->mMin;
851 else if (cvPort->mHasHi)
853 cvPort->mDef = cvPort->mMax;
860 lilv_node_free(designation);
876 LilvNodes *extdata = lilv_plugin_get_extension_data(
mPlug);
879 LILV_FOREACH(nodes, i, extdata)
881 const LilvNode *node = lilv_nodes_get(extdata, i);
882 const char *uri = lilv_node_as_string(node);
884 if (strcmp(uri, LV2_OPTIONS__interface) == 0)
888 else if (strcmp(uri, LV2_WORKER__interface) == 0)
892 else if (strcmp(uri, LV2_STATE__interface) == 0)
897 lilv_nodes_free(extdata);
912 wxT(
"BufferSize"), userBlockSize, 8192);
923 return std::make_shared<Instance>(*
this);
955 for (
size_t i = 0, cnt =
mSlaves.size(); i < cnt; i++)
979 for (
size_t i = 0, cnt =
mSlaves.size(); i < cnt; i++)
1014 port->mBuffer.reinit((
unsigned)
mBlockSize, port->mIsInput);
1037 const float *
const *inbuf,
float *
const *outbuf,
size_t size)
1048 lilv_instance_connect_port(instance,
1050 const_cast<float*
>(port->mIsInput ? inbuf[i++] : outbuf[o++]));
1060 uint8_t *buf = port->mBuffer.data();
1064 lv2_atom_forge_set_buffer(&
mForge,
1066 port->mBuffer.size());
1068 LV2_Atom_Forge_Frame seqFrame;
1069 LV2_Atom_Sequence *seq = ( LV2_Atom_Sequence *)
1070 lv2_atom_forge_sequence_head(&
mForge, &seqFrame, 0);
1072 if (port->mWantsPosition)
1076 LV2_Atom_Forge_Frame posFrame;
1077 lv2_atom_forge_object(&
mForge, &posFrame, 0, urid_Position);
1078 lv2_atom_forge_key(&
mForge, urid_Speed);
1080 lv2_atom_forge_key(&
mForge, urid_Frame);
1082 lv2_atom_forge_pop(&
mForge, &posFrame);
1089 if (
mForge.offset +
sizeof(LV2_Atom_Event) + atom.size <
mForge.size)
1093 lv2_atom_forge_write(&
mForge, &atom,
sizeof(atom));
1095 mForge.offset += atom.size;
1096 seq->atom.size += atom.size;
1101 wxLogError(wxT(
"LV2 sequence buffer overflow"));
1105 lv2_atom_forge_pop(&
mForge, &seqFrame);
1109 port->mBuffer.resize(port->mMinimumSize);
1110 *(( LV2_Atom *) buf) =
1118 lilv_instance_run(instance,
size);
1124 if (!port->mIsInput)
1126 port->mBuffer.resize(port->mMinimumSize);
1128 LV2_Atom *chunk = ( LV2_Atom *) port->mBuffer.data();
1129 chunk->size = port->mMinimumSize;
1130 chunk->type = urid_Chunk;
1142 port->mBuffer.reinit((
unsigned)
mBlockSize, port->mIsInput);
1153return GuardedCall<bool>([&]{
1154 for (
auto & slave : mSlaves)
1156 FreeInstance(slave);
1162 lilv_instance_deactivate(mMaster->GetInstance());
1166 for (
auto & port : mCVPorts)
1168 port->mBuffer.reset();
1232 uint8_t *buf = port->mBuffer.data();
1236 lv2_atom_forge_set_buffer(&
mForge,
1238 port->mBuffer.size());
1240 LV2_Atom_Forge_Frame seqFrame;
1241 LV2_Atom_Sequence *seq = (LV2_Atom_Sequence *)
1242 lv2_atom_forge_sequence_head(&
mForge, &seqFrame, 0);
1244 if (port->mWantsPosition)
1248 LV2_Atom_Forge_Frame posFrame;
1249 lv2_atom_forge_object(&
mForge, &posFrame, 0, urid_Position);
1250 lv2_atom_forge_key(&
mForge, urid_Speed);
1252 lv2_atom_forge_key(&
mForge, urid_Frame);
1254 lv2_atom_forge_pop(&
mForge, &posFrame);
1261 if (
mForge.offset +
sizeof(LV2_Atom_Event) + atom.size <
mForge.size)
1265 lv2_atom_forge_write(&
mForge, &atom,
sizeof(atom));
1267 mForge.offset += atom.size;
1268 seq->atom.size += atom.size;
1273 wxLogError(wxT(
"LV2 sequence buffer overflow"));
1276 lv2_atom_forge_pop(&
mForge, &seqFrame);
1278 LV2_ATOM_SEQUENCE_FOREACH(seq, ev)
1280 LV2_Atom_Object *o = (LV2_Atom_Object *) &ev->body;
1281 wxLogDebug(wxT(
"ev = %lld ev.size %d ev.type %d"), ev->time.frames, ev->body.size, ev->body.type);
1287 port->mBuffer.resize(port->mMinimumSize);
1288 *((LV2_Atom *) buf) =
1300 const float *
const *inbuf,
float *
const *outbuf,
size_t numSamples)
1302 wxASSERT(group >= 0 && group < (
int)
mSlaves.size());
1305 if (group < 0 || group >= (
int)
mSlaves.size())
1319 for (
decltype(numSamples) s = 0; s < numSamples; s++)
1325 lilv_instance_connect_port(instance,
1327 const_cast<float*
>(port->mIsInput ? inbuf[i++] : outbuf[o++]));
1334 lilv_instance_run(instance, numSamples);
1340 for (
decltype(numSamples) s = 0; s < numSamples; s++)
1342 outbuf[i][s] = inbuf[i][s];
1351 uint8_t *buf = port->mBuffer.data();
1353 if (!port->mIsInput)
1355 port->mBuffer.resize(port->mMinimumSize);
1357 LV2_Atom *chunk = ( LV2_Atom *) buf;
1358 chunk->size = port->mMinimumSize;
1359 chunk->type = LV2Symbols::urid_Chunk;
1373return GuardedCall<bool>([&]{
1375 if (mNumSamples == 0)
1380 for (
auto & port : mAtomPorts)
1382 if (!port->mIsInput)
1384 ZixRing *ring = port->mRing;
1386 LV2_ATOM_SEQUENCE_FOREACH((LV2_Atom_Sequence *) port->mBuffer.data(), ev)
1388 zix_ring_write(ring, &ev->body, ev->body.size + sizeof(LV2_Atom));
1400 wxWindow &parent, wxDialog &dialog,
bool forceModal)
1430 if (!parms.Write(port->mName, port->mVal))
1449 if (!parms.Read(port->mName, &d))
1455 if (d < port->mMin || d > port->mMax)
1468 if (!parms.Read(port->mName, &d))
1474 port->mTmp = port->mVal * (port->mSampleRate ?
mSampleRate : 1.0);
1488 auto parent =
S.GetParent();
1491 mParent->PushEventHandler(
this);
1527 return std::make_unique<DefaultEffectUIValidator>(*
this, access);
1546#ifdef __WX_EVTLOOP_BUSY_WAITING__
1547 wxEventLoop::SetBusyWaiting(
false);
1551 mParent->RemoveEventHandler(
this);
1619 LilvNodes *presets = lilv_plugin_get_related(
mPlug, node_Preset);
1622 LILV_FOREACH(nodes, i, presets)
1624 const LilvNode *
preset = lilv_nodes_get(presets, i);
1630 LilvNodes *labels = lilv_world_find_nodes(
gWorld,
preset, node_Label, NULL);
1633 const LilvNode *
label = lilv_nodes_get_first(labels);
1637 lilv_nodes_free(labels);
1645 lilv_nodes_free(presets);
1678 lilv_state_free(state);
1685 return state != NULL;
1709 if (dlg.ShowModal() == wxID_OK)
1768 mOptions[ndx].context = LV2_OPTIONS_INSTANCE;
1796 if (
CheckFeatures(subject, LV2Symbols::node_RequiredFeature,
true))
1798 return CheckFeatures(subject, LV2Symbols::node_OptionalFeature,
false);
1806 bool supported =
true;
1812 LILV_FOREACH(nodes, i, nodes)
1814 const LilvNode *node = lilv_nodes_get(nodes, i);
1815 const char *uri = lilv_node_as_string(node);
1817 if ((strcmp(uri, LV2_UI__noUserResize) == 0) ||
1818 (strcmp(uri, LV2_UI__fixedSize) == 0))
1822 else if (strcmp(uri, LV2_WORKER__schedule) == 0)
1832 if (feature && strcmp(feature->URI, uri) == 0)
1843 wxLogError(wxT(
"%s requires unsupported feature %s"), lilv_node_as_string(lilv_plugin_get_uri(
mPlug)), uri);
1851 lilv_nodes_free(nodes);
1860 if (
CheckOptions(subject, LV2Symbols::node_RequiredOption,
true))
1862 return CheckOptions(subject, LV2Symbols::node_SupportedOption,
false);
1871 bool supported =
true;
1873 LilvNodes *nodes = lilv_world_find_nodes(
gWorld, subject, predicate, NULL);
1876 LILV_FOREACH(nodes, i, nodes)
1878 const LilvNode *node = lilv_nodes_get(nodes, i);
1879 const char *uri = lilv_node_as_string(node);
1882 if (urid == urid_NominalBlockLength)
1886 else if (urid == urid_SampleRate)
1896 if (option.key == urid)
1907 wxLogError(wxT(
"%s requires unsupported option %s"), lilv_node_as_string(lilv_plugin_get_uri(
mPlug)), uri);
1915 lilv_nodes_free(nodes);
1924 if (wrapper == NULL)
1947 lilv_instance_connect_port(instance,
1957 lilv_instance_connect_port(instance, port->mIndex, port->mBuffer.data());
1963 lilv_instance_connect_port(instance, port->mIndex, port->mBuffer.get());
1968 lilv_instance_activate(instance);
1969 lilv_instance_deactivate(instance);
1973 if (!port->mIsInput)
1977 LV2_ATOM_SEQUENCE_FOREACH(( LV2_Atom_Sequence *) port->mBuffer.data(), ev)
1996 const char *nativeType =
1997#if defined(__WXGTK3__)
1999#elif defined(__WXGTK__)
2001#elif defined(__WXMSW__)
2003#elif defined(__WXMAC__)
2008 const LilvUI *ui = NULL;
2009 const LilvNode *uiType = NULL;
2010 LilvUIs *uis = lilv_plugin_get_uis(
mPlug);
2013 LilvNode *containerType = lilv_new_uri(
gWorld, nativeType);
2016 LILV_FOREACH(uis, iter, uis)
2018 ui = lilv_uis_get(uis, iter);
2019 if (lilv_ui_is_supported(ui, suil_ui_supported, containerType, &uiType))
2023 if (lilv_ui_is_a(ui, node_Gtk) || lilv_ui_is_a(ui, node_Gtk3))
2032 lilv_node_free(containerType);
2039 LILV_FOREACH(uis, iter, uis)
2041 ui = lilv_uis_get(uis, iter);
2042 if (lilv_ui_is_a(ui, node_ExternalUI) || lilv_ui_is_a(ui, node_ExternalUIOld))
2044 uiType = node_ExternalUI;
2058 const LilvNode *uinode = lilv_ui_get_uri(ui);
2059 lilv_world_load_resource(
gWorld, uinode);
2066 const char *containerType;
2068 if (uiType == node_ExternalUI)
2074 containerType = nativeType;
2077#if defined(__WXGTK__)
2079 if (!gtk_widget_get_window(GTK_WIDGET(
mParent->m_wxwindow)))
2081 gtk_widget_realize(GTK_WIDGET(
mParent->m_wxwindow));
2105#if defined(__WXMSW__)
2108 char *libPath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)), NULL);
2109 wxString path = wxPathOnly(libPath);
2110 SetDllDirectory(path.c_str());
2114 char *bundlePath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_bundle_uri(ui)), NULL);
2115 char *binaryPath = lilv_file_uri_parse(lilv_node_as_uri(lilv_ui_get_binary_uri(ui)), NULL);
2120 lilv_node_as_uri(lilv_plugin_get_uri(
mPlug)),
2121 lilv_node_as_uri(lilv_ui_get_uri(ui)),
2122 lilv_node_as_uri(uiType),
2125 reinterpret_cast<const LV2_Feature *
const *
>(
mFeatures.data()));
2127 lilv_free(binaryPath);
2128 lilv_free(bundlePath);
2134#if defined(__WXMSW__)
2135 SetDllDirectory(NULL);
2144 if (uiType == node_ExternalUI)
2146 mParent->SetMinSize(wxDefaultSize);
2156 WXWidget widget = (WXWidget) suil_instance_get_widget(
mSuilInstance);
2158#if defined(__WXGTK__)
2161 gtk_widget_show_all(widget);
2168 if ( !uNativeWin->Create(
mParent, widget) )
2181 wxSizerItem *si = NULL;
2182 auto vs = std::make_unique<wxBoxSizer>(wxVERTICAL);
2185 auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
2191 vs->Add(hs.release(), 1, wxCENTER);
2196 vs->Add(hs.release(), 1, wxEXPAND);
2207 mParent->SetSizerAndFit(vs.release());
2211 suil_instance_extension_data(
mSuilInstance, LV2_UI__idleInterface);
2214 suil_instance_extension_data(
mSuilInstance, LV2_UI__showInterface);
2224#ifdef __WX_EVTLOOP_BUSY_WAITING__
2225 wxEventLoop::SetBusyWaiting(
true);
2229#if defined(__WXMSW__)
2230 SetDllDirectory(NULL);
2239 wxSizer *innerSizer;
2242 wxScrolledWindow *
const w =
safenew
2247 wxVSCROLL | wxTAB_TRAVERSAL);
2250 auto outerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
2251 w->SetScrollRate(0, 20);
2254 w->SetName(wxT(
"\a"));
2255 w->SetLabel(wxT(
"\a"));
2257 outerSizer->Add(w, 1, wxEXPAND);
2260 auto uInnerSizer = std::make_unique<wxBoxSizer>(wxVERTICAL);
2261 innerSizer = uInnerSizer.get();
2266 auto groupSizer = std::make_unique<wxStaticBoxSizer>(wxVERTICAL, w,
_(
"Generator"));
2268 auto sizer = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
2270 wxWindow *item =
safenew wxStaticText(w, 0,
_(
"&Duration:"));
2271 sizer->Add(item, 0, wxALIGN_CENTER | wxALL, 5);
2276 extra.GetDurationFormat(),
2277 extra.GetDuration(),
2282 sizer->Add(
mDuration, 0, wxALIGN_CENTER | wxALL, 5);
2284 groupSizer->Add(sizer.release(), 0, wxALIGN_CENTER | wxALL, 5);
2285 innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
2290 return a.Translation() < b.Translation(); });
2292 for (
size_t i = 0, groupCount =
mGroups.size(); i < groupCount; i++)
2295 auto groupSizer = std::make_unique<wxStaticBoxSizer>(
2298 auto gridSizer = std::make_unique<wxFlexGridSizer>(numCols, 5, 5);
2299 gridSizer->AddGrowableCol(3);
2305 if (port->mNotOnGui)
2310 wxString labelText = port->mName;
2311 if (!port->mUnits.empty())
2313 labelText += wxT(
" (") + port->mUnits + wxT(
")");
2318 gridSizer->Add(1, 1, 0);
2322 gridSizer->Add(b, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
2323 port->mCtrl.button = b;
2325 gridSizer->Add(1, 1, 0);
2326 gridSizer->Add(1, 1, 0);
2327 gridSizer->Add(1, 1, 0);
2331 wxWindow *item =
safenew wxStaticText(w, wxID_ANY, labelText + wxT(
":"),
2332 wxDefaultPosition, wxDefaultSize,
2334 gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
2339 c->SetName(labelText);
2340 c->SetValue(port->mVal > 0);
2341 gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
2342 port->mCtrl.checkbox = c;
2344 gridSizer->Add(1, 1, 0);
2345 gridSizer->Add(1, 1, 0);
2346 gridSizer->Add(1, 1, 0);
2348 else if (port->mEnumeration)
2351 for (s = (
int) port->mScaleValues.size() - 1; s >= 0; s--)
2353 if (port->mVal >= port->mScaleValues[s])
2365 c->SetName(labelText);
2366 c->Append(port->mScaleLabels);
2368 gridSizer->Add(c, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
2369 port->mCtrl.choice = c;
2371 gridSizer->Add(1, 1, 0);
2372 gridSizer->Add(1, 1, 0);
2373 gridSizer->Add(1, 1, 0);
2375 else if (!port->mIsInput)
2377 gridSizer->Add(1, 1, 0);
2378 gridSizer->Add(1, 1, 0);
2381 gridSizer->Add(m, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
2382 port->mCtrl.meter = m;
2384 gridSizer->Add(1, 1, 0);
2389 t->SetName(labelText);
2390 gridSizer->Add(t, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
2393 float rate = port->mSampleRate ?
mSampleRate : 1.0;
2395 port->mLo = port->mMin * rate;
2396 port->mHi = port->mMax * rate;
2397 port->mTmp = port->mVal * rate;
2401 IntegerValidator<float> vld(&port->mTmp);
2402 vld.SetRange(port->mLo, port->mHi);
2403 t->SetValidator(vld);
2407 FloatingPointValidator<float> vld(6, &port->mTmp);
2408 vld.SetRange(port->mLo, port->mHi);
2411 float range = port->mHi - port->mLo;
2412 auto style = range < 10
2413 ? NumValidatorStyle::THREE_TRAILING_ZEROES
2415 ? NumValidatorStyle::TWO_TRAILING_ZEROES
2416 : NumValidatorStyle::ONE_TRAILING_ZERO;
2417 vld.SetStyle(style);
2419 t->SetValidator(vld);
2425 if (port->mInteger || port->mSampleRate)
2427 str.Printf(wxT(
"%d"), (
int)
lrintf(port->mLo));
2433 item =
safenew wxStaticText(w, wxID_ANY,
str);
2434 gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT);
2438 gridSizer->Add(1, 1, 0);
2445 s->SetName(labelText);
2446 gridSizer->Add(s, 0, wxALIGN_CENTER_VERTICAL | wxEXPAND);
2447 port->mCtrl.slider = s;
2452 if (port->mInteger || port->mSampleRate)
2454 str.Printf(wxT(
"%d"), (
int)
lrintf(port->mHi));
2460 item =
safenew wxStaticText(w, wxID_ANY,
str);
2461 gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT);
2465 gridSizer->Add(1, 1, 0);
2470 groupSizer->Add(gridSizer.release(), 1, wxEXPAND | wxALL, 5);
2471 innerSizer->Add(groupSizer.release(), 0, wxEXPAND | wxALL, 5);
2474 innerSizer->Layout();
2477 std::vector<int> widths(numCols);
2479 size_t cnt = innerSizer->GetChildren().GetCount();
2482 wxSizer *groupSizer = innerSizer->GetItem(i)->GetSizer();
2483 wxFlexGridSizer *gridSizer = (wxFlexGridSizer *) groupSizer->GetItem((
size_t) 0)->GetSizer();
2485 size_t items = gridSizer->GetChildren().GetCount();
2486 int cols = gridSizer->GetCols();
2488 for (
size_t j = 0; j < items; j++)
2490 wxSizerItem *item = gridSizer->GetItem(j);
2491 widths[j % cols] = wxMax(widths[j % cols], item->GetSize().GetWidth());
2498 wxSizer *groupSizer = innerSizer->GetItem(i)->GetSizer();
2499 wxFlexGridSizer *gridSizer = (wxFlexGridSizer *) groupSizer->GetItem((
size_t) 0)->GetSizer();
2501 size_t items = gridSizer->GetChildren().GetCount();
2502 int cols = gridSizer->GetCols();
2504 for (
size_t j = 0; j < items; j++)
2506 wxSizerItem *item = gridSizer->GetItem(j);
2508 int flags = item->GetFlag();
2509 if (flags & wxEXPAND)
2514 if (flags & wxALIGN_RIGHT)
2516 flags = (flags & ~wxALL) | wxLEFT;
2520 flags = (flags & ~wxALL) | wxRIGHT;
2522 item->SetFlag(flags);
2524 item->SetBorder(widths[j % cols] - item->GetMinSize().GetWidth());
2528 w->SetSizer(uInnerSizer.release());
2531 mParent->SetSizer(outerSizer.release());
2535 wxSize sz1 = innerSizer->GetMinSize();
2536 wxSize sz2 =
mParent->GetMinSize();
2537 w->SetMinSize( { -1,
std::min(sz1.y, sz2.y) } );
2540 mParent->SetMinSize(w->GetMinSize());
2572 for (
auto & param :
params)
2583 port->mCtrl.checkbox->SetValue(port->mVal > 0);
2585 else if (port->mEnumeration)
2588 for (s = (
int) port->mScaleValues.size() - 1; s >= 0; s--)
2590 if (port->mVal >= port->mScaleValues[s])
2601 port->mCtrl.choice->SetSelection(s);
2603 else if (port->mIsInput)
2605 port->mTmp = port->mVal * (port->mSampleRate ?
mSampleRate : 1.0);
2621 float lo = port->mLo;
2622 float hi = port->mHi;
2623 float val = port->mTmp;
2625 if (port->mLogarithmic)
2632 port->mCtrl.slider->SetValue(
lrintf((val - lo) / (hi - lo) * 1000.0));
2639 port->mVal = port->mDef;
2646 port->mVal = evt.GetInt() ? 1.0 : 0.0;
2653 port->mVal = port->mScaleValues[evt.GetInt()];
2660 if (port->mText->GetValidator()->TransferFromWindow())
2662 port->mVal = port->mSampleRate ? port->mTmp /
mSampleRate : port->mTmp;
2672 float lo = port->mLo;
2673 float hi = port->mHi;
2675 if (port->mLogarithmic)
2681 port->mTmp = (((float) evt.GetInt()) / 1000.0) * (hi - lo) + lo;
2682 port->mTmp = port->mLogarithmic ? expf(port->mTmp) : port->mTmp;
2684 port->mTmp = port->mTmp < port->mLo ? port->mLo : port->mTmp;
2685 port->mTmp = port->mTmp > port->mHi ? port->mHi : port->mTmp;
2687 port->mVal = port->mSampleRate ? port->mTmp /
mSampleRate : port->mTmp;
2689 port->mText->GetValidator()->TransferToWindow();
2720 SuilHandle handle = suil_instance_get_handle(
mSuilInstance);
2736 LV2_Atom *atom = (LV2_Atom *) malloc(
mControlOut->mMinimumSize);
2741 uint32_t
size = lv2_atom_total_size(atom);
2743 if (size < mControlOut->mMinimumSize)
2749 LV2Symbols::urid_EventTransfer,
2755 wxLogError(wxT(
"LV2 sequence buffer overflow"));
2765 if (port->mVal != port->mLst)
2772 port->mLst = port->mVal;
2800 mParent->SetMinSize(wxDefaultSize);
2802#if defined(__WXGTK__)
2812 mDialog->SetMinSize(wxDefaultSize);
2847 const char *WXUNUSED(map),
2850 return ((
LV2Effect *) callback_data)->URID_Map(uri);
2856 return ((
LV2Effect *) handle)->URID_Map(uri);
2882 return ((
LV2Effect *) handle)->URID_Unmap(urid);
2890 if (urid <= (LV2_URID)
gURIDMap.size())
2897 if (urid <= (LV2_URID)
mURIDMap.size())
2913 len = ((
LV2Effect *) handle)->LogVPrintf(type, fmt, ap);
2922 return ((
LV2Effect *) handle)->LogVPrintf(type, fmt, ap);
2928 long level = wxLOG_Error;
2930 if (type == urid_Error)
2932 level = wxLOG_Error;
2934 else if (type == urid_Note)
2938 else if (type == urid_Trace)
2940 level = wxLOG_Trace;
2942 else if (type == urid_Warning)
2944 level = wxLOG_Warning;
2948 level = wxLOG_Message;
2952 int len = wxCRT_VsnprintfA(msg, 0, fmt, ap);
2954 msg = (
char *) malloc(len + 1);
2957 wxCRT_VsnprintfA(msg, len, fmt, ap);
2961 wxLogGeneric(level, wxT(
"%s: %s"),
GetSymbol().Msgid().Translation(), text);
2972 return ((
LV2Effect *) handle)->UIResize(width, height);
2980 wxSizeEvent sw(wxSize(width, height));
2982 mNativeWin->GetEventHandler()->AddPendingEvent(sw);
2996 return ((
LV2Effect *) controller)->UIClosed();
3008 uint32_t port_index,
3009 uint32_t buffer_size,
3013 ((
LV2Effect *) controller)->SuilPortWrite(port_index, buffer_size, protocol, buffer);
3017 uint32_t buffer_size,
3022 if (protocol == 0 && buffer_size ==
sizeof(
float))
3027 it->second->mVal = *((
const float *) buffer);
3031 else if (protocol == LV2Symbols::urid_EventTransfer)
3044 const char *port_symbol)
3046 return ((
LV2Effect *) controller)->SuilPortIndex(port_symbol);
3051 for (
size_t i = 0, cnt = lilv_plugin_get_num_ports(
mPlug); i < cnt; i++)
3053 const LilvPort *port = lilv_plugin_get_port_by_index(
mPlug, i);
3054 if (strcmp(port_symbol, lilv_node_as_string(lilv_port_get_symbol(
mPlug, port))) == 0)
3056 return lilv_port_get_index(
mPlug, port);
3060 return LV2UI_INVALID_PORT_INDEX;
3069 return ((
LV2Effect *) user_data)->GetPortValue(port_symbol,
size, type);
3076 wxString symbol = wxString::FromUTF8(port_symbol);
3080 if (port->mSymbol == symbol)
3082 *
size =
sizeof(float);
3083 *type = LV2Symbols::urid_Float;
3084 return (
void *) &port->mVal;
3101 ((
LV2Effect *) user_data)->SetPortValue(port_symbol, value,
size, type);
3109 wxString symbol = wxString::FromUTF8(port_symbol);
3114 if (port->mSymbol == symbol)
3116 if (type == urid_Bool &&
size ==
sizeof(
bool))
3118 port->mVal = (float) (*((
const bool *) value)) ? 1.0f : 0.0f;
3120 else if (type == urid_Double &&
size ==
sizeof(
double))
3122 port->mVal = (float) (*((
const double *) value));
3124 else if (type == urid_Float &&
size ==
sizeof(
float))
3126 port->mVal = (float) (*((
const float *) value));
3128 else if (type == urid_Int &&
size ==
sizeof(int32_t))
3130 port->mVal = (float) (*((
const int32_t *) value));
3132 else if (type == urid_Long &&
size ==
sizeof(int64_t))
3134 port->mVal = (float) (*((
const int64_t *) value));
3142#if defined(__WXGTK__)
3170 wxSizeEvent se(wxSize(requisition->width, requisition->height));
3172 mNativeWin->GetEventHandler()->AddPendingEvent(se);
3196 wxThread *thread = GetThread();
3197 if (thread && thread->IsAlive())
3220 std::vector<std::unique_ptr<LV2_Feature>> & features)
3225 features.pop_back();
3234#if defined(__WXMSW__)
3237 const LilvNode *
const libNode = lilv_plugin_get_library_uri(plugin);
3238 const char *
const libUri = lilv_node_as_uri(libNode);
3239 char *libPath = lilv_file_uri_parse(libUri, NULL);
3240 wxString path = wxPathOnly(libPath);
3241 SetDllDirectory(path.c_str());
3245 mInstance = lilv_plugin_instantiate(plugin,
3247 reinterpret_cast<LV2_Feature **
>(features.data()));
3249#if defined(__WXMSW__)
3250 SetDllDirectory(NULL);
3256 features.pop_back();
3259 features.pop_back();
3273 lilv_instance_get_extension_data(
mInstance, LV2_OPTIONS__interface);
3276 lilv_instance_get_extension_data(
mInstance, LV2_STATE__interface);
3279 lilv_instance_get_extension_data(
mInstance, LV2_WORKER__interface);
3288 if (CreateThread() == wxTHREAD_NO_ERROR)
3322 LV2_Options_Option options[2] = {};
3336 LV2_Options_Option options[2] = {};
3353 while (
mRequests.Receive(work) == wxMSGQUEUE_NO_ERROR)
3376 while (
mResponses.ReceiveTimeout(0, work) == wxMSGQUEUE_NO_ERROR)
3411 return LV2_WORKER_SUCCESS;
3428 return LV2_WORKER_SUCCESS;
wxEVT_COMMAND_BUTTON_CLICKED
Declare abstract class AudacityException, some often-used subclasses, and GuardedCall.
int AudacityMessageBox(const TranslatableString &message, const TranslatableString &caption, long style, wxWindow *parent, int x, int y)
static const AudacityProject::AttachedObjects::RegisteredFactory key
EVT_BUTTON(wxID_NO, DependencyDialog::OnNo) EVT_BUTTON(wxID_YES
EffectDistortion::Params params
const TranslatableString name
enum ChannelName * ChannelNames
EVT_COMMAND_RANGE(ID_Slider, ID_Slider+NUMBER_OF_BANDS - 1, wxEVT_COMMAND_SLIDER_UPDATED, EffectEqualization::OnSlider) EffectEqualization
wxString PluginPath
type alias for identifying a Plugin supplied by a module, each module defining its own interpretation...
std::vector< RegistryPath > RegistryPaths
#define DEFAULT_BLOCKSIZE
wxString LilvString(const LilvNode *node)
#define LV2EFFECTS_FAMILY
std::shared_ptr< LV2ControlPort > LV2ControlPortPtr
#define LV2_UI__makeResident
std::unique_ptr< T, Destroyer< T > > Destroy_ptr
a convenience for using Destroyer
wxEVT_COMMAND_TEXT_UPDATED
EffectReverbSettings preset
static Settings & settings()
TranslatableString Verbatim(wxString str)
Require calls to the one-argument constructor to go through this distinct global function name.
void reinit(Integral count)
CommandParameters, derived from wxFileConfig, is essentially doing the same things as the SettingsVis...
bool GetParameters(wxString &parms)
bool SetParameters(const wxString &parms)
ComponentInterfaceSymbol pairs a persistent string identifier used internally with an optional,...
Base class for many of the effects in Audacity.
Performs effect computation.
virtual const EffectSettings & Get()=0
static wxString ToDisplayString(double numberToConvert, int digitsAfterDecimalPoint=-1)
Convert a number to a string, uses the user's locale's decimal separator.
VendorSymbol GetVendor() const override
std::unique_ptr< EffectUIValidator > PopulateUI(ShuttleGui &S, EffectInstance &instance, EffectSettingsAccess &access) override
Adds controls to a panel that is given as the parent window of S
LV2_Feature * mParentFeature
LV2AudioPortArray mAudioPorts
bool RealtimeProcessStart(EffectSettings &settings) override
void OnTimer(wxTimerEvent &evt)
bool mFactoryPresetsLoaded
static void ui_closed(LV2UI_Controller controller)
wxSize mNativeWinInitialSize
LV2AtomPortArray mAtomPorts
LV2_Extension_Data_Feature mExtensionDataFeature
bool ValidateOptions(const LilvNode *subject)
PluginPath GetPath() const override
void SuilPortWrite(uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer)
size_t RealtimeProcess(int group, EffectSettings &settings, const float *const *inbuf, float *const *outbuf, size_t numSamples) override
void SetSlider(const LV2ControlPortPtr &port)
void FreeInstance(LV2Wrapper *wrapper)
LV2ControlPortArray mControlPorts
size_t AddOption(LV2_URID, uint32_t size, LV2_URID, const void *value)
RegistryPaths GetFactoryPresets() const override
Report names of factory presets.
size_t GetBlockSize() const override
LV2Wrapper * InitInstance(float sampleRate)
unsigned GetAudioInCount() const override
How many input buffers to allocate at once.
bool SupportsAutomation() const override
Whether the effect has any automatable controls.
LV2AtomPortPtr mControlOut
SuilInstance * mSuilInstance
EffectFamilySymbol GetFamily() const override
Report identifier and user-visible name of the effect protocol.
bool ValidateUI(EffectSettings &) override
void ExportPresets(const EffectSettings &settings) const override
bool DoLoadFactoryPreset(int id)
bool RealtimeProcessEnd(EffectSettings &settings) noexcept override
void ShowOptions() override
bool RealtimeSuspend() override
std::vector< LV2Wrapper * > mSlaves
bool HasOptions() override
void SizeRequest(GtkWidget *widget, GtkRequisition *requisition)
wxWeakRef< wxDialog > mDialog
LV2_URID_Unmap mURIDUnmapFeature
void SetPortValue(const char *port_symbol, const void *value, uint32_t size, uint32_t type)
bool SaveParameters(const RegistryPath &group, const EffectSettings &settings) const
static LV2_URID urid_map(LV2_URID_Map_Handle handle, const char *uri)
std::unordered_map< TranslatableString, std::vector< int > > mGroupMap
int LogVPrintf(LV2_URID type, const char *fmt, va_list ap)
bool CheckFeatures(const LilvNode *subject, const LilvNode *predicate, bool required)
size_t SetBlockSize(size_t maxBlockSize) override
bool DoLoadUserPreset(const RegistryPath &name, EffectSettings &settings)
bool RealtimeAddProcessor(EffectSettings &settings, unsigned numChannels, float sampleRate) override
RegistryPaths mFactoryPresetNames
bool TransferDataToWindow()
void OnTrigger(wxCommandEvent &evt)
static uint32_t uri_to_id(LV2_URI_Map_Callback_Data callback_data, const char *map, const char *uri)
int UIResize(int width, int height)
bool mWantsStateInterface
void SetSampleRate(double rate) override
LV2_External_UI_Widget * mExternalWidget
bool mSupportsNominalBlockLength
bool LoadParameters(const RegistryPath &group, EffectSettings &settings)
void ImportPresets(EffectSettings &settings) override
LV2_URI_Map_Feature mUriMapFeature
sampleCount GetLatency() override
LV2Symbols::URIDMap mURIDMap
bool LoadFactoryPreset(int id, EffectSettings &settings) const override
Change settings to the preset whose name is GetFactoryPresets()[id]
bool SaveSettings(const EffectSettings &settings, CommandParameters &parms) const override
Store settings as keys and values.
bool RealtimeResume() noexcept override
bool ProcessFinalize() override
const char * URID_Unmap(LV2_URID urid)
bool ProcessInitialize(EffectSettings &settings, sampleCount totalLen, ChannelNames chanMap) override
LV2_URID_Map mURIDMapFeature
static void size_request(GtkWidget *widget, GtkRequisition *requisition, LV2Effect *win)
LV2_URID URID_Map(const char *uri)
uint32_t SuilPortIndex(const char *port_symbol)
EffectType GetType() const override
Type determines how it behaves.
bool SupportsRealtime() const override
Whether the effect supports realtime previewing (while audio is playing).
static const char * urid_unmap(LV2_URID_Unmap_Handle handle, LV2_URID urid)
bool RealtimeFinalize(EffectSettings &settings) noexcept override
TranslatableStrings mGroups
unsigned GetAudioOutCount() const override
How many output buffers to allocate at once.
wxString GetVersion() const override
std::vector< LV2_Options_Option > mOptions
NativeWindow * mNativeWin
bool CheckOptions(const LilvNode *subject, const LilvNode *predicate, bool required)
LV2UI_Show_Interface * mUIShowInterface
void OnSlider(wxCommandEvent &evt)
NumericTextCtrl * mDuration
LV2UI_Resize mUIResizeFeature
static int ui_resize(LV2UI_Feature_Handle handle, int width, int height)
wxArrayString mFactoryPresetUris
wxSize mNativeWinLastSize
const void * GetPortValue(const char *port_symbol, uint32_t *size, uint32_t *type)
bool mWantsOptionsInterface
bool ValidateFeatures(const LilvNode *subject)
ComponentInterfaceSymbol GetSymbol() const override
size_t ProcessBlock(EffectSettings &settings, const float *const *inBlock, float *const *outBlock, size_t blockLen) override
Called for destructive effect computation.
static void set_value_func(const char *port_symbol, void *user_data, const void *value, uint32_t size, uint32_t type)
void OnText(wxCommandEvent &evt)
static int log_vprintf(LV2_Log_Handle handle, LV2_URID type, const char *fmt, va_list ap)
std::unordered_map< uint32_t, LV2ControlPortPtr > mControlPortMap
LV2_Feature * AddFeature(const char *uri, void *data)
int GetMidiOutCount() const override
Function that has not yet found a use.
bool LoadSettings(const CommandParameters &parms, EffectSettings &settings) const override
Restore settings from keys and values.
LV2AtomPortPtr mControlIn
std::shared_ptr< EffectInstance > MakeInstance() const override
Make an object maintaining short-term state of an Effect.
bool IsInteractive() const override
Whether the effect needs a dialog for entry of settings.
bool CanExportPresets() override
bool LoadUserPreset(const RegistryPath &name, EffectSettings &settings) const override
Change settings to a user-named preset.
void OnChoice(wxCommandEvent &evt)
bool mWantsWorkerInterface
void OnIdle(wxIdleEvent &evt)
std::shared_ptr< EffectInstance > DoMakeInstance()
LV2_External_UI_Host mExternalUIHost
void OnSize(wxSizeEvent &evt)
LV2_Feature * mInstanceAccessFeature
TranslatableString GetDescription() const override
bool SaveUserPreset(const RegistryPath &name, const EffectSettings &settings) const override
Save settings in the configuration file as a user-named preset.
bool RealtimeInitialize(EffectSettings &settings) override
static const void * get_value_func(const char *port_symbol, void *user_data, uint32_t *size, uint32_t *type)
bool IsGraphicalUI() override
std::vector< std::unique_ptr< LV2_Feature > > mFeatures
static void suil_port_write_func(SuilController controller, uint32_t port_index, uint32_t buffer_size, uint32_t protocol, const void *buffer)
void OnToggle(wxCommandEvent &evt)
static int log_printf(LV2_Log_Handle handle, LV2_URID type, const char *fmt,...)
LV2UI_Idle_Interface * mUIIdleInterface
static uint32_t suil_port_index_func(SuilController controller, const char *port_symbol)
int ShowClientInterface(wxWindow &parent, wxDialog &dialog, bool forceModal) override
int GetMidiInCount() const override
Function that has not yet found a use.
bool IsDefault() const override
Whether the effect sorts "above the line" in the menus.
bool BuildPlain(EffectSettingsAccess &access)
void OnErase(wxEraseEvent &evt)
LV2EffectMeter(wxWindow *parent, const LV2ControlPortPtr ctrl)
const LV2ControlPortPtr mControlPort
void OnPaint(wxPaintEvent &evt)
void OnSize(wxSizeEvent &evt)
void OnIdle(wxIdleEvent &evt)
virtual ~LV2EffectMeter()
void PopulateOrExchange(ShuttleGui &S)
LV2EffectSettingsDialog(wxWindow *parent, LV2Effect &effect)
virtual ~LV2EffectSettingsDialog()
void OnOk(wxCommandEvent &evt)
LV2_Worker_Interface * mWorkerInterface
LV2Wrapper(LV2Effect *effect)
static LV2_Worker_Status respond(LV2_Worker_Respond_Handle handle, uint32_t size, const void *data)
LV2_Worker_Status ScheduleWork(uint32_t size, const void *data)
LV2_Worker_Status Respond(uint32_t size, const void *data)
wxMessageQueue< LV2Work > mRequests
LV2_State_Interface * mStateInterface
LilvInstance * Instantiate(const LilvPlugin *plugin, double sampleRrate, std::vector< std::unique_ptr< LV2_Feature > > &features)
void ConnectPorts(float **inbuf, float **outbuf)
void SetFreeWheeling(bool enable)
LV2_Worker_Schedule mWorkerSchedule
static LV2_Worker_Status schedule_work(LV2_Worker_Schedule_Handle handle, uint32_t size, const void *data)
LV2_Options_Interface * mOptionsInterface
LilvInstance * GetInstance()
wxMessageQueue< LV2Work > mResponses
void SetName(const TranslatableString &name)
Derived from ShuttleGuiBase, an Audacity specific class for shuttling data to and from GUI.
Holds a msgid for the translation catalog; may also bind format arguments.
wxString Translation() const
Positions or offsets within audio files need a wide type.
uint32_t zix_ring_read(ZixRing *ring, void *dst, uint32_t size)
ZixRing * zix_ring_new(uint32_t size)
uint32_t zix_ring_write(ZixRing *ring, const void *src, uint32_t size)
uint32_t zix_ring_skip(ZixRing *ring, uint32_t size)
void zix_ring_mlock(ZixRing *ring)
#define LV2_EXTERNAL_UI_SHOW(ptr)
#define LV2_EXTERNAL_UI_DEPRECATED_URI
#define LV2_EXTERNAL_UI_RUN(ptr)
#define LV2_EXTERNAL_UI__Widget
#define LV2_EXTERNAL_UI__Host
LV2_URID Lookup_URI(URIDMap &map, const char *uri, bool add)
URIDMap gURIDMap
Declare the global map of positive integers to URIs.
bool SetConfig(const EffectDefinitionInterface &ident, ConfigurationType type, const RegistryPath &group, const RegistryPath &key, const Value &value)
bool GetConfig(const EffectDefinitionInterface &ident, ConfigurationType type, const RegistryPath &group, const RegistryPath &key, Value &var, const Value &defval)
std::string ToUTF8(const std::wstring &wstr)
const char * plugin_human_id
void(* ui_closed)(LV2UI_Controller controller)
Externalized state of a plug-in.
EffectSettingsExtra extra
Options & AutoPos(bool enable)
uint32_t size
Size (capacity) in bytes.