splashgui text clr, faders/speed keyframe popup slider rework, reticle rework
[goodguy/history.git] / cinelerra-5.1 / cinelerra / pluginlv2ui.C
1
2 // shared between parent/child fork
3 #include "language.h"
4 #include "pluginlv2ui.h"
5
6 #include <gtk/gtk.h>
7 #include <gdk/gdk.h>
8
9 #include <ctype.h>
10 #include <string.h>
11
12 void PluginLV2UI::update_value(int idx, uint32_t bfrsz, uint32_t typ, const void *bfr)
13 {
14         if( idx >= config.nb_ports ) return;
15         for( int i=0, sz=config.size(); i<sz; ++i ) {
16                 PluginLV2Client_Opt *opt = config[i];
17                 if( opt->idx == idx ) {
18                         opt->set_value(*(const float*)bfr);
19                         updates |= UPDATE_HOST;
20                         break;
21                 }
22         }
23 }
24 void PluginLV2UI::write_from_ui(void *the, uint32_t idx,
25                 uint32_t bfrsz, uint32_t typ, const void *bfr)
26 {
27         ((PluginLV2UI*)the)->update_value(idx, bfrsz, typ, bfr);
28 }
29
30 uint32_t PluginLV2UI::port_index(void* obj, const char* sym)
31 {
32         PluginLV2UI *the = (PluginLV2UI*)obj;
33         for( int i=0, sz=the->config.size(); i<sz; ++i ) {
34                 PluginLV2Client_Opt *opt = the->config[i];
35                 if( !strcmp(sym, opt->sym) ) return opt->idx;
36         }
37         return UINT32_MAX;
38 }
39
40 void PluginLV2UI::update_control(int idx, uint32_t bfrsz, uint32_t typ, const void *bfr)
41 {
42         if( !sinst || idx >= config.nb_ports ) return;
43         suil_instance_port_event(sinst, idx, bfrsz, typ, bfr);
44 }
45
46
47 uint32_t PluginLV2UI::uri_to_id(LV2_URID_Map_Handle handle, const char *map, const char *uri)
48 {
49         return ((PluginLV2UriTable *)handle)->map(uri);
50 }
51
52 LV2_URID PluginLV2UI::uri_table_map(LV2_URID_Map_Handle handle, const char *uri)
53 {
54         return ((PluginLV2UriTable *)handle)->map(uri);
55 }
56
57 const char *PluginLV2UI::uri_table_unmap(LV2_URID_Map_Handle handle, LV2_URID urid)
58 {
59         return ((PluginLV2UriTable *)handle)->unmap(urid);
60 }
61
62 void PluginLV2UI::lv2ui_instantiate(void *parent)
63 {
64         if ( !ui_host ) {
65                 ui_host = suil_host_new(
66                         PluginLV2UI::write_from_ui,
67                         PluginLV2UI::port_index,
68                         0, 0);
69 //              suil_host_set_touch_func(ui_host, cb_touch);
70         }
71
72         features.remove();  // remove terminating zero
73         ui_features = features.size();
74         LV2_Handle lilv_handle = lilv_instance_get_handle(inst);
75         features.append(new Lv2Feature(NS_EXT "instance-access", lilv_handle));
76         const LV2_Descriptor *lilv_desc = lilv_instance_get_descriptor(inst);
77         ext_data = new LV2_Extension_Data_Feature();
78         ext_data->data_access = lilv_desc->extension_data;
79         features.append(new Lv2Feature(LV2_DATA_ACCESS_URI, ext_data));
80         features.append(new Lv2Feature(LV2_UI__parent, parent));
81         features.append(new Lv2Feature(LV2_UI__idleInterface, 0));
82         features.append(new Lv2Feature(LV2_EXTERNAL_UI_URI, &extui_host));
83         features.append(new Lv2Feature(LV2_EXTERNAL_UI_URI__KX__Host, &extui_host));
84         features.append(0); // add new terminating zero
85
86         const char* bundle_uri  = lilv_node_as_uri(lilv_ui_get_bundle_uri(lilv_ui));
87         char*       bundle_path = lilv_file_uri_parse(bundle_uri, NULL);
88         const char* binary_uri  = lilv_node_as_uri(lilv_ui_get_binary_uri(lilv_ui));
89         char*       binary_path = lilv_file_uri_parse(binary_uri, NULL);
90         sinst = suil_instance_new(ui_host, this, ui_type,
91                 lilv_node_as_uri(lilv_plugin_get_uri(lilv)),
92                 lilv_node_as_uri(lilv_ui_get_uri(lilv_ui)),
93                 lilv_node_as_uri(lilv_type),
94                 bundle_path, binary_path, features);
95
96         lilv_free(binary_path);
97         lilv_free(bundle_path);
98 }
99
100 bool PluginLV2UI::lv2ui_resizable()
101 {
102         if( !lilv_ui ) return false;
103         const LilvNode* s   = lilv_ui_get_uri(lilv_ui);
104         LilvNode *p   = lilv_new_uri(world, LV2_CORE__optionalFeature);
105         LilvNode *fs  = lilv_new_uri(world, LV2_UI__fixedSize);
106         LilvNode *nrs = lilv_new_uri(world, LV2_UI__noUserResize);
107         LilvNodes *fs_matches = lilv_world_find_nodes(world, s, p, fs);
108         LilvNodes *nrs_matches = lilv_world_find_nodes(world, s, p, nrs);
109         lilv_nodes_free(nrs_matches);
110         lilv_nodes_free(fs_matches);
111         lilv_node_free(nrs);
112         lilv_node_free(fs);
113         lilv_node_free(p);
114         return !fs_matches && !nrs_matches;
115 }
116
117 int PluginLV2UI::update_lv2_input(float *vals, int force)
118 {
119         int ret = 0;
120         float *ctls = config.ctls;
121         for( int i=0; i<config.size(); ++i ) {
122                 int idx = config[i]->idx;
123                 float val = vals[idx];
124                 if( !force && ctls[idx] == val ) continue;
125                 ctls[idx] = val;
126                 update_control(idx, sizeof(ctls[idx]), 0, &ctls[idx]);
127                 ++ret;
128         }
129         return ret;
130 }
131
132 void PluginLV2UI::update_lv2_output()
133 {
134         int *ports = config.ports;
135         float *ctls = config.ctls;
136         for( int i=0; i<config.nb_ports; ++i ) {
137                 if( !(ports[i] & PORTS_UPDATE) ) continue;
138                 ports[i] &= ~PORTS_UPDATE;
139                 update_control(i, sizeof(ctls[i]), 0, &ctls[i]);
140         }
141 }
142
143 void PluginLV2UI::run_lilv(int samples)
144 {
145         float ctls[config.nb_ports];
146         for( int i=0; i<config.nb_ports; ++i ) ctls[i] = config.ctls[i];
147
148         lilv_instance_run(inst, samples);
149
150         if( worker_iface ) worker_responses();
151
152         for( int i=0; i<config.nb_ports; ++i ) {
153                 if( !(config.ports[i] & PORTS_OUTPUT) ) continue;
154                 if( !(config.ports[i] & PORTS_CONTROL) ) continue;
155                 if( config.ctls[i] == ctls[i] ) continue;
156                 config.ports[i] |= PORTS_UPDATE;
157                 updates |= UPDATE_PORTS;
158         }
159 }
160
161 void PluginLV2ChildUI::start_gui()
162 {
163         if( gui ) gui->start_gui();
164         update_lv2_input(config.ctls, 1);
165         connect_ports(config, PORTS_CONTROL | PORTS_ATOM);
166         int n = 0;
167 #if 1
168 // some plugins must have pointers, or they crash
169         float inp[nb_inputs], out[nb_outputs];
170         memset(&inp, 0, nb_inputs*sizeof(float));
171         memset(&out, 0, nb_outputs*sizeof(float));
172         int ich = 0, och = 0;
173         for( int i=0; i<config.nb_ports; ++i ) {
174                 const LilvPort *lp = lilv_plugin_get_port_by_index(lilv, i);
175                 if( !lp ) continue;
176                 int port = config.ports[i];
177                 if( !(port & PORTS_AUDIO) ) continue;
178                 if( (port & PORTS_INPUT) ) {
179                         lilv_instance_connect_port(inst, i, &inp[ich++]);
180                         continue;
181                 }
182                 if( (port & PORTS_OUTPUT) ) {
183                         lilv_instance_connect_port(inst, i, &out[och++]);
184                         continue;
185                 }
186         }
187         n = 1;
188 #endif
189         updates = 0;
190         run_lilv(n);
191         if( gui ) {
192                 send_host(LV2_SHOW, 0, 0);
193                 hidden = 0;
194         }
195 }
196
197 void PluginLV2UI::update_host()
198 {
199 // ignore update
200         if( running < 0 ) { running = 1;  return; }
201         send_host(LV2_UPDATE, config.ctls, sizeof(float)*config.nb_ports);
202 }
203
204
205 static void lv2ui_extui_host_ui_closed(void *p)
206 {
207         PluginLV2UI *ui = (PluginLV2UI *)p;
208         ui->hidden = -1;
209 }
210
211 int PluginLV2ChildUI::init_ui(const char *path, int sample_rate, int bfrsz)
212 {
213         char *title = PluginLV2UI::title;
214         if( load_lv2(path, title) ) return 1;
215         if( init_lv2(config, sample_rate, bfrsz) ) return 1;
216
217         lilv_uis = lilv_plugin_get_uis(lilv);
218         if( !gui && lilv_uis && wgt_type ) {
219                 LilvNode *gui_type = lilv_new_uri(world, wgt_type);
220                 LILV_FOREACH(uis, i, lilv_uis) {
221                         const LilvUI *ui = lilv_uis_get(lilv_uis, i);
222                         if( lilv_ui_is_supported(ui, suil_ui_supported, gui_type, &lilv_type)) {
223                                 extui_host.ui_closed = lv2ui_extui_host_ui_closed;
224                                 gui = new PluginLV2ChildWgtUI(this);
225                                 lilv_ui = ui;
226                                 ui_type = wgt_type;
227                                 break;
228                         }
229                 }
230                 lilv_node_free(gui_type);
231         }
232         if( !gui && lilv_uis && gtk_type ) {
233                 LilvNode *gui_type = lilv_new_uri(world, gtk_type);
234                 LILV_FOREACH(uis, i, lilv_uis) {
235                         const LilvUI *ui = lilv_uis_get(lilv_uis, i);
236                         if( lilv_ui_is_supported(ui, suil_ui_supported, gui_type, &lilv_type)) {
237                                 gui = new PluginLV2ChildGtkUI(this);
238                                 lilv_ui = ui;
239                                 ui_type = gtk_type;
240                                 break;
241                         }
242                 }
243                 lilv_node_free(gui_type);
244                 ui_type = gtk_type;
245         }
246
247         lilv_instance_activate(inst);
248         return 0;
249 }
250
251 void PluginLV2ChildUI::reset_gui()
252 {
253         if( gui ) gui->reset_gui();
254         if( sinst )     { suil_instance_free(sinst);  sinst = 0; }
255         if( ui_host )   { suil_host_free(ui_host);    ui_host = 0; }
256
257         while( features.size() > ui_features ) features.remove_object();
258         features.append(0);
259         send_host(LV2_HIDE, 0, 0);
260         hidden = 1;
261 }
262
263 // main loop
264 int PluginLV2ChildUI::run_ui()
265 {
266         double last_time = 0;
267         int64_t frame_usecs = 1e6 / refreshrate;
268         running = 1;
269         done = 0;
270         while( !done ) {
271                 if( hidden < 0 ) {
272                         if( gui ) gui->top_level = 0;
273                         reset_gui();
274                         if( !is_forked() ) {
275                                 done = -1;
276                                 break;
277                         }
278                         hidden = 1;
279                 }
280                 if( updates ) {
281                         if( (updates & UPDATE_PORTS) )
282                                 update_lv2_output();
283                         if( (updates & UPDATE_HOST) )
284                                 update_host();
285                         updates = 0;
286                 }
287                 struct timeval tv;  gettimeofday(&tv, 0);
288                 double t = tv.tv_sec + tv.tv_usec / 1e6;
289                 double dt = t - last_time;  last_time = t;
290                 int64_t usec = frame_usecs - dt*1e6;
291                 if( usec < 0 ) usec = 0;
292                 if( child_iteration(usec) < 0 )
293                         done = 1;
294         }
295         running = 0;
296         return 0;
297 }
298
299 void PluginLV2ChildUI::run_buffer(int shmid)
300 {
301         if( !shm_buffer(shmid) ) return;
302         map_buffer();
303         connect_ports(config, PORTS_ALL);
304         run_lilv(shm_bfr->samples);
305         shm_bfr->done = 1;
306 }
307
308 int PluginLV2ChildUI::child_iteration(int64_t usec)
309 {
310         int ret = 0;
311         if( is_forked() )
312                 ret = read_child(usec);
313         else if( gui )
314                 usleep(usec);
315         else
316                 ret = -1;
317
318         if( ret > 0 ) {
319                 switch( child_token ) {
320                 case LV2_OPEN: {
321                         open_bfr_t *open_bfr = (open_bfr_t *)child_data;
322                         if( init_ui(open_bfr->path, open_bfr->sample_rate, open_bfr->bfrsz) ) {
323                                 printf("lv2ui: unable to init: %s\n", open_bfr->path);
324                                 exit(1);
325                         }
326                         break; }
327                 case LV2_LOAD: {
328                         float *vals = (float *)child_data;
329                         update_lv2_input(vals, 1);
330                         break; }
331                 case LV2_UPDATE: {
332                         float *vals = (float *)child_data;
333                         update_lv2_input(vals, 0);
334                         break; }
335                 case LV2_SHOW: {
336                         start_gui();
337                         break; }
338                 case LV2_HIDE: {
339                         reset_gui();
340                         break; }
341                 case LV2_SHMID: {
342                         int shmid = *(int *)child_data;
343                         run_buffer(shmid);
344                         send_parent(LV2_SHMID, 0, 0);
345                         break; }
346                 case EXIT_CODE:
347                         return -1;
348                 }
349         }
350         if( ret >= 0 && gui )
351                 gui->handle_child();
352         return ret;
353 }
354
355 int PluginLV2ChildUI::send_host(int64_t token, const void *data, int bytes)
356 {
357         return is_forked() ? send_parent(token, data, bytes) : 0;
358 }
359
360 PluginLV2GUI::PluginLV2GUI(PluginLV2ChildUI *child_ui)
361 {
362         this->child_ui = child_ui;
363         top_level = 0;
364 }
365
366 PluginLV2GUI::~PluginLV2GUI()
367 {
368 }
369
370 PluginLV2ChildGtkUI::PluginLV2ChildGtkUI(PluginLV2ChildUI *child_ui)
371  : PluginLV2GUI(child_ui)
372 {
373         gtk_set_locale();
374         gtk_init(&child_ui->ac, &child_ui->av);
375 }
376
377 PluginLV2ChildGtkUI::~PluginLV2ChildGtkUI()
378 {
379 }
380
381 void PluginLV2ChildGtkUI::reset_gui()
382 {
383         GtkWidget *top_level = (GtkWidget *)this->top_level;
384         if( top_level ) { gtk_widget_destroy(top_level); this->top_level = 0; }
385 }
386
387 static void lilv_gtk_destroy(GtkWidget* widget, gpointer data)
388 {
389         PluginLV2ChildGtkUI *gui = (PluginLV2ChildGtkUI*)data;
390         gui->child_ui->hidden = -1;
391 }
392
393 void PluginLV2ChildGtkUI::start_gui()
394 {
395         this->top_level = (void *)gtk_window_new(GTK_WINDOW_TOPLEVEL);
396         GtkWidget *top_level = (GtkWidget *)this->top_level;
397         g_signal_connect(top_level, "destroy", G_CALLBACK(lilv_gtk_destroy), this);
398         char *title = child_ui->PluginLV2UI::title;
399         gtk_window_set_title(GTK_WINDOW(top_level), title);
400
401         GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
402         gtk_window_set_role(GTK_WINDOW(top_level), "plugin_ui");
403         gtk_container_add(GTK_CONTAINER(top_level), vbox);
404
405         GtkWidget *alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0);
406         gtk_box_pack_start(GTK_BOX(vbox), alignment, TRUE, TRUE, 0);
407         gtk_widget_show(alignment);
408         child_ui->lv2ui_instantiate(alignment);
409         GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(child_ui->sinst);
410         gtk_container_add(GTK_CONTAINER(alignment), widget);
411         gtk_window_set_resizable(GTK_WINDOW(top_level), child_ui->lv2ui_resizable());
412         gtk_widget_show_all(vbox);
413         gtk_widget_grab_focus(widget);
414         gtk_window_present(GTK_WINDOW(top_level));
415 }
416
417 int PluginLV2ChildGtkUI::handle_child()
418 {
419         if( gtk_events_pending() ) {
420                 gtk_main_iteration();
421         }
422         return 1;
423 }
424
425 PluginLV2ChildWgtUI::PluginLV2ChildWgtUI(PluginLV2ChildUI *child_ui)
426  : PluginLV2GUI(child_ui)
427 {
428 }
429
430 PluginLV2ChildWgtUI::~PluginLV2ChildWgtUI()
431 {
432 }
433
434 void PluginLV2ChildWgtUI::reset_gui()
435 {
436         lv2_external_ui *top_level = (lv2_external_ui *)this->top_level;
437         if( top_level ) { LV2_EXTERNAL_UI_HIDE(top_level); this->top_level = 0; }
438 }
439
440 void PluginLV2ChildWgtUI::start_gui()
441 {
442         child_ui->lv2ui_instantiate(0);
443         this->top_level = (void *)suil_instance_get_widget(child_ui->sinst);
444         lv2_external_ui *top_level = (lv2_external_ui *)this->top_level;
445         if( top_level ) LV2_EXTERNAL_UI_SHOW(top_level);
446 }
447
448 int PluginLV2ChildWgtUI::handle_child()
449 {
450         lv2_external_ui *top_level = (lv2_external_ui *)this->top_level;
451         if( top_level )
452                 LV2_EXTERNAL_UI_RUN(top_level);
453         return 1;
454 }
455