2 Copyright (C) 2008 Paul Davis
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
28 #include <pbd/compose.h>
29 #include <pbd/error.h>
30 #include <pbd/pathscanner.h>
31 #include <pbd/xml++.h>
33 #include <ardour/ardour.h>
34 #include <ardour/session.h>
35 #include <ardour/audioengine.h>
36 #include <ardour/lv2_plugin.h>
38 #include <pbd/stl_delete.h>
44 using namespace ARDOUR
;
47 LV2Plugin::LV2Plugin (AudioEngine
& e
, Session
& session
, LV2World
& world
, SLV2Plugin plugin
, nframes_t rate
)
52 init (world
, plugin
, rate
);
55 LV2Plugin::LV2Plugin (const LV2Plugin
&other
)
57 , _world(other
._world
)
60 init (other
._world
, other
._plugin
, other
._sample_rate
);
62 for (uint32_t i
= 0; i
< parameter_count(); ++i
) {
63 _control_data
[i
] = other
._shadow_data
[i
];
64 _shadow_data
[i
] = other
._shadow_data
[i
];
69 LV2Plugin::init (LV2World
& world
, SLV2Plugin plugin
, nframes_t rate
)
76 _latency_control_port
= 0;
77 _was_activated
= false;
79 _instance
= slv2_plugin_instantiate(plugin
, rate
, _features
);
80 _name
= slv2_plugin_get_name(plugin
);
82 _author
= slv2_plugin_get_author_name(plugin
);
85 error
<< _("LV2: Failed to instantiate plugin ") << slv2_plugin_get_uri(plugin
) << endl
;
86 throw failed_constructor();
89 if (slv2_plugin_has_feature(plugin
, world
.in_place_broken
)) {
90 error
<< string_compose(_("LV2: \"%1\" cannot be used, since it cannot do inplace processing"),
91 slv2_value_as_string(_name
));
92 slv2_value_free(_name
);
93 slv2_value_free(_author
);
94 throw failed_constructor();
97 _instance_access_feature
.URI
= "http://lv2plug.in/ns/ext/instance-access";
98 _instance_access_feature
.data
= (void*)_instance
->lv2_handle
;
100 _data_access_extension_data
.extension_data
= _instance
->lv2_descriptor
->extension_data
;
101 _data_access_feature
.URI
= "http://lv2plug.in/ns/ext/data-access";
102 _data_access_feature
.data
= &_data_access_extension_data
;
104 _features
= (LV2_Feature
**)malloc(sizeof(LV2_Feature
*) * 3);
105 _features
[0] = &_instance_access_feature
;
106 _features
[1] = &_data_access_feature
;
111 const uint32_t num_ports
= slv2_plugin_get_num_ports(plugin
);
113 _control_data
= new float[num_ports
];
114 _shadow_data
= new float[num_ports
];
115 _defaults
= new float[num_ports
];
117 const bool latent
= slv2_plugin_has_latency(plugin
);
118 uint32_t latency_port
= (latent
? slv2_plugin_get_latency_port_index(plugin
) : 0);
120 for (uint32_t i
= 0; i
< num_ports
; ++i
) {
121 if (parameter_is_control(i
)) {
122 SLV2Port port
= slv2_plugin_get_port_by_index(plugin
, i
);
124 slv2_port_get_range(plugin
, port
, &def
, NULL
, NULL
);
125 _defaults
[i
] = def
? slv2_value_as_float(def
) : 0.0f
;
126 slv2_value_free(def
);
128 slv2_instance_connect_port (_instance
, i
, &_control_data
[i
]);
130 if (latent
&& i
== latency_port
) {
131 _latency_control_port
= &_control_data
[i
];
132 *_latency_control_port
= 0;
135 if (parameter_is_input(i
)) {
136 _shadow_data
[i
] = default_value (i
);
143 SLV2UIs uis
= slv2_plugin_get_uis(_plugin
);
144 if (slv2_uis_size(uis
) > 0) {
145 for (unsigned i
=0; i
< slv2_uis_size(uis
); ++i
) {
146 SLV2UI ui
= slv2_uis_get_at(uis
, i
);
147 if (slv2_ui_is_a(ui
, _world
.gtk_gui
)) {
154 Plugin::setup_controls ();
156 latency_compute_run ();
159 LV2Plugin::~LV2Plugin ()
164 GoingAway (); /* EMIT SIGNAL */
166 slv2_instance_free(_instance
);
167 slv2_value_free(_name
);
168 slv2_value_free(_author
);
171 delete [] _control_data
;
175 delete [] _shadow_data
;
180 LV2Plugin::unique_id() const
182 return slv2_value_as_uri(slv2_plugin_get_uri(_plugin
));
187 LV2Plugin::default_value (uint32_t port
)
189 return _defaults
[port
];
193 LV2Plugin::port_symbol (uint32_t index
)
195 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, index
);
197 error
<< name() << ": Invalid port index " << index
<< endmsg
;
200 SLV2Value sym
= slv2_port_get_symbol(_plugin
, port
);
201 return slv2_value_as_string(sym
);
206 LV2Plugin::set_parameter (uint32_t which
, float val
)
208 if (which
< slv2_plugin_get_num_ports(_plugin
)) {
209 _shadow_data
[which
] = val
;
210 ParameterChanged (which
, val
); /* EMIT SIGNAL */
212 if (which
< parameter_count() && controls
[which
]) {
213 controls
[which
]->Changed ();
217 warning
<< string_compose (_("Illegal parameter number used with plugin \"%1\"."
218 "This is a bug in either Ardour or the LV2 plugin (%2)"),
219 name(), unique_id()) << endmsg
;
224 LV2Plugin::get_parameter (uint32_t which
) const
226 if (parameter_is_input(which
)) {
227 return (float) _shadow_data
[which
];
229 return (float) _control_data
[which
];
235 LV2Plugin::nth_parameter (uint32_t n
, bool& ok
) const
241 for (c
= 0, x
= 0; x
< slv2_plugin_get_num_ports(_plugin
); ++x
) {
242 if (parameter_is_control (x
)) {
254 LV2Plugin::get_state()
256 XMLNode
*root
= new XMLNode(state_node_name());
259 LocaleGuard
lg (X_("POSIX"));
261 for (uint32_t i
= 0; i
< parameter_count(); ++i
){
263 if (parameter_is_input(i
) && parameter_is_control(i
)) {
264 child
= new XMLNode("port");
265 snprintf(buf
, sizeof(buf
), "%u", i
);
266 child
->add_property("number", string(buf
));
267 child
->add_property("symbol", port_symbol(i
));
268 snprintf(buf
, sizeof(buf
), "%+f", _shadow_data
[i
]);
269 child
->add_property("value", string(buf
));
270 root
->add_child_nocopy (*child
);
272 if (i
< controls
.size() && controls
[i
]) {
273 root
->add_child_nocopy (controls
[i
]->get_state());
282 LV2Plugin::save_preset (string name
)
284 return Plugin::save_preset (name
, "lv2");
288 LV2Plugin::has_editor() const
290 return (_ui
!= NULL
);
294 LV2Plugin::set_state(const XMLNode
& node
)
298 XMLNodeConstIterator iter
;
303 LocaleGuard
lg (X_("POSIX"));
305 if (node
.name() != state_node_name()) {
306 error
<< _("Bad node sent to LV2Plugin::set_state") << endmsg
;
310 nodes
= node
.children ("port");
312 for(iter
= nodes
.begin(); iter
!= nodes
.end(); ++iter
){
316 if ((prop
= child
->property("number")) != 0) {
317 port
= prop
->value().c_str();
319 warning
<< _("LV2: no lv2 port number") << endmsg
;
323 if ((prop
= child
->property("value")) != 0) {
324 data
= prop
->value().c_str();
326 warning
<< _("LV2: no lv2 port data") << endmsg
;
330 sscanf (port
, "%" PRIu32
, &port_id
);
331 set_parameter (port_id
, atof(data
));
334 latency_compute_run ();
340 LV2Plugin::get_parameter_descriptor (uint32_t which
, ParameterDescriptor
& desc
) const
342 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, which
);
344 SLV2Value def
, min
, max
;
345 slv2_port_get_range(_plugin
, port
, &def
, &min
, &max
);
347 desc
.integer_step
= slv2_port_has_property(_plugin
, port
, _world
.integer
);
348 desc
.toggled
= slv2_port_has_property(_plugin
, port
, _world
.toggled
);
349 desc
.logarithmic
= false; // TODO (LV2 extension)
350 desc
.sr_dependent
= slv2_port_has_property(_plugin
, port
, _world
.srate
);
351 desc
.label
= slv2_value_as_string(slv2_port_get_name(_plugin
, port
));
352 desc
.lower
= min
? slv2_value_as_float(min
) : 0.0f
;
353 desc
.upper
= max
? slv2_value_as_float(max
) : 1.0f
;
354 desc
.min_unbound
= false; // TODO (LV2 extension)
355 desc
.max_unbound
= false; // TODO (LV2 extension)
357 if (desc
.integer_step
) {
359 desc
.smallstep
= 0.1;
360 desc
.largestep
= 10.0;
362 const float delta
= desc
.upper
- desc
.lower
;
363 desc
.step
= delta
/ 1000.0f
;
364 desc
.smallstep
= delta
/ 10000.0f
;
365 desc
.largestep
= delta
/10.0f
;
368 slv2_value_free(def
);
369 slv2_value_free(min
);
370 slv2_value_free(max
);
377 LV2Plugin::describe_parameter (uint32_t which
)
379 if (which
< parameter_count()) {
380 SLV2Value name
= slv2_port_get_name(_plugin
,
381 slv2_plugin_get_port_by_index(_plugin
, which
));
382 string
ret(slv2_value_as_string(name
));
383 slv2_value_free(name
);
391 LV2Plugin::latency () const
393 if (_latency_control_port
) {
394 return (nframes_t
) floor (*_latency_control_port
);
401 LV2Plugin::automatable () const
405 for (uint32_t i
= 0; i
< parameter_count(); ++i
){
406 if (parameter_is_input(i
) && parameter_is_control(i
)) {
407 ret
.insert (ret
.end(), i
);
415 LV2Plugin::connect_and_run (vector
<Sample
*>& bufs
, uint32_t nbufs
, int32_t& in_index
, int32_t& out_index
, nframes_t nframes
, nframes_t offset
)
422 then
= get_cycles ();
424 while (port_index
< parameter_count()) {
425 if (parameter_is_audio(port_index
)) {
426 if (parameter_is_input(port_index
)) {
427 slv2_instance_connect_port(_instance
, port_index
,
428 bufs
[min((uint32_t)in_index
, nbufs
- 1)] + offset
);
430 } else if (parameter_is_output(port_index
)) {
431 slv2_instance_connect_port(_instance
, port_index
,
432 bufs
[min((uint32_t)out_index
, nbufs
- 1)] + offset
);
441 set_cycles ((uint32_t) (now
- then
));
447 LV2Plugin::parameter_is_control (uint32_t param
) const
449 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, param
);
450 return slv2_port_is_a(_plugin
, port
, _world
.control_class
);
454 LV2Plugin::parameter_is_audio (uint32_t param
) const
456 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, param
);
457 return slv2_port_is_a(_plugin
, port
, _world
.audio_class
);
461 LV2Plugin::parameter_is_output (uint32_t param
) const
463 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, param
);
464 return slv2_port_is_a(_plugin
, port
, _world
.output_class
);
468 LV2Plugin::parameter_is_input (uint32_t param
) const
470 SLV2Port port
= slv2_plugin_get_port_by_index(_plugin
, param
);
471 return slv2_port_is_a(_plugin
, port
, _world
.input_class
);
475 LV2Plugin::print_parameter (uint32_t param
, char *buf
, uint32_t len
) const
478 if (param
< parameter_count()) {
479 snprintf (buf
, len
, "%.3f", get_parameter (param
));
487 LV2Plugin::run (nframes_t nframes
)
489 for (uint32_t i
= 0; i
< parameter_count(); ++i
) {
490 if (parameter_is_control(i
) && parameter_is_input(i
)) {
491 _control_data
[i
] = _shadow_data
[i
];
495 slv2_instance_run(_instance
, nframes
);
499 LV2Plugin::latency_compute_run ()
501 if (!_latency_control_port
) {
505 /* we need to run the plugin so that it can set its latency
511 uint32_t port_index
= 0;
512 uint32_t in_index
= 0;
513 uint32_t out_index
= 0;
514 const nframes_t bufsize
= 1024;
515 float buffer
[bufsize
];
517 memset(buffer
,0,sizeof(float)*bufsize
);
519 /* Note that we've already required that plugins
520 be able to handle in-place processing.
525 while (port_index
< parameter_count()) {
526 if (parameter_is_audio (port_index
)) {
527 if (parameter_is_input (port_index
)) {
528 slv2_instance_connect_port (_instance
, port_index
, buffer
);
530 } else if (parameter_is_output (port_index
)) {
531 slv2_instance_connect_port (_instance
, port_index
, buffer
);
543 : world(slv2_world_new())
545 slv2_world_load_all(world
);
546 input_class
= slv2_value_new_uri(world
, SLV2_PORT_CLASS_INPUT
);
547 output_class
= slv2_value_new_uri(world
, SLV2_PORT_CLASS_OUTPUT
);
548 control_class
= slv2_value_new_uri(world
, SLV2_PORT_CLASS_CONTROL
);
549 audio_class
= slv2_value_new_uri(world
, SLV2_PORT_CLASS_AUDIO
);
550 in_place_broken
= slv2_value_new_uri(world
, SLV2_NAMESPACE_LV2
"inPlaceBroken");
551 integer
= slv2_value_new_uri(world
, SLV2_NAMESPACE_LV2
"integer");
552 toggled
= slv2_value_new_uri(world
, SLV2_NAMESPACE_LV2
"toggled");
553 srate
= slv2_value_new_uri(world
, SLV2_NAMESPACE_LV2
"sampleRate");
554 gtk_gui
= slv2_value_new_uri(world
, "http://lv2plug.in/ns/extensions/ui#GtkUI");
557 LV2World::~LV2World()
559 slv2_value_free(input_class
);
560 slv2_value_free(output_class
);
561 slv2_value_free(control_class
);
562 slv2_value_free(audio_class
);
563 slv2_value_free(in_place_broken
);
566 LV2PluginInfo::LV2PluginInfo (void* lv2_world
, void* slv2_plugin
)
567 : _lv2_world(lv2_world
)
568 , _slv2_plugin(slv2_plugin
)
572 LV2PluginInfo::~LV2PluginInfo()
577 LV2PluginInfo::load (Session
& session
)
582 plugin
.reset (new LV2Plugin (session
.engine(), session
,
583 *(LV2World
*)_lv2_world
, (SLV2Plugin
)_slv2_plugin
, session
.frame_rate()));
585 plugin
->set_info(PluginInfoPtr(new LV2PluginInfo(*this)));
589 catch (failed_constructor
&err
) {
590 return PluginPtr ((Plugin
*) 0);
597 LV2PluginInfo::discover (void* lv2_world
)
599 PluginInfoList plugs
;
601 LV2World
* world
= (LV2World
*)lv2_world
;
602 SLV2Plugins plugins
= slv2_world_get_all_plugins(world
->world
);
604 for (unsigned i
=0; i
< slv2_plugins_size(plugins
); ++i
) {
605 SLV2Plugin p
= slv2_plugins_get_at(plugins
, i
);
606 LV2PluginInfoPtr
info (new LV2PluginInfo(lv2_world
, p
));
608 SLV2Value name
= slv2_plugin_get_name(p
);
609 info
->name
= string(slv2_value_as_string(name
));
610 slv2_value_free(name
);
612 SLV2PluginClass pclass
= slv2_plugin_get_class(p
);
613 SLV2Value label
= slv2_plugin_class_get_label(pclass
);
614 info
->category
= slv2_value_as_string(label
);
616 SLV2Value author_name
= slv2_plugin_get_author_name(p
);
617 info
->creator
= author_name
? string(slv2_value_as_string(author_name
)) : "Unknown";
618 slv2_value_free(author_name
);
620 info
->path
= "/NOPATH"; // Meaningless for LV2
622 info
->n_inputs
= slv2_plugin_get_num_ports_of_class(p
,
623 world
->input_class
, world
->audio_class
, NULL
);
625 info
->n_outputs
= slv2_plugin_get_num_ports_of_class(p
,
626 world
->output_class
, world
->audio_class
, NULL
);
628 info
->unique_id
= slv2_value_as_uri(slv2_plugin_get_uri(p
));
629 info
->index
= 0; // Meaningless for LV2
631 plugs
.push_back (info
);