rework set default transtion, nested proxy edl fixes, doubleclick proxy media fix...
[goodguy/history.git] / cinelerra-5.1 / cinelerra / pluginlv2config.C
1 #ifdef HAVE_LV2
2
3 /*
4  * CINELERRA
5  * Copyright (C) 2018 GG
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  */
22
23 #include "arraylist.h"
24 #include "cstrdup.h"
25 #include "language.h"
26 #include "pluginlv2.h"
27 #include "pluginlv2config.h"
28
29 #include <ctype.h>
30 #include <string.h>
31
32 PluginLV2UriTable::PluginLV2UriTable()
33  : Mutex("PluginLV2UriTable::PluginLV2UriTable")
34 {
35         set_array_delete();
36 }
37
38 PluginLV2UriTable::~PluginLV2UriTable()
39 {
40         remove_all_objects();
41 }
42
43 LV2_URID PluginLV2UriTable::map(const char *uri)
44 {
45         lock("PluginLV2UriTable::map");
46         int i = 0, n = size();
47         while( i<n && strcmp(uri, get(i)) ) ++i;
48         if( i >= n ) append(cstrdup(uri));
49         unlock();
50         return i+1;
51 }
52
53 const char *PluginLV2UriTable::unmap(LV2_URID urid)
54 {
55         lock("PluginLV2UriTable::unmap");
56         int idx = urid - 1;
57         const char *ret = idx>=0 && idx<size() ? get(idx) : 0;
58         unlock();
59         return ret;
60 }
61
62 PluginLV2Client_OptName:: PluginLV2Client_OptName(PluginLV2Client_Opt *opt)
63 {
64         this->opt = opt;
65         set_text(opt->get_name());
66 }
67
68 PluginLV2Client_OptValue::PluginLV2Client_OptValue(PluginLV2Client_Opt *opt)
69 {
70         this->opt = opt;
71         update();
72 }
73
74 int PluginLV2Client_OptValue::update()
75 {
76         char val[BCSTRLEN];
77         sprintf(val, "%f", opt->get_value());
78         if( !strcmp(val, get_text()) ) return 0;
79         set_text(val);
80         return 1;
81 }
82
83
84 PluginLV2Client_Opt::PluginLV2Client_Opt(PluginLV2ClientConfig *conf, int idx)
85 {
86         this->conf = conf;
87         this->idx = idx;
88         item_name = new PluginLV2Client_OptName(this);
89         item_value = new PluginLV2Client_OptValue(this);
90 }
91
92 PluginLV2Client_Opt::~PluginLV2Client_Opt()
93 {
94         delete item_name;
95         delete item_value;
96 }
97
98 float PluginLV2Client_Opt::get_value()
99 {
100         return conf->ctls[idx];
101 }
102
103 const char *PluginLV2Client_Opt::get_symbol()
104 {
105         return conf->syms[idx];
106 }
107
108 void PluginLV2Client_Opt::set_value(float v)
109 {
110         conf->ctls[idx] = v;
111 }
112
113 int PluginLV2Client_Opt::update(float v)
114 {
115         set_value(v);
116         return item_value->update();
117 }
118
119 const char *PluginLV2Client_Opt::get_name()
120 {
121         return conf->names[idx];
122 }
123
124 PluginLV2ClientConfig::PluginLV2ClientConfig()
125 {
126         names = 0;
127         syms = 0;
128         mins = 0;
129         maxs = 0;
130         ctls = 0;
131         ports = 0;
132         nb_ports = 0;
133 }
134
135 PluginLV2ClientConfig::~PluginLV2ClientConfig()
136 {
137         reset();
138         remove_all_objects();
139 }
140
141 void PluginLV2ClientConfig::reset()
142 {
143         for( int i=0; i<nb_ports; ++i ) {
144                 delete [] names[i];
145                 delete [] syms[i];
146         }
147         delete [] names;  names = 0;
148         delete [] mins;   mins = 0;
149         delete [] maxs;   maxs = 0;
150         delete [] ctls;   ctls = 0;
151         delete [] ports;  ports = 0;
152         nb_ports = 0;
153 }
154
155
156 int PluginLV2ClientConfig::equivalent(PluginLV2ClientConfig &that)
157 {
158         PluginLV2ClientConfig &conf = *this;
159         for( int i=0; i<that.size(); ++i ) {
160                 PluginLV2Client_Opt *topt = conf[i], *vopt = that[i];
161                 if( !EQUIV(topt->get_value(), vopt->get_value()) ) return 0;
162         }
163         return 1;
164 }
165
166 void PluginLV2ClientConfig::copy_from(PluginLV2ClientConfig &that)
167 {
168         if( nb_ports != that.nb_ports ) {
169                 reset();
170                 nb_ports = that.nb_ports;
171                 names = new const char *[nb_ports];
172                 syms = new const char *[nb_ports];
173                 for( int i=0; i<nb_ports; ++i ) names[i] = syms[i] = 0;
174                 mins  = new float[nb_ports];
175                 maxs  = new float[nb_ports];
176                 ctls  = new float[nb_ports];
177                 ports = new int[nb_ports];
178         }
179         for( int i=0; i<nb_ports; ++i ) {
180                 delete [] names[i];  names[i] = cstrdup(that.names[i]);
181                 delete [] syms[i];   syms[i] = cstrdup(that.syms[i]);
182                 mins[i] = that.mins[i];
183                 maxs[i] = that.maxs[i];
184                 ctls[i] = that.ctls[i];
185                 ports[i] = ports[i];
186         }
187         remove_all_objects();
188         for( int i=0; i<that.size(); ++i ) {
189                 append(new PluginLV2Client_Opt(this, that[i]->idx));
190         }
191 }
192
193 void PluginLV2ClientConfig::interpolate(PluginLV2ClientConfig &prev, PluginLV2ClientConfig &next,
194         int64_t prev_frame, int64_t next_frame, int64_t current_frame)
195 {
196         copy_from(prev);
197 }
198
199 void PluginLV2ClientConfig::init_lv2(const LilvPlugin *lilv, PluginLV2 *lv2)
200 {
201         reset();
202         nb_ports = lilv_plugin_get_num_ports(lilv);
203         names = new const char *[nb_ports];
204         syms = new const char *[nb_ports];
205         mins  = new float[nb_ports];
206         maxs  = new float[nb_ports];
207         ctls  = new float[nb_ports];
208         ports = new int[nb_ports];
209         lilv_plugin_get_port_ranges_float(lilv, mins, maxs, ctls);
210         for( int i=0; i<nb_ports; ++i ) {
211                 const LilvPort *lp = lilv_plugin_get_port_by_index(lilv, i);
212                 LilvNode *pnm = lilv_port_get_name(lilv, lp);
213                 names[i] = cstrdup(lilv_node_as_string(pnm));
214                 lilv_node_free(pnm);
215                 const LilvNode *sym = lilv_port_get_symbol(lilv, lp);
216                 syms[i] = cstrdup(lilv_node_as_string(sym));
217                 int port = 0;
218                 if( lilv_port_is_a(lilv, lp, lv2->lv2_AudioPort) )   port |= PORTS_AUDIO;
219                 if( lilv_port_is_a(lilv, lp, lv2->lv2_ControlPort) ) port |= PORTS_CONTROL;
220                 if( lilv_port_is_a(lilv, lp, lv2->lv2_InputPort) )   port |= PORTS_INPUT;
221                 if( lilv_port_is_a(lilv, lp, lv2->lv2_OutputPort) )  port |= PORTS_OUTPUT;
222                 if( lilv_port_is_a(lilv, lp, lv2->atom_AtomPort) )   port |= PORTS_ATOM;
223                 ports[i] = port;
224         }
225 }
226
227 int PluginLV2ClientConfig::update()
228 {
229         int ret = 0;
230         PluginLV2ClientConfig &conf = *this;
231         for( int i=0; i<size(); ++i ) {
232                 if( conf[i]->item_value->update() ) ++ret;
233         }
234         return ret;
235 }
236
237 void PluginLV2ClientConfig::dump(FILE *fp)
238 {
239         fprintf(fp, "Controls:\n");
240         for( int i=0; i<size(); ++i ) {
241                 fprintf(fp, " %3d. (%3d)  %-24s  %f\n",
242                         i, get(i)->idx, get(i)->get_symbol(), get(i)->get_value());
243         }
244         fprintf(fp, "Ports:\n");
245         for( int i=0; i<nb_ports; ++i ) {
246                 fprintf(fp, " %3d.  %-24s  %f  (%f - %f) %s\n",
247                         i, syms[i], ctls[i], mins[i], maxs[i], names[i]);
248         }
249 }
250
251 #endif /* HAVE_LV2 */