Reported by Fedora team for gcc-13 and Andrew created patch here
[goodguy/cinelerra.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 [] syms;   syms = 0;
149         delete [] mins;   mins = 0;
150         delete [] maxs;   maxs = 0;
151         delete [] ctls;   ctls = 0;
152         delete [] ports;  ports = 0;
153         nb_ports = 0;
154 }
155
156
157 int PluginLV2ClientConfig::equivalent(PluginLV2ClientConfig &that)
158 {
159         PluginLV2ClientConfig &conf = *this;
160         for( int i=0; i<that.size(); ++i ) {
161                 PluginLV2Client_Opt *topt = conf[i], *vopt = that[i];
162                 if( !EQUIV(topt->get_value(), vopt->get_value()) ) return 0;
163         }
164         return 1;
165 }
166
167 void PluginLV2ClientConfig::copy_from(PluginLV2ClientConfig &that)
168 {
169         if( nb_ports != that.nb_ports ) {
170                 reset();
171                 nb_ports = that.nb_ports;
172                 names = new const char *[nb_ports];
173                 syms = new const char *[nb_ports];
174                 for( int i=0; i<nb_ports; ++i ) names[i] = syms[i] = 0;
175                 mins  = new float[nb_ports];
176                 maxs  = new float[nb_ports];
177                 ctls  = new float[nb_ports];
178                 ports = new int[nb_ports];
179         }
180         for( int i=0; i<nb_ports; ++i ) {
181                 delete [] names[i];  names[i] = cstrdup(that.names[i]);
182                 delete [] syms[i];   syms[i] = cstrdup(that.syms[i]);
183                 mins[i] = that.mins[i];
184                 maxs[i] = that.maxs[i];
185                 ctls[i] = that.ctls[i];
186                 ports[i] = ports[i];
187         }
188         remove_all_objects();
189         for( int i=0; i<that.size(); ++i ) {
190                 append(new PluginLV2Client_Opt(this, that[i]->idx));
191         }
192 }
193
194 void PluginLV2ClientConfig::interpolate(PluginLV2ClientConfig &prev, PluginLV2ClientConfig &next,
195         int64_t prev_frame, int64_t next_frame, int64_t current_frame)
196 {
197         copy_from(prev);
198 }
199
200 void PluginLV2ClientConfig::init_lv2(const LilvPlugin *lilv, PluginLV2 *lv2)
201 {
202         reset();
203         nb_ports = lilv_plugin_get_num_ports(lilv);
204         names = new const char *[nb_ports];
205         syms = new const char *[nb_ports];
206         mins  = new float[nb_ports];
207         maxs  = new float[nb_ports];
208         ctls  = new float[nb_ports];
209         ports = new int[nb_ports];
210         lilv_plugin_get_port_ranges_float(lilv, mins, maxs, ctls);
211         for( int i=0; i<nb_ports; ++i ) {
212                 const LilvPort *lp = lilv_plugin_get_port_by_index(lilv, i);
213                 LilvNode *pnm = lilv_port_get_name(lilv, lp);
214                 names[i] = cstrdup(lilv_node_as_string(pnm));
215                 lilv_node_free(pnm);
216                 const LilvNode *sym = lilv_port_get_symbol(lilv, lp);
217                 syms[i] = cstrdup(lilv_node_as_string(sym));
218                 int port = 0;
219                 if( lilv_port_is_a(lilv, lp, lv2->lv2_AudioPort) )   port |= PORTS_AUDIO;
220                 if( lilv_port_is_a(lilv, lp, lv2->lv2_ControlPort) ) port |= PORTS_CONTROL;
221                 if( lilv_port_is_a(lilv, lp, lv2->lv2_InputPort) )   port |= PORTS_INPUT;
222                 if( lilv_port_is_a(lilv, lp, lv2->lv2_OutputPort) )  port |= PORTS_OUTPUT;
223                 if( lilv_port_is_a(lilv, lp, lv2->atom_AtomPort) )   port |= PORTS_ATOM;
224                 ports[i] = port;
225         }
226 }
227
228 int PluginLV2ClientConfig::update()
229 {
230         int ret = 0;
231         PluginLV2ClientConfig &conf = *this;
232         for( int i=0; i<size(); ++i ) {
233                 if( conf[i]->item_value->update() ) ++ret;
234         }
235         return ret;
236 }
237
238 void PluginLV2ClientConfig::dump(FILE *fp)
239 {
240         fprintf(fp, "Controls:\n");
241         for( int i=0; i<size(); ++i ) {
242                 fprintf(fp, " %3d. (%3d)  %-24s  %f\n",
243                         i, get(i)->idx, get(i)->get_symbol(), get(i)->get_value());
244         }
245         fprintf(fp, "Ports:\n");
246         for( int i=0; i<nb_ports; ++i ) {
247                 fprintf(fp, " %3d.  %-24s  %f  (%f - %f) %s\n",
248                         i, syms[i], ctls[i], mins[i], maxs[i], names[i]);
249         }
250 }
251
252 #endif /* HAVE_LV2 */