2 Copyright (C) 2000-2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #include <cstdio> // so libraptor doesn't complain
34 #include "pbd/compose.h"
35 #include "pbd/error.h"
36 #include "pbd/xml++.h"
38 #include "midi++/manager.h"
40 #include "ardour/ardour.h"
41 #include "ardour/session.h"
42 #include "ardour/audioengine.h"
43 #include "ardour/ladspa_plugin.h"
44 #include "ardour/buffer_set.h"
45 #include "ardour/audio_buffer.h"
47 #include "pbd/stl_delete.h"
53 using namespace ARDOUR
;
56 LadspaPlugin::LadspaPlugin (void *mod
, AudioEngine
& e
, Session
& session
, uint32_t index
, framecnt_t rate
)
59 init (mod
, index
, rate
);
62 LadspaPlugin::LadspaPlugin (const LadspaPlugin
&other
)
65 init (other
._module
, other
._index
, other
._sample_rate
);
67 for (uint32_t i
= 0; i
< parameter_count(); ++i
) {
68 _control_data
[i
] = other
._shadow_data
[i
];
69 _shadow_data
[i
] = other
._shadow_data
[i
];
74 LadspaPlugin::init (void *mod
, uint32_t index
, framecnt_t rate
)
76 LADSPA_Descriptor_Function dfunc
;
83 _latency_control_port
= 0;
84 _was_activated
= false;
86 dfunc
= (LADSPA_Descriptor_Function
) dlsym (_module
, "ladspa_descriptor");
88 if ((errstr
= dlerror()) != NULL
) {
89 error
<< _("LADSPA: module has no descriptor function.") << endmsg
;
90 throw failed_constructor();
93 if ((_descriptor
= dfunc (index
)) == 0) {
94 error
<< _("LADSPA: plugin has gone away since discovery!") << endmsg
;
95 throw failed_constructor();
100 if (LADSPA_IS_INPLACE_BROKEN(_descriptor
->Properties
)) {
101 error
<< string_compose(_("LADSPA: \"%1\" cannot be used, since it cannot do inplace processing"), _descriptor
->Name
) << endmsg
;
102 throw failed_constructor();
107 if (_descriptor
->instantiate
== 0) {
108 throw failed_constructor();
111 if ((_handle
= _descriptor
->instantiate (_descriptor
, rate
)) == 0) {
112 throw failed_constructor();
115 port_cnt
= parameter_count();
117 _control_data
= new LADSPA_Data
[port_cnt
];
118 _shadow_data
= new LADSPA_Data
[port_cnt
];
120 for (i
= 0; i
< port_cnt
; ++i
) {
121 if (LADSPA_IS_PORT_CONTROL(port_descriptor (i
))) {
122 connect_port (i
, &_control_data
[i
]);
124 if (LADSPA_IS_PORT_OUTPUT(port_descriptor (i
)) &&
125 strcmp (port_names()[i
], X_("latency")) == 0) {
126 _latency_control_port
= &_control_data
[i
];
127 *_latency_control_port
= 0;
130 if (!LADSPA_IS_PORT_INPUT(port_descriptor (i
))) {
134 _shadow_data
[i
] = default_value (i
);
138 latency_compute_run ();
141 LadspaPlugin::~LadspaPlugin ()
146 /* XXX who should close a plugin? */
150 delete [] _control_data
;
151 delete [] _shadow_data
;
155 LadspaPlugin::unique_id() const
158 snprintf (buf
, sizeof (buf
), "%lu", _descriptor
->UniqueID
);
163 LadspaPlugin::default_value (uint32_t port
)
165 const LADSPA_PortRangeHint
*prh
= port_range_hints();
167 bool bounds_given
= false;
168 bool sr_scaling
= false;
169 bool earlier_hint
= false;
171 /* defaults - case 1 */
173 if (LADSPA_IS_HINT_HAS_DEFAULT(prh
[port
].HintDescriptor
)) {
174 if (LADSPA_IS_HINT_DEFAULT_MINIMUM(prh
[port
].HintDescriptor
)) {
175 ret
= prh
[port
].LowerBound
;
180 else if (LADSPA_IS_HINT_DEFAULT_LOW(prh
[port
].HintDescriptor
)) {
181 ret
= prh
[port
].LowerBound
* 0.75f
+ prh
[port
].UpperBound
* 0.25f
;
185 else if (LADSPA_IS_HINT_DEFAULT_MIDDLE(prh
[port
].HintDescriptor
)) {
186 ret
= prh
[port
].LowerBound
* 0.5f
+ prh
[port
].UpperBound
* 0.5f
;
190 else if (LADSPA_IS_HINT_DEFAULT_HIGH(prh
[port
].HintDescriptor
)) {
191 ret
= prh
[port
].LowerBound
* 0.25f
+ prh
[port
].UpperBound
* 0.75f
;
195 else if (LADSPA_IS_HINT_DEFAULT_MAXIMUM(prh
[port
].HintDescriptor
)) {
196 ret
= prh
[port
].UpperBound
;
200 else if (LADSPA_IS_HINT_DEFAULT_0(prh
[port
].HintDescriptor
)) {
204 else if (LADSPA_IS_HINT_DEFAULT_1(prh
[port
].HintDescriptor
)) {
208 else if (LADSPA_IS_HINT_DEFAULT_100(prh
[port
].HintDescriptor
)) {
212 else if (LADSPA_IS_HINT_DEFAULT_440(prh
[port
].HintDescriptor
)) {
222 /* defaults - case 2 */
223 else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh
[port
].HintDescriptor
) &&
224 !LADSPA_IS_HINT_BOUNDED_ABOVE(prh
[port
].HintDescriptor
)) {
226 if (prh
[port
].LowerBound
< 0) {
229 ret
= prh
[port
].LowerBound
;
236 /* defaults - case 3 */
237 else if (!LADSPA_IS_HINT_BOUNDED_BELOW(prh
[port
].HintDescriptor
) &&
238 LADSPA_IS_HINT_BOUNDED_ABOVE(prh
[port
].HintDescriptor
)) {
240 if (prh
[port
].UpperBound
> 0) {
243 ret
= prh
[port
].UpperBound
;
250 /* defaults - case 4 */
251 else if (LADSPA_IS_HINT_BOUNDED_BELOW(prh
[port
].HintDescriptor
) &&
252 LADSPA_IS_HINT_BOUNDED_ABOVE(prh
[port
].HintDescriptor
)) {
254 if (prh
[port
].LowerBound
< 0 && prh
[port
].UpperBound
> 0) {
256 } else if (prh
[port
].LowerBound
< 0 && prh
[port
].UpperBound
< 0) {
257 ret
= prh
[port
].UpperBound
;
259 ret
= prh
[port
].LowerBound
;
265 /* defaults - case 5 */
267 if (LADSPA_IS_HINT_SAMPLE_RATE(prh
[port
].HintDescriptor
) && !earlier_hint
) {
281 LadspaPlugin::set_parameter (uint32_t which
, float val
)
283 if (which
< _descriptor
->PortCount
) {
284 _shadow_data
[which
] = (LADSPA_Data
) val
;
287 if (which
< parameter_count() && controls
[which
]) {
288 controls
[which
]->Changed ();
293 warning
<< string_compose (_("illegal parameter number used with plugin \"%1\". This may"
294 "indicate a change in the plugin design, and presets may be"
299 Plugin::set_parameter (which
, val
);
302 /** @return `plugin' value */
304 LadspaPlugin::get_parameter (uint32_t which
) const
306 if (LADSPA_IS_PORT_INPUT(port_descriptor (which
))) {
307 return (float) _shadow_data
[which
];
309 return (float) _control_data
[which
];
314 LadspaPlugin::nth_parameter (uint32_t n
, bool& ok
) const
320 for (c
= 0, x
= 0; x
< _descriptor
->PortCount
; ++x
) {
321 if (LADSPA_IS_PORT_CONTROL (port_descriptor (x
))) {
332 LadspaPlugin::add_state (XMLNode
* root
) const
336 LocaleGuard
lg (X_("POSIX"));
338 for (uint32_t i
= 0; i
< parameter_count(); ++i
){
340 if (LADSPA_IS_PORT_INPUT(port_descriptor (i
)) &&
341 LADSPA_IS_PORT_CONTROL(port_descriptor (i
))){
343 child
= new XMLNode("Port");
344 snprintf(buf
, sizeof(buf
), "%u", i
);
345 child
->add_property("number", string(buf
));
346 snprintf(buf
, sizeof(buf
), "%+f", _shadow_data
[i
]);
347 child
->add_property("value", string(buf
));
348 root
->add_child_nocopy (*child
);
354 LadspaPlugin::set_state (const XMLNode
& node
, int version
)
356 if (version
< 3000) {
357 return set_state_2X (node
, version
);
362 XMLNodeConstIterator iter
;
367 LocaleGuard
lg (X_("POSIX"));
369 if (node
.name() != state_node_name()) {
370 error
<< _("Bad node sent to LadspaPlugin::set_state") << endmsg
;
374 nodes
= node
.children ("Port");
376 for (iter
= nodes
.begin(); iter
!= nodes
.end(); ++iter
) {
380 if ((prop
= child
->property("number")) != 0) {
381 port
= prop
->value().c_str();
383 warning
<< _("LADSPA: no ladspa port number") << endmsg
;
386 if ((prop
= child
->property("value")) != 0) {
387 data
= prop
->value().c_str();
389 warning
<< _("LADSPA: no ladspa port data") << endmsg
;
393 sscanf (port
, "%" PRIu32
, &port_id
);
394 set_parameter (port_id
, atof(data
));
397 latency_compute_run ();
399 return Plugin::set_state (node
, version
);
403 LadspaPlugin::set_state_2X (const XMLNode
& node
, int /* version */)
407 XMLNodeConstIterator iter
;
412 LocaleGuard
lg (X_("POSIX"));
414 if (node
.name() != state_node_name()) {
415 error
<< _("Bad node sent to LadspaPlugin::set_state") << endmsg
;
419 nodes
= node
.children ("port");
421 for(iter
= nodes
.begin(); iter
!= nodes
.end(); ++iter
){
425 if ((prop
= child
->property("number")) != 0) {
426 port
= prop
->value().c_str();
428 warning
<< _("LADSPA: no ladspa port number") << endmsg
;
431 if ((prop
= child
->property("value")) != 0) {
432 data
= prop
->value().c_str();
434 warning
<< _("LADSPA: no ladspa port data") << endmsg
;
438 sscanf (port
, "%" PRIu32
, &port_id
);
439 set_parameter (port_id
, atof(data
));
442 latency_compute_run ();
448 LadspaPlugin::get_parameter_descriptor (uint32_t which
, ParameterDescriptor
& desc
) const
450 LADSPA_PortRangeHint prh
;
452 prh
= port_range_hints()[which
];
455 if (LADSPA_IS_HINT_BOUNDED_BELOW(prh
.HintDescriptor
)) {
456 desc
.min_unbound
= false;
457 if (LADSPA_IS_HINT_SAMPLE_RATE(prh
.HintDescriptor
)) {
458 desc
.lower
= prh
.LowerBound
* _session
.frame_rate();
460 desc
.lower
= prh
.LowerBound
;
463 desc
.min_unbound
= true;
468 if (LADSPA_IS_HINT_BOUNDED_ABOVE(prh
.HintDescriptor
)) {
469 desc
.max_unbound
= false;
470 if (LADSPA_IS_HINT_SAMPLE_RATE(prh
.HintDescriptor
)) {
471 desc
.upper
= prh
.UpperBound
* _session
.frame_rate();
473 desc
.upper
= prh
.UpperBound
;
476 desc
.max_unbound
= true;
477 desc
.upper
= 4; /* completely arbitrary */
480 if (LADSPA_IS_HINT_INTEGER (prh
.HintDescriptor
)) {
482 desc
.smallstep
= 0.1;
483 desc
.largestep
= 10.0;
485 float delta
= desc
.upper
- desc
.lower
;
486 desc
.step
= delta
/ 1000.0f
;
487 desc
.smallstep
= delta
/ 10000.0f
;
488 desc
.largestep
= delta
/10.0f
;
491 desc
.toggled
= LADSPA_IS_HINT_TOGGLED (prh
.HintDescriptor
);
492 desc
.logarithmic
= LADSPA_IS_HINT_LOGARITHMIC (prh
.HintDescriptor
);
493 desc
.sr_dependent
= LADSPA_IS_HINT_SAMPLE_RATE (prh
.HintDescriptor
);
494 desc
.integer_step
= LADSPA_IS_HINT_INTEGER (prh
.HintDescriptor
);
496 desc
.label
= port_names()[which
];
502 LadspaPlugin::describe_parameter (Evoral::Parameter which
)
504 if (which
.type() == PluginAutomation
&& which
.id() < parameter_count()) {
505 return port_names()[which
.id()];
512 LadspaPlugin::signal_latency () const
515 return _user_latency
;
518 if (_latency_control_port
) {
519 return (framecnt_t
) floor (*_latency_control_port
);
525 set
<Evoral::Parameter
>
526 LadspaPlugin::automatable () const
528 set
<Evoral::Parameter
> ret
;
530 for (uint32_t i
= 0; i
< parameter_count(); ++i
){
531 if (LADSPA_IS_PORT_INPUT(port_descriptor (i
)) &&
532 LADSPA_IS_PORT_CONTROL(port_descriptor (i
))){
534 ret
.insert (ret
.end(), Evoral::Parameter(PluginAutomation
, 0, i
));
542 LadspaPlugin::connect_and_run (BufferSet
& bufs
,
543 ChanMapping in_map
, ChanMapping out_map
,
544 pframes_t nframes
, framecnt_t offset
)
546 Plugin::connect_and_run (bufs
, in_map
, out_map
, nframes
, offset
);
549 cycles_t then
= get_cycles ();
551 uint32_t audio_in_index
= 0;
552 uint32_t audio_out_index
= 0;
553 for (uint32_t port_index
= 0; port_index
< parameter_count(); ++port_index
) {
554 if (LADSPA_IS_PORT_AUDIO(port_descriptor(port_index
))) {
555 if (LADSPA_IS_PORT_INPUT(port_descriptor(port_index
))) {
556 const uint32_t buf_index
= in_map
.get(DataType::AUDIO
, audio_in_index
++);
557 connect_port(port_index
, bufs
.get_audio(buf_index
).data(offset
));
558 } else if (LADSPA_IS_PORT_OUTPUT(port_descriptor(port_index
))) {
559 const uint32_t buf_index
= out_map
.get(DataType::AUDIO
, audio_out_index
++);
560 connect_port(port_index
, bufs
.get_audio(buf_index
).data(offset
));
565 run_in_place (nframes
);
567 set_cycles ((uint32_t) (now
- then
));
573 LadspaPlugin::parameter_is_control (uint32_t param
) const
575 return LADSPA_IS_PORT_CONTROL(port_descriptor (param
));
579 LadspaPlugin::parameter_is_audio (uint32_t param
) const
581 return LADSPA_IS_PORT_AUDIO(port_descriptor (param
));
585 LadspaPlugin::parameter_is_output (uint32_t param
) const
587 return LADSPA_IS_PORT_OUTPUT(port_descriptor (param
));
591 LadspaPlugin::parameter_is_input (uint32_t param
) const
593 return LADSPA_IS_PORT_INPUT(port_descriptor (param
));
597 LadspaPlugin::print_parameter (uint32_t param
, char *buf
, uint32_t len
) const
600 if (param
< parameter_count()) {
601 snprintf (buf
, len
, "%.3f", get_parameter (param
));
609 LadspaPlugin::run_in_place (pframes_t nframes
)
611 for (uint32_t i
= 0; i
< parameter_count(); ++i
) {
612 if (LADSPA_IS_PORT_INPUT(port_descriptor (i
)) && LADSPA_IS_PORT_CONTROL(port_descriptor (i
))) {
613 _control_data
[i
] = _shadow_data
[i
];
617 assert (_was_activated
);
619 _descriptor
->run (_handle
, nframes
);
623 LadspaPlugin::latency_compute_run ()
625 if (!_latency_control_port
) {
629 /* we need to run the plugin so that it can set its latency
635 uint32_t port_index
= 0;
636 uint32_t in_index
= 0;
637 uint32_t out_index
= 0;
638 const framecnt_t bufsize
= 1024;
639 LADSPA_Data buffer
[bufsize
];
641 memset(buffer
,0,sizeof(LADSPA_Data
)*bufsize
);
643 /* Note that we've already required that plugins
644 be able to handle in-place processing.
649 while (port_index
< parameter_count()) {
650 if (LADSPA_IS_PORT_AUDIO (port_descriptor (port_index
))) {
651 if (LADSPA_IS_PORT_INPUT (port_descriptor (port_index
))) {
652 connect_port (port_index
, buffer
);
654 } else if (LADSPA_IS_PORT_OUTPUT (port_descriptor (port_index
))) {
655 connect_port (port_index
, buffer
);
662 run_in_place (bufsize
);
667 LadspaPluginInfo::load (Session
& session
)
673 if ((module
= dlopen (path
.c_str(), RTLD_NOW
)) == 0) {
674 error
<< string_compose(_("LADSPA: cannot load module from \"%1\""), path
) << endmsg
;
675 error
<< dlerror() << endmsg
;
676 return PluginPtr ((Plugin
*) 0);
678 plugin
.reset (new LadspaPlugin (module
, session
.engine(), session
, index
, session
.frame_rate()));
681 plugin
->set_info(PluginInfoPtr(new LadspaPluginInfo(*this)));
685 catch (failed_constructor
&err
) {
686 return PluginPtr ((Plugin
*) 0);
690 LadspaPluginInfo::LadspaPluginInfo()
692 type
= ARDOUR::LADSPA
;
697 LadspaPlugin::find_presets ()
700 std::string
unique (unique_id());
702 if (!isdigit (unique
[0])) {
706 id
= atol (unique
.c_str());
708 lrdf_uris
* set_uris
= lrdf_get_setting_uris(id
);
711 for (uint32_t i
= 0; i
< (uint32_t) set_uris
->count
; ++i
) {
712 if (char* label
= lrdf_get_label(set_uris
->items
[i
])) {
713 PresetRecord
rec (set_uris
->items
[i
], label
);
714 _presets
.insert (make_pair (set_uris
->items
[i
], rec
));
717 lrdf_free_uris(set_uris
);
723 LadspaPlugin::load_preset (PresetRecord r
)
725 lrdf_defaults
* defs
= lrdf_get_setting_values (r
.uri
.c_str());
728 for (uint32_t i
= 0; i
< (uint32_t) defs
->count
; ++i
) {
729 if (parameter_is_input (defs
->items
[i
].pid
)) {
730 set_parameter(defs
->items
[i
].pid
, defs
->items
[i
].value
);
733 lrdf_free_setting_values(defs
);
736 Plugin::load_preset (r
);
740 /* XXX: should be in liblrdf */
742 lrdf_remove_preset (const char *source
, const char *setting_uri
)
747 char setting_uri_copy
[64];
750 strncpy(setting_uri_copy
, setting_uri
, sizeof(setting_uri_copy
));
752 p
.subject
= setting_uri_copy
;
753 strncpy(buf
, LADSPA_BASE
"hasPortValue", sizeof(buf
));
756 q
= lrdf_matches(&p
);
760 for (i
= q
; i
; i
= i
->next
) {
761 p
.subject
= i
->object
;
762 lrdf_remove_matches(&p
);
765 lrdf_free_statements(q
);
768 strncpy(buf
, LADSPA_BASE
"hasSetting", sizeof(buf
));
770 p
.object
= setting_uri_copy
;
771 lrdf_remove_matches(&p
);
773 p
.subject
= setting_uri_copy
;
776 lrdf_remove_matches (&p
);
780 LadspaPlugin::do_remove_preset (string name
)
782 string
const envvar
= preset_envvar ();
783 if (envvar
.empty()) {
784 warning
<< _("Could not locate HOME. Preset not removed.") << endmsg
;
788 Plugin::PresetRecord
const * p
= preset_by_label (name
);
793 string
const source
= preset_source (envvar
);
794 lrdf_remove_preset (source
.c_str(), p
->uri
.c_str ());
796 write_preset_file (envvar
);
800 LadspaPlugin::preset_envvar () const
803 if ((envvar
= getenv ("HOME")) == 0) {
811 LadspaPlugin::preset_source (string envvar
) const
813 return string_compose ("file:%1/.ladspa/rdf/ardour-presets.n3", envvar
);
817 LadspaPlugin::write_preset_file (string envvar
)
819 string path
= string_compose("%1/.ladspa", envvar
);
820 if (g_mkdir_with_parents (path
.c_str(), 0775)) {
821 warning
<< string_compose(_("Could not create %1. Preset not saved. (%2)"), path
, strerror(errno
)) << endmsg
;
826 if (g_mkdir_with_parents (path
.c_str(), 0775)) {
827 warning
<< string_compose(_("Could not create %1. Preset not saved. (%2)"), path
, strerror(errno
)) << endmsg
;
831 string
const source
= preset_source (envvar
);
833 if (lrdf_export_by_source (source
.c_str(), source
.substr(5).c_str())) {
834 warning
<< string_compose(_("Error saving presets file %1."), source
) << endmsg
;
842 LadspaPlugin::do_save_preset (string name
)
844 /* make a vector of pids that are input parameters */
845 vector
<int> input_parameter_pids
;
846 for (uint32_t i
= 0; i
< parameter_count(); ++i
) {
847 if (parameter_is_input (i
)) {
848 input_parameter_pids
.push_back (i
);
852 std::string
unique (unique_id());
854 if (!isdigit (unique
[0])) {
858 uint32_t const id
= atol (unique
.c_str());
860 lrdf_defaults defaults
;
861 defaults
.count
= input_parameter_pids
.size ();
862 lrdf_portvalue portvalues
[input_parameter_pids
.size()];
863 defaults
.items
= portvalues
;
865 for (vector
<int>::size_type i
= 0; i
< input_parameter_pids
.size(); ++i
) {
866 portvalues
[i
].pid
= input_parameter_pids
[i
];
867 portvalues
[i
].value
= get_parameter (input_parameter_pids
[i
]);
870 string
const envvar
= preset_envvar ();
871 if (envvar
.empty()) {
872 warning
<< _("Could not locate HOME. Preset not saved.") << endmsg
;
876 string
const source
= preset_source (envvar
);
878 char* uri_char
= lrdf_add_preset (source
.c_str(), name
.c_str(), id
, &defaults
);
879 string
uri (uri_char
);
882 if (!write_preset_file (envvar
)) {