37 static void init(
unsigned int samplingFreq,
PluginDef *plugin);
38 static void mono_process(
int count,
float *input,
float *output,
PluginDef *plugin);
39 static void to_mono_process(
int count,
float *input,
float *output,
PluginDef *plugin);
40 static void stereo_process(
int count,
float *input1,
float *input2,
float *output1,
float *output2,
PluginDef *plugin);
42 static int registerparam(
const ParamReg& reg);
43 static int uiloader(
const UiBuilder& builder,
int form);
44 static void del_instance(
PluginDef *plugin);
46 const LADSPA_Descriptor *desc;
48 LADSPA_Handle instance;
50 Glib::ustring name_str;
53 void connect(
int tp,
int i,
float *v);
54 inline void cleanup();
58 inline void mono_dry_wet(
int count,
float *input0,
float *input1,
float *output0);
59 inline void stereo_dry_wet(
int count,
float *input0,
float *input1,
float *input2,
float *input3,
float *output0,
float *output1);
60 inline void down_to_mono(
int count,
float *input0,
float *input1,
float *output0);
61 inline void up_to_stereo(
int count,
float *input0,
float *output0,
float *output1);
62 std::string make_id(
const paradesc& p);
63 LadspaDsp(
const plugdesc *plug,
void *handle_,
const LADSPA_Descriptor *desc_,
bool mono,
bool to_mono);
72 handle = dlopen(plug->
path.c_str(), RTLD_LOCAL|RTLD_NOW);
74 gx_print_error(
"ladspaloader",ustring::compose(_(
"Cannot open plugin: %1 [%2]"), plug->
path, dlerror()));
77 LADSPA_Descriptor_Function ladspa_descriptor = (LADSPA_Descriptor_Function)dlsym(handle,
"ladspa_descriptor");
78 const char *dlsym_error = dlerror();
80 gx_print_error(
"ladspaloader",ustring::compose(_(
"Cannot load symbol 'ladspa_descriptor': %1"), dlsym_error));
85 const LADSPA_Descriptor *desc = ladspa_descriptor(plug->
index);
86 if (!desc || desc->UniqueID != plug->
UniqueID) {
87 for (
int i = 0; ; i++) {
88 desc = ladspa_descriptor(i);
92 if (desc->UniqueID == plug->
UniqueID) {
98 gx_print_error(
"ladspaloader",ustring::compose(_(
"Cannot load ladspa descriptor #%1 from %2"), plug->
index, plug->
path));
103 if (desc->UniqueID == 4069 || desc->UniqueID == 4070) {
111 for (
unsigned int i = 0; i < desc->PortCount; ++i) {
112 if (LADSPA_IS_PORT_AUDIO(desc->PortDescriptors[i])) {
113 if (LADSPA_IS_PORT_INPUT(desc->PortDescriptors[i])) {
121 bool to_mono =
false;
122 if (num_inputs == 1 && num_outputs == 1) {
124 }
else if (num_inputs == 2 && num_outputs == 2) {
129 "ladspaloader",ustring::compose(
130 _(
"cannot use ladspa plugin %1 with %2 inputs and %3 outputs"),
131 desc->Label, num_inputs, num_outputs));
136 return new LadspaDsp(plug, handle, desc, mono, to_mono);
139 LadspaDsp::LadspaDsp(
const plugdesc *plug,
void *handle_,
const LADSPA_Descriptor *desc_,
bool mono,
bool to_mono)
140 :
PluginDef(), desc(desc_), handle(handle_), instance(),
141 ports(
new LADSPA_Data[desc->PortCount]), name_str(), pd(plug), is_activated(
false) {
161 inline void LadspaDsp::cleanup() {
164 activate(
true,
this);
166 activate(
false,
this);
168 desc->cleanup(instance);
178 if (jp.
read_kv(
"index", index) ||
185 jp.
read_kv(
"newrow", newrow) ||
186 jp.
read_kv(
"has_caption", has_caption)) {
188 std::vector<std::string> v;
213 jw.
write_kv(
"has_caption", has_caption);
219 jw.
write(p->value_id);
220 jw.
write(p->value_label);
232 if (jp.
read_kv(
"path", path) ||
234 jp.
read_kv(
"UniqueID", UniqueID) ||
238 jp.
read_kv(
"quirks", quirks) ||
239 jp.
read_kv(
"add_wet_dry", add_wet_dry) ||
240 jp.
read_kv(
"stereo_to_mono", stereo_to_mono) ||
241 jp.
read_kv(
"master_idx", master_idx) ||
242 jp.
read_kv(
"master_label", master_label) ||
243 jp.
read_kv(
"id_str", id_str)) {
263 jw.
write_kv(
"UniqueID", static_cast<unsigned int>(UniqueID));
268 jw.
write_kv(
"add_wet_dry", add_wet_dry);
269 jw.
write_kv(
"stereo_to_mono", stereo_to_mono);
270 jw.
write_kv(
"master_idx", master_idx);
271 jw.
write_kv(
"master_label", master_label);
275 for (std::vector<paradesc*>::iterator i = names.begin(); i != names.end(); ++i) {
282 plugdesc::~plugdesc() {
283 for (std::vector<paradesc*>::const_iterator it = names.begin(); it != names.end(); ++it) {
288 LadspaDsp::~LadspaDsp() {
298 if (start ==
self.is_activated) {
301 self.is_activated =
start;
303 if (
self.desc->activate) {
304 self.desc->activate(
self.instance);
307 if (
self.desc->deactivate) {
308 self.desc->deactivate(
self.instance);
314 void LadspaDsp::connect(
int tp,
int i,
float *v) {
315 for (
unsigned int n = 0; n < desc->PortCount; ++n) {
316 if (!LADSPA_IS_PORT_AUDIO(desc->PortDescriptors[n])) {
319 if (desc->PortDescriptors[n] & tp) {
321 desc->connect_port(instance, n, v);
337 void LadspaDsp::set_shortname() {
341 name_str = desc->Name;
342 if (name_str.size() > 15) {
349 void LadspaDsp::init(
unsigned int samplingFreq,
PluginDef *plugin) {
352 if (samplingFreq == 0) {
355 self.instance =
self.desc->instantiate(
self.desc, samplingFreq);
357 for (std::vector<paradesc*>::const_iterator it =
self.pd->
names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
358 self.desc->connect_port(
self.instance, (*it)->index, &
self.ports[(*it)->index]);
362 inline void LadspaDsp::mono_dry_wet(
int count,
float *input0,
float *input1,
float *output0)
364 double fSlow0 = (0.01 * dry_wet);
365 double fSlow1 = (1 - fSlow0);
366 for (
int i=0; i<count; i++) {
367 output0[i] = ((fSlow0 * (double)input1[i]) + (fSlow1 * (double)input0[i]));
371 void LadspaDsp::mono_process(
int count,
float *input,
float *output,
PluginDef *plugin) {
373 assert(
self.is_activated);
375 float wet_out[count];
376 self.connect(LADSPA_PORT_INPUT, 0, input);
377 self.connect(LADSPA_PORT_OUTPUT, 0, wet_out);
378 self.desc->run(
self.instance, count);
379 self.mono_dry_wet(count, input, wet_out, output);
381 self.connect(LADSPA_PORT_INPUT, 0, input);
382 self.connect(LADSPA_PORT_OUTPUT, 0, output);
383 self.desc->run(
self.instance, count);
387 void LadspaDsp::up_to_stereo(
int count,
float *input0,
float *output0,
float *output1) {
388 memcpy(output0, input0, count *
sizeof(
float));
389 memcpy(output1, input0, count *
sizeof(
float));
392 void LadspaDsp::down_to_mono(
int count,
float *input0,
float *input1,
float *output0) {
393 for (
int i=0; i<count; i++) {
394 output0[i] = 0.5 * (input0[i] + input1[i]);
398 void LadspaDsp::to_mono_process(
int count,
float *input,
float *output,
PluginDef *plugin) {
400 assert(
self.is_activated);
402 float wet_out[count];
404 float inputs1[count];
405 float outputs[count];
406 float outputs1[count];
407 self.up_to_stereo(count,input,inputs, inputs1);
408 self.connect(LADSPA_PORT_INPUT, 0, inputs);
409 self.connect(LADSPA_PORT_INPUT, 1, inputs1);
410 self.connect(LADSPA_PORT_INPUT, 0, outputs);
411 self.connect(LADSPA_PORT_INPUT, 1, outputs1);
412 self.desc->run(
self.instance, count);
413 self.down_to_mono(count,outputs,outputs1,wet_out);
414 self.mono_dry_wet(count, input, wet_out, output);
417 float inputs1[count];
418 float outputs[count];
419 float outputs1[count];
420 self.up_to_stereo(count,input,inputs, inputs1);
421 self.connect(LADSPA_PORT_INPUT, 0, inputs);
422 self.connect(LADSPA_PORT_INPUT, 1, inputs1);
423 self.connect(LADSPA_PORT_INPUT, 0, outputs);
424 self.connect(LADSPA_PORT_INPUT, 1, outputs1);
425 self.desc->run(
self.instance, count);
426 self.down_to_mono(count,outputs,outputs1,output);
430 inline void LadspaDsp::stereo_dry_wet(
int count,
float *input0,
float *input1,
float *input2,
float *input3,
float *output0,
float *output1)
432 double fSlow0 = (0.01 * dry_wet);
433 double fSlow1 = (1 - fSlow0);
434 for (
int i=0; i<count; i++) {
435 output0[i] = ((fSlow0 * (double)input2[i]) + (fSlow1 * (double)input0[i]));
436 output1[i] = ((fSlow0 * (double)input3[i]) + (fSlow1 * (double)input1[i]));
440 void LadspaDsp::stereo_process(
int count,
float *input1,
float *input2,
float *output1,
float *output2,
PluginDef *plugin) {
442 assert(
self.is_activated);
444 float wet_out1[count];
445 float wet_out2[count];
446 self.connect(LADSPA_PORT_INPUT, 0, input1);
447 self.connect(LADSPA_PORT_INPUT, 1, input2);
448 self.connect(LADSPA_PORT_OUTPUT, 0, wet_out1);
449 self.connect(LADSPA_PORT_OUTPUT, 1, wet_out2);
450 self.desc->run(
self.instance, count);
451 self.stereo_dry_wet(count, input1, input2, wet_out1, wet_out2, output1, output2);
453 self.connect(LADSPA_PORT_INPUT, 0, input1);
454 self.connect(LADSPA_PORT_INPUT, 1, input2);
455 self.connect(LADSPA_PORT_OUTPUT, 0, output1);
456 self.connect(LADSPA_PORT_OUTPUT, 1, output2);
457 self.desc->run(
self.instance, count);
461 static Glib::ustring TrimLabel(
const char *label,
int cnt_in_row) {
462 const size_t minlen = 60 / cnt_in_row - 1;
463 const size_t maxlen = minlen + 10;
464 const size_t cutlen = (maxlen + minlen) / 2;
465 Glib::ustring pn(label);
466 size_t rem = pn.find_first_of(
"([");
467 if(rem != Glib::ustring::npos) {
470 while ((rem = pn.find_last_of(
" ")) == pn.size()-1) {
477 rem1 = pn.find_first_of(
" ", rem1);
478 if (rem1 == Glib::ustring::npos) {
481 while (rem1 > rem + minlen) {
484 pn.replace(lastpos, 1, 1,
'\n');
485 }
else if (rem1 < rem + maxlen) {
486 if (rem1 == pn.size()) {
490 pn.replace(rem1, 1, 1,
'\n');
493 pn.insert(rem,
"\n");
499 if (rem1 >= pn.size()) {
506 static Glib::ustring TrimEffectLabel(
const char *label,
int cnt_in_row) {
507 const size_t minlen = 60 / cnt_in_row - 1;
508 const size_t maxlen = minlen + 10;
509 const size_t cutlen = (maxlen + minlen) / 2;
510 Glib::ustring pn(label);
515 rem1 = pn.find_first_of(
" ", rem1);
516 if (rem1 == Glib::ustring::npos) {
519 while (rem1 > rem + minlen) {
522 pn.replace(lastpos, 1, 1,
'\n');
523 }
else if (rem1 < rem + maxlen) {
524 if (rem1 == pn.size()) {
528 pn.replace(rem1, 1, 1,
'\n');
531 pn.insert(rem,
"\n");
537 if (rem1 >= pn.size()) {
544 std::string LadspaDsp::make_id(
const paradesc& p) {
548 int LadspaDsp::registerparam(
const ParamReg& reg) {
553 for (std::vector<paradesc*>::const_iterator it =
self.pd->
names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
559 std::vector<paradesc*>::const_iterator it2 = it+1;
560 while (it2 !=
self.pd->
names.end() && !(*it2)->newrow) {
569 const char *nm =
self.desc->PortNames[d->
index];
570 Glib::ustring snm(d->
name);
572 snm = TrimLabel(nm, cnt_in_row);
581 case tp_int: tp =
"S";
break;
587 default: assert(
false);
589 reg.
registerVar(
self.make_id(*d).c_str(), snm.c_str(), tp, nm, &
self.ports[d->
index],
593 self.idd =
self.pd->id_str +
".dry_wet";
594 reg.
registerVar(
self.idd.c_str(),
"",
"S",
"dry/wet",&
self.dry_wet, 100, 0, 100, 1);
598 int LadspaDsp::uiloader(
const UiBuilder& b,
int form) {
606 for (std::vector<paradesc*>::const_iterator it =
self.pd->
names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
607 if ((n)==
self.pd->master_idx) {
613 const char *p =
self.pd->master_label.c_str();
625 for (std::vector<paradesc*>::const_iterator it =
self.pd->
names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
639 for (std::vector<paradesc*>::const_iterator it =
self.pd->
names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
642 if ( (rows == 1) || ( rows > 1 && row > 0 )) {
650 const char *p1 =
self.desc->PortNames[(*it)->index];
651 if (!(*it)->name.empty())
652 p1 = (*it)->name.c_str();
653 Glib::ustring trim = TrimEffectLabel(p1, 4);
654 const char *p = trim.c_str();
655 std::string
id =
self.make_id(**it);
656 if ((row == 1 && rows == 1 ) || (row >1 && rows >1 )) {
662 if (!(*it)->has_caption) {
668 if ((*it)->has_caption) {
675 if (!(*it)->has_caption) {
681 if ((*it)->has_caption) {
688 if (!(*it)->has_caption) {
691 if (((*it)->up - (*it)->low)<200) {
698 if ((*it)->has_caption) {
718 void LadspaDsp::del_instance(
PluginDef *plugin) {
729 static void init(
unsigned int samplingFreq,
PluginDef *plugin);
730 static void mono_process(
int count,
float *input,
float *output,
PluginDef *plugin);
731 static void to_mono_process(
int count,
float *input,
float *output,
PluginDef *plugin);
732 static void stereo_process(
int count,
float *input1,
float *input2,
float *output1,
float *output2,
PluginDef *plugin);
733 static int activate(
bool start,
PluginDef *plugin);
734 static int registerparam(
const ParamReg& reg);
736 static void del_instance(
PluginDef *plugin);
739 const LilvPlugin* plugin;
741 LilvInstance* instance;
743 Glib::ustring name_str;
746 void connect(
const LilvNode* tp,
int i,
float *v);
747 inline void cleanup();
748 void set_shortname();
751 inline void mono_dry_wet(
int count,
float *input0,
float *input1,
float *output0);
752 inline void stereo_dry_wet(
int count,
float *input0,
float *input1,
float *input2,
float *input3,
float *output0,
float *output1);
753 inline void down_to_mono(
int count,
float *input0,
float *input1,
float *output0);
754 inline void up_to_stereo(
int count,
float *input0,
float *output0,
float *output1);
755 std::string make_id(
const paradesc& p);
764 LilvNode* plugin_uri = lilv_new_uri(loader.world, plug->
path.c_str());
765 const LilvPlugin* plugin = lilv_plugins_get_by_uri(loader.lv2_plugins, plugin_uri);
766 lilv_node_free(plugin_uri);
768 gx_print_error(
"lv2loader",ustring::compose(_(
"Cannot open LV2 plugin: %1"), plug->
path));
772 int num_inputs = lilv_plugin_get_num_ports_of_class(plugin, loader.lv2_AudioPort, loader.lv2_InputPort, 0);
773 int num_outputs = lilv_plugin_get_num_ports_of_class(plugin, loader.lv2_AudioPort, loader.lv2_OutputPort, 0);
774 int num_controls = lilv_plugin_get_num_ports_of_class(plugin, loader.lv2_ControlPort, 0);
777 bool to_mono =
false;
778 if (num_inputs == 1 && num_outputs == 1) {
780 }
else if (num_inputs == 2 && num_outputs == 2) {
784 LilvNode *nm = lilv_plugin_get_name(plugin);
786 "lv2loader",ustring::compose(
787 _(
"cannot use LV2 plugin %1 with %2 inputs and %3 outputs"),
788 lilv_node_as_string(nm), num_inputs, num_outputs));
792 Lv2Dsp*
self =
new Lv2Dsp(plug, plugin, loader, mono, to_mono);
793 int desk_controls = 0;
794 for (std::vector<paradesc*>::const_iterator it = self->pd->names.begin(); it !=
self->pd->names.end(); ++it, ++desk_controls) ;
795 if (num_controls != desk_controls) {
796 LilvNode *nm = lilv_plugin_get_name(plugin);
798 "lv2loader",ustring::compose(
799 _(
"LV2 plugin %1 has changed it's ports, this may result in errors!!\nPlease go to the LADSPA/LV2 loader and select %1\nSelect 'Show Details' and press 'Restore Defaults'\nUn-load %1 (un-tick the box) and press 'save'.\nAfter this you could re-load %1 with it's new ports"),
800 lilv_node_as_string(nm)));
808 Lv2Dsp::Lv2Dsp(
const plugdesc *plug,
const LilvPlugin* plugin_,
const LadspaLoader& loader_,
bool mono,
bool to_mono)
809 :
PluginDef(), loader(loader_), plugin(plugin_), name_node(lilv_plugin_get_name(plugin_)), instance(),
810 ports(
new LADSPA_Data[lilv_plugin_get_num_ports(plugin_)]), name_str(), pd(plug), is_activated(
false) {
812 id = pd->id_str.c_str();
815 name = lilv_node_as_string(name_node);
830 inline void Lv2Dsp::cleanup() {
833 activate(
true,
this);
835 activate(
false,
this);
837 lilv_instance_free(instance);
846 lilv_node_free(name_node);
849 int Lv2Dsp::activate(
bool start,
PluginDef *plugin) {
851 if (start ==
self.is_activated) {
854 if (!
self.instance) {
858 self.is_activated =
start;
860 lilv_instance_activate(
self.instance);
862 lilv_instance_deactivate(
self.instance);
867 void Lv2Dsp::connect(
const LilvNode* tp,
int i,
float *v) {
868 unsigned int num_ports = lilv_plugin_get_num_ports(plugin);
869 for (
unsigned int n = 0; n < num_ports; ++n) {
870 const LilvPort* port = lilv_plugin_get_port_by_index(plugin, n);
871 if (!lilv_port_is_a(plugin, port, loader.lv2_AudioPort)) {
874 if (lilv_port_is_a(plugin, port, tp)) {
876 lilv_instance_connect_port(instance, n, v);
892 void Lv2Dsp::set_shortname() {
893 if (!pd->shortname.empty()) {
896 name_str = lilv_node_as_string(name_node);
897 if (name_str.size() > 15) {
904 void Lv2Dsp::init(
unsigned int samplingFreq,
PluginDef *pldef) {
907 if (samplingFreq == 0) {
910 self.instance = lilv_plugin_instantiate(
self.plugin, samplingFreq, 0);
911 if (!
self.instance) {
912 gx_print_error(
"Lv2Dsp", ustring::compose(
"cant init plugin: %1 \n uri: %2",
self.
name,
self.pd->path));
916 for (std::vector<paradesc*>::const_iterator it =
self.pd->names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
917 lilv_instance_connect_port(
self.instance, (*it)->index, &
self.ports[(*it)->index]);
921 inline void Lv2Dsp::mono_dry_wet(
int count,
float *input0,
float *input1,
float *output0)
923 double fSlow0 = (0.01 * dry_wet);
924 double fSlow1 = (1 - fSlow0);
925 for (
int i=0; i<count; i++) {
926 output0[i] = ((fSlow0 * (double)input1[i]) + (fSlow1 * (double)input0[i]));
930 void Lv2Dsp::mono_process(
int count,
float *input,
float *output,
PluginDef *plugin) {
932 assert(
self.is_activated);
933 if (
self.pd->add_wet_dry) {
934 float wet_out[count];
935 self.connect(
self.loader.lv2_InputPort, 0, input);
936 self.connect(
self.loader.lv2_OutputPort, 0, wet_out);
937 lilv_instance_run(
self.instance, count);
938 self.mono_dry_wet(count, input, wet_out, output);
940 self.connect(
self.loader.lv2_InputPort, 0, input);
941 self.connect(
self.loader.lv2_OutputPort, 0, output);
942 lilv_instance_run(
self.instance, count);
946 void Lv2Dsp::up_to_stereo(
int count,
float *input0,
float *output0,
float *output1) {
947 memcpy(output0, input0, count *
sizeof(
float));
948 memcpy(output1, input0, count *
sizeof(
float));
951 void Lv2Dsp::down_to_mono(
int count,
float *input0,
float *input1,
float *output0) {
952 for (
int i=0; i<count; i++) {
953 output0[i] = 0.5 * (input0[i] + input1[i]);
957 void Lv2Dsp::to_mono_process(
int count,
float *input,
float *output,
PluginDef *plugin) {
959 assert(
self.is_activated);
960 if (
self.pd->add_wet_dry) {
961 float wet_out[count];
963 float inputs1[count];
964 float outputs[count];
965 float outputs1[count];
966 self.up_to_stereo(count,input,inputs, inputs1);
967 self.connect(
self.loader.lv2_InputPort, 0, inputs);
968 self.connect(
self.loader.lv2_InputPort, 1, inputs1);
969 self.connect(
self.loader.lv2_OutputPort, 0, outputs);
970 self.connect(
self.loader.lv2_OutputPort, 1, outputs1);
971 lilv_instance_run(
self.instance, count);
972 self.down_to_mono(count,outputs,outputs1,wet_out);
973 self.mono_dry_wet(count, input, wet_out, output);
976 float inputs1[count];
977 float outputs[count];
978 float outputs1[count];
979 self.up_to_stereo(count,input,inputs, inputs1);
980 self.connect(
self.loader.lv2_InputPort, 0, inputs);
981 self.connect(
self.loader.lv2_InputPort, 1, inputs1);
982 self.connect(
self.loader.lv2_OutputPort, 0, outputs);
983 self.connect(
self.loader.lv2_OutputPort, 1, outputs1);
984 lilv_instance_run(
self.instance, count);
985 self.down_to_mono(count,outputs,outputs1,output);
989 inline void Lv2Dsp::stereo_dry_wet(
int count,
float *input0,
float *input1,
float *input2,
float *input3,
float *output0,
float *output1)
991 double fSlow0 = (0.01 * dry_wet);
992 double fSlow1 = (1 - fSlow0);
993 for (
int i=0; i<count; i++) {
994 output0[i] = ((fSlow0 * (double)input2[i]) + (fSlow1 * (double)input0[i]));
995 output1[i] = ((fSlow0 * (double)input3[i]) + (fSlow1 * (double)input1[i]));
999 void Lv2Dsp::stereo_process(
int count,
float *input1,
float *input2,
float *output1,
float *output2,
PluginDef *plugin) {
1001 assert(
self.is_activated);
1002 if (
self.pd->add_wet_dry) {
1003 float wet_out1[count];
1004 float wet_out2[count];
1005 self.connect(
self.loader.lv2_InputPort, 0, input1);
1006 self.connect(
self.loader.lv2_InputPort, 1, input2);
1007 self.connect(
self.loader.lv2_OutputPort, 0, wet_out1);
1008 self.connect(
self.loader.lv2_OutputPort, 1, wet_out2);
1009 lilv_instance_run(
self.instance, count);
1010 self.stereo_dry_wet(count, input1, input2, wet_out1, wet_out2, output1, output2);
1012 self.connect(
self.loader.lv2_InputPort, 0, input1);
1013 self.connect(
self.loader.lv2_InputPort, 1, input2);
1014 self.connect(
self.loader.lv2_OutputPort, 0, output1);
1015 self.connect(
self.loader.lv2_OutputPort, 1, output2);
1016 lilv_instance_run(
self.instance, count);
1020 std::string Lv2Dsp::make_id(
const paradesc& p) {
1024 int Lv2Dsp::registerparam(
const ParamReg& reg) {
1029 int num_controls = lilv_plugin_get_num_ports_of_class(
self.plugin,
self.loader.lv2_ControlPort, 0);
1030 for (std::vector<paradesc*>::const_iterator it =
self.pd->names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
1031 if (n>=num_controls)
break;
1037 std::vector<paradesc*>::const_iterator it2 = it+1;
1038 while (it2 !=
self.pd->names.end() && !(*it2)->newrow) {
1047 const LilvPort* port = lilv_plugin_get_port_by_index(
self.plugin, d->
index);
1048 LilvNode* nm_node = lilv_port_get_name(
self.plugin, port);
1049 const char *nm = lilv_node_as_string(nm_node);
1050 Glib::ustring snm(d->
name);
1052 snm = TrimLabel(nm, cnt_in_row);
1060 case tp_none: tp =
"S";
break;
1061 case tp_int: tp =
"S";
break;
1067 default: assert(
false);
1069 reg.
registerVar(
self.make_id(*d).c_str(), snm.c_str(), tp, nm, &
self.ports[d->
index],
1072 lilv_node_free(nm_node);
1074 self.idd =
self.pd->id_str +
".dry_wet";
1075 reg.
registerVar(
self.idd.c_str(),
"",
"S",
"dry/wet",&
self.dry_wet, 100, 0, 100, 1);
1079 int Lv2Dsp::uiloader(
const UiBuilder& b,
int form) {
1085 if (
self.pd->master_idx >= 0) {
1087 for (std::vector<paradesc*>::const_iterator it =
self.pd->names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
1088 if ((n)==
self.pd->master_idx) {
1089 switch ((*it)->tp) {
1094 const char *p =
self.pd->master_label.c_str();
1109 for (std::vector<paradesc*>::const_iterator it =
self.pd->names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
1110 if ((*it)->newrow) {
1116 int num_controls = lilv_plugin_get_num_ports_of_class(
self.plugin,
self.loader.lv2_ControlPort, 0);
1117 for (std::vector<paradesc*>::const_iterator it =
self.pd->names.begin(); it !=
self.pd->names.end(); ++it, ++n) {
1118 if (n>=num_controls)
break;
1119 if ((*it)->newrow) {
1121 if ( (rows == 1) || ( rows > 1 && row > 0 )) {
1129 const LilvPort* port = lilv_plugin_get_port_by_index(
self.plugin, (*it)->index);
1130 LilvNode* nm_node = lilv_port_get_name(
self.plugin, port);
1131 const char *p1 = lilv_node_as_string(nm_node);
1132 if (!(*it)->name.empty())
1133 p1 = (*it)->name.c_str();
1134 Glib::ustring trim = TrimEffectLabel(p1, 4);
1135 const char *p = trim.c_str();
1136 std::string
id =
self.make_id(**it);
1137 if ((row == 1 && rows == 1 ) || (row >1 && rows >1 )) {
1140 switch ((*it)->tp) {
1143 if (!(*it)->has_caption) {
1149 if ((*it)->has_caption) {
1156 if (!(*it)->has_caption) {
1162 if ((*it)->has_caption) {
1169 if (!(*it)->has_caption) {
1172 if (((*it)->up - (*it)->low)<200) {
1179 if ((*it)->has_caption) {
1190 lilv_node_free(nm_node);
1192 if (
self.pd->add_wet_dry) {
1200 void Lv2Dsp::del_instance(
PluginDef *plugin) {
1201 delete static_cast<Lv2Dsp*
>(plugin);
1218 : options(options_),
1220 world(lilv_world_new()),
1222 lv2_AudioPort(lilv_new_uri(world, LV2_CORE__AudioPort)),
1223 lv2_ControlPort(lilv_new_uri(world, LV2_CORE__ControlPort)),
1224 lv2_InputPort(lilv_new_uri(world, LV2_CORE__InputPort)),
1225 lv2_OutputPort(lilv_new_uri(world, LV2_CORE__OutputPort)) {
1226 lilv_world_load_all(world);
1227 lv2_plugins = lilv_world_get_all_plugins(world);
1232 for (pluginarray::iterator i = plugins.begin(); i != plugins.end(); ++i) {
1235 lilv_node_free(lv2_OutputPort);
1236 lilv_node_free(lv2_InputPort);
1237 lilv_node_free(lv2_ControlPort);
1238 lilv_node_free(lv2_AudioPort);
1239 lilv_world_free(world);
1244 read_module_list(ml);
1246 gx_print_error(
"ladspaloader",ustring::compose(_(
"Exception in LADSPA list reader: %1"), e.
what()));
1253 for (pluginarray::iterator i = plugins.begin(); i != plugins.end(); ++i) {
1256 plugins = new_plugins;
1263 plugins = new_plugins;
1267 for (pluginarray::iterator i =
begin(); i !=
end(); ++i) {
1269 if ((*i)->path == desc->
path) {
1273 if ((*i)->UniqueID == desc->
UniqueID) {
1283 static_cast<Lv2Dsp*
>(pdef)->set_plugdesc(pdesc);
1285 static_cast<LadspaDsp*
>(pdef)->set_plugdesc(pdesc);
1290 for (
value_pair *p = values; p->value_id; ++p) {
1291 g_free(const_cast<char*>(p->value_id));
1299 for (std::vector<std::string>::const_iterator i = v.begin(); i != v.end(); ++i, ++n) {
1300 const char *p = g_strdup(i->c_str());
1301 values[n].value_id = p;
1302 values[n].value_label = p;
1304 values[n].value_id = 0;
1305 values[n].value_label = 0;
1308 void LadspaLoader::read_module_config(
const std::string& filename,
plugdesc *p) {
1309 std::ifstream ifs(filename.c_str());
1311 gx_print_error(
"ladspaloader", ustring::compose(_(
"can't open %1"), filename));
1360 std::vector<std::string> v;
1368 p->
names.push_back(para);
1375 void LadspaLoader::read_module_list(
pluginarray& ml) {
1405 if (access(fname.c_str(), F_OK) != 0) {
1407 if (access(fname.c_str(), F_OK) != 0) {
1411 if (!fname.empty()) {
1413 read_module_config(fname, p);
1415 gx_print_error(
"ladspaloader",ustring::compose(_(
"read error in file %1: %2"), s, e.
what()));
void write_kv(const char *key, float v)
CmdConnection::msg_type start
void begin_array(bool nl=false)
pluginarray::iterator end()
std::string get_factory_filepath(const std::string &basename) const
void end_array(bool nl=false)
void writeJSON(gx_system::JsonWriter &jw)
int(* uiloader)(const UiBuilder &builder, int format)
void set_plugins(pluginarray &new_plugins)
void set_plugdesc(const plugdesc *pd_)
LadspaLoader(const gx_system::CmdlineOptions &options)
std::vector< plugdesc * > pluginarray
void set_plugdesc(const plugdesc *pd_)
float *(* registerVar)(const char *id, const char *name, const char *tp, const char *tooltip, float *var, float val, float low, float up, float step)
void(* create_switch_no_caption)(const char *sw_type, const char *id)
void(* registerEnumVar)(const char *id, const char *name, const char *tp, const char *tooltip, const value_pair *values, float *var, float val, float low, float up, float step)
pluginarray::iterator find(plugdesc *desc)
void write_key(const char *p, bool nl=false)
bool load(pluginarray &p)
void readJSON(gx_system::JsonParser &jp)
deletefunc delete_instance
static LadspaDsp * create(const plugdesc *plug)
static Lv2Dsp * create(const plugdesc *plug, const LadspaLoader &loader)
void gx_print_error(const char *, const std::string &)
bool read_kv(const char *key, float &v)
void(* create_selector)(const char *id, const char *label)
PluginDef * create(unsigned int idx)
#define PLUGINDEF_VERSION
void(* openHorizontalBox)(const char *label)
registerfunc register_params
void(* create_port_display)(const char *id, const char *label)
std::string get_plugin_filepath(const std::string &basename) const
void begin_object(bool nl=false)
void(* create_small_rackknobr)(const char *id, const char *label)
Glib::ustring master_label
std::string to_string(const T &t)
virtual const char * what() const
void(* create_small_rackknob)(const char *id, const char *label)
std::vector< paradesc * > names
void gx_print_warning(const char *, const std::string &)
void(* openHorizontalhideBox)(const char *label)
activatefunc activate_plugin
void(* create_spin_value)(const char *id, const char *label)
process_stereo_audio stereo_audio
std::string get_user_filepath(const std::string &basename) const
void update_instance(PluginDef *pdef, plugdesc *pdesc)
pluginarray::iterator begin()
string current_value() const
void readJSON(gx_system::JsonParser &jp)
void(* set_next_flags)(int flags)
void writeJSON(gx_system::JsonWriter &jw)
process_mono_audio mono_audio
void set_valuelist(const std::vector< std::string > &v)
static std::string get_ladspa_filename(unsigned long uid)
float current_value_float()
token next(token expect=no_token)
void write(float v, bool nl=false)
void(* create_switch)(const char *sw_type, const char *id, const char *label)
void change_plugins(pluginarray &new_plugins)
void(* create_master_slider)(const char *id, const char *label)
void end_object(bool nl=false)
void(* create_selector_no_caption)(const char *id)
void(* openVerticalBox)(const char *label)
std::string encode_filename(const std::string &s)