2 * Copyright (C) 2013-2015 Paul Davis <paul@linuxaudiosystems.com>
3 * Copyright (C) 2014-2019 Robin Gareus <robin@gareus.org>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 /******************************************************************/
21 /** VSTFX - An engine based on FST for handling linuxVST plugins **/
22 /******************************************************************/
32 #include <glibmm/timer.h>
34 #include "ardour/linux_vst_support.h"
35 #include "ardour/vst_plugin.h"
53 static pthread_mutex_t plugin_mutex;
55 static VSTState * vstfx_first = NULL;
57 const char magic[] = "VSTFX Plugin State v002";
59 static volatile int gui_quit = 0;
61 /*This will be our connection to X*/
63 static Display* LXVST_XDisplay = NULL;
65 /*The thread handle for the GUI event loop*/
67 static pthread_t LXVST_gui_event_thread;
69 /*Util functions to get the value of a property attached to an XWindow*/
71 static bool LXVST_xerror;
73 int TempErrorHandler (Display *display, XErrorEvent *e)
82 int getXWindowProperty (Window window, Atom atom)
87 unsigned long userCount;
92 /*Use our own Xerror handler while we're in here - in an
93 attempt to stop the brain dead default Xerror behaviour of
94 qutting the entire application because of e.g. an invalid
97 XErrorHandler olderrorhandler = XSetErrorHandler (TempErrorHandler);
99 XGetWindowProperty (LXVST_XDisplay, // The display
100 window, // The Window
101 atom, // The property
102 0, // Offset into the data
103 1, // Number of 32Bit chunks of data
104 false, // false = don't delete the property
105 AnyPropertyType, // Required property type mask
106 &userType, // Actual type returned
107 &userSize, // Actual format returned
108 &userCount, // Actual number of items stored in the returned data
109 &bytes, // Number of bytes remaining if a partial read
110 &data); // The actual data read
112 if (LXVST_xerror == false && userCount == 1) {
113 result = *(int*)data;
116 XSetErrorHandler (olderrorhandler);
118 /*Hopefully this will return zero if the property is not set*/
127 /********************************************************************/
128 /* This is untested - have no 64Bit plugins which use this */
129 /* system of passing an eventProc address */
130 /********************************************************************/
132 long getXWindowProperty (Window window, Atom atom)
137 unsigned long userCount;
140 LXVST_xerror = false;
142 /*Use our own Xerror handler while we're in here - in an
143 * attempt to stop the brain dead default Xerror behaviour of
144 * qutting the entire application because of e.g. an invalid
148 XErrorHandler olderrorhandler = XSetErrorHandler (TempErrorHandler);
150 XGetWindowProperty (LXVST_XDisplay,
163 if (LXVST_xerror == false && userCount == 1) {
164 result = *(long*)data;
167 XSetErrorHandler (olderrorhandler);
169 /*Hopefully this will return zero if the property is not set*/
176 /*The event handler - called from within the main GUI thread to
177 dispatch events to any VST UIs which have callbacks stuck to them*/
180 dispatch_x_events (XEvent* event, VSTState* vstfx)
182 /*Handle some of the Events we might be interested in*/
186 /*Configure event - when the window is resized or first drawn*/
188 case ConfigureNotify:
190 Window window = event->xconfigure.event;
192 int width = event->xconfigure.width;
193 int height = event->xconfigure.height;
195 /* If we get a config notify on the parent window XID then we need to see
196 * if the size has been changed - some plugins re-size their UI window e.g.
197 * when opening a preset manager.
199 * if the size has changed, we flag this so that in lxvst_pluginui.cc
200 * we can make the change to the GTK parent window in ardour, from its UI thread */
202 if (window == (Window) (vstfx->linux_window)) {
204 printf ("dispatch_x_events: ConfigureNotify cfg: (%d %d) plugin: (%d %d)\n",
206 vstfx->width, vstfx->height
209 if (width != vstfx->width || height != vstfx->height) {
210 vstfx->width = width;
211 vstfx->height = height;
212 ARDOUR::VSTPlugin* plug = (ARDOUR::VSTPlugin *)(vstfx->plugin->ptr1);
213 plug->VSTSizeWindow (); /* EMIT SIGNAL */
216 /* QUIRK : Loomer plugins not only resize the UI but throw it into some random
217 * position at the same time. We need to re-position the window at the origin of
218 * the parent window*/
220 if (vstfx->linux_plugin_ui_window) {
221 XMoveWindow (LXVST_XDisplay, vstfx->linux_plugin_ui_window, 0, 0);
228 /*Reparent Notify - when the plugin UI is reparented into
229 our Host Window we will get an event here... probably... */
233 Window ParentWindow = event->xreparent.parent;
235 /*If the ParentWindow matches the window for the vstfx instance then
236 the Child window must be the XID of the pluginUI window created by the
237 plugin, so we need to see if it has a callback stuck to it, and if so
238 set that up in the vstfx */
240 /***********************************************************/
241 /* 64Bit --- This mechanism is not 64Bit compatible at the */
243 /***********************************************************/
245 if (ParentWindow == (Window) (vstfx->linux_window)) {
247 Window PluginUIWindowID = event->xreparent.window;
249 vstfx->linux_plugin_ui_window = PluginUIWindowID;
251 int result = getXWindowProperty (PluginUIWindowID, XInternAtom (LXVST_XDisplay, "_XEventProc", false));
254 vstfx->eventProc = NULL;
256 vstfx->eventProc = (void (*) (void* event))result;
260 long result = getXWindowProperty (PluginUIWindowID, XInternAtom (LXVST_XDisplay, "_XEventProc", false));
263 vstfx->eventProc = NULL;
265 vstfx->eventProc = (void (*) (void* event))result;
274 Window window = event->xany.window;
275 Atom message_type = event->xclient.message_type;
277 /*The only client message we are interested in is to signal
278 that the plugin parent window is now valid and can be passed
279 to effEditOpen when the editor is launched*/
281 if (window == (Window) (vstfx->linux_window)) {
282 char* message = XGetAtomName (LXVST_XDisplay, message_type);
284 if (strcmp (message,"LaunchEditor") == 0) {
285 if (event->xclient.data.l[0] == 0x0FEEDBAC) {
286 vstfx_launch_editor (vstfx);
299 /* Some VSTs built with toolkits e.g. JUCE will manager their own UI
300 autonomously in the plugin, running the UI in its own thread, so once
301 we have created a parent window for the plugin, its UI takes care of
304 /*Other types register a callback as an Xwindow property on the plugin
305 UI window after they create it. If that is the case, we need to call it
306 here, passing the XEvent into it*/
308 if (vstfx->eventProc == NULL) {
312 vstfx->eventProc ((void*)event);
315 /** This is the main gui event loop for the plugin, we also need to pass
316 any Xevents to all the UI callbacks plugins 'may' have registered on their
317 windows, that is if they don't manage their own UIs **/
320 gui_event_loop (void* ptr)
323 int LXVST_sched_timer_interval = 40; //ms, 25fps
325 uint64_t clock1, clock2;
327 clock1 = g_get_monotonic_time();
328 /*The 'Forever' loop - runs the plugin UIs etc - based on the FST gui event loop*/
332 /* handle window creation requests, destroy requests,
333 and run idle callbacks */
335 /*Look at the XEvent queue - if there are any XEvents we need to handle them,
336 including passing them to all the plugin (eventProcs) we are currently managing*/
338 bool may_sleep = true;
340 if (LXVST_XDisplay) {
341 /*See if there are any events in the queue*/
343 int num_events = XPending (LXVST_XDisplay);
345 if (num_events > 0) {
346 // keep dispatching events as fast as possible
350 /*process them if there are any*/
353 XNextEvent (LXVST_XDisplay, &event);
355 /*Call dispatch events, with the event, for each plugin in the linked list*/
357 for (vstfx = vstfx_first; vstfx; vstfx = vstfx->next) {
358 pthread_mutex_lock (&vstfx->lock);
360 dispatch_x_events (&event, vstfx);
362 pthread_mutex_unlock (&vstfx->lock);
369 /*We don't want to use all the CPU.. */
373 /*See if its time for us to do a scheduled event pass on all the plugins*/
375 clock2 = g_get_monotonic_time();
376 const int64_t elapsed_time_ms = (clock2 - clock1) / 1000;
378 if ((LXVST_sched_timer_interval != 0) && elapsed_time_ms >= LXVST_sched_timer_interval) {
379 //printf ("elapsed %d ms ^= %.2f Hz\n", elapsed_time_ms, 1000.0/ (double)elapsed_time_ms); // DEBUG
380 pthread_mutex_lock (&plugin_mutex);
383 /*Parse through the linked list of plugins*/
385 for (vstfx = vstfx_first; vstfx; vstfx = vstfx->next)
387 pthread_mutex_lock (&vstfx->lock);
389 /*Window scheduled for destruction*/
391 if (vstfx->destroy) {
392 if (vstfx->linux_window) {
393 vstfx->plugin->dispatcher (vstfx->plugin, effEditClose, 0, 0, NULL, 0.0);
395 XDestroyWindow (LXVST_XDisplay, vstfx->linux_window);
396 /* FIXME - probably safe to assume we never have an XID of 0 but not explicitly true */
397 vstfx->linux_window = 0;
398 vstfx->destroy = FALSE;
401 vstfx_event_loop_remove_plugin (vstfx);
402 vstfx->been_activated = FALSE;
403 pthread_cond_signal (&vstfx->window_status_change);
404 pthread_mutex_unlock (&vstfx->lock);
409 /*Window does not yet exist - scheduled for creation*/
411 /* FIXME - probably safe to assume 0 is not a valid XID but not explicitly true */
412 if (vstfx->linux_window == 0) {
413 if (vstfx_create_editor (vstfx)) {
414 vstfx_error ("** ERROR ** VSTFX : Cannot create editor for plugin %s", vstfx->handle->name);
415 vstfx_event_loop_remove_plugin (vstfx);
416 pthread_cond_signal (&vstfx->window_status_change);
417 pthread_mutex_unlock (&vstfx->lock);
420 /* condition/unlock: it was signalled & unlocked in fst_create_editor() */
424 vststate_maybe_set_program (vstfx);
425 vstfx->want_program = -1;
426 vstfx->want_chunk = 0;
428 /*scheduled call to dispatcher*/
430 if (vstfx->dispatcher_wantcall) {
431 vstfx->dispatcher_retval = vstfx->plugin->dispatcher (
433 vstfx->dispatcher_opcode,
434 vstfx->dispatcher_index,
435 vstfx->dispatcher_val,
436 vstfx->dispatcher_ptr,
437 vstfx->dispatcher_opt
440 vstfx->dispatcher_wantcall = 0;
441 pthread_cond_signal (&vstfx->plugin_dispatcher_called);
444 /*Call the editor Idle function in the plugin*/
446 vstfx->plugin->dispatcher (vstfx->plugin, effEditIdle, 0, 0, NULL, 0);
448 if (vstfx->wantIdle) {
449 vstfx->plugin->dispatcher (vstfx->plugin, 53, 0, 0, NULL, 0);
452 pthread_mutex_unlock (&vstfx->lock);
454 pthread_mutex_unlock (&plugin_mutex);
456 clock1 = g_get_monotonic_time();
459 if (!gui_quit && may_sleep && elapsed_time_ms + 1 < LXVST_sched_timer_interval) {
460 Glib::usleep (1000 * (LXVST_sched_timer_interval - elapsed_time_ms - 1));
464 if (LXVST_XDisplay) {
465 XCloseDisplay (LXVST_XDisplay);
469 /* some plugin UIs (looking at you, u-he^abique), do set thread-keys
470 * and free, but not unset them.
472 * This leads to a double-free in __nptl_deallocate_tsd
473 * nptl/pthread_create.c:175 __pthread_keys[idx].destr (data);
474 * when the event-loop thread is joined.
476 * This workaround is dedicated to all the plugin-UI-devs
477 * who think their UI owns the complete process memory-space.
479 * NB. ardour itself does not use thread-keys for the
480 * VST event-loop thread, and anyway, this thread is joined
481 * only when ardour exit()s. If this would result in a leak,
484 if (!getenv ("ARDOUR_RUNNING_UNDER_VALGRIND")) {
485 for (pthread_key_t i = 0; i < PTHREAD_KEYS_MAX; ++i) {
486 if (pthread_getspecific (i)) {
487 pthread_setspecific (i, NULL);
495 /*The VSTFX Init function - this needs to be called before the VSTFX engine
496 can be accessed, it gets the UI thread running, opens a connection to X etc
497 normally started in globals.cc*/
499 int vstfx_init (void* ptr)
501 assert (gui_quit == 0);
502 pthread_mutex_init (&plugin_mutex, NULL);
504 int thread_create_result;
506 pthread_attr_t thread_attributes;
508 /*Init the attribs to defaults*/
510 pthread_attr_init (&thread_attributes);
512 /*Make sure the thread is joinable - this should be the default anyway -
513 so we can join to it on vstfx_exit*/
515 pthread_attr_setdetachstate (&thread_attributes, PTHREAD_CREATE_JOINABLE);
518 /*This is where we need to open a connection to X, and start the GUI thread*/
520 /*Open our connection to X - all linuxVST plugin UIs handled by the LXVST engine
521 will talk to X down this connection - X cannot handle multi-threaded access via
524 if (LXVST_XDisplay == NULL) {
525 LXVST_XDisplay = XOpenDisplay (NULL); //We might be able to make this open a specific screen etc
528 /*Drop out and report the error if we fail to connect to X */
530 if (LXVST_XDisplay == NULL) {
531 vstfx_error ("** ERROR ** VSTFX: Failed opening connection to X");
536 /*We have a connection to X - so start the gui event loop*/
538 /*Create the thread - use default attrs for now, don't think we need anything special*/
540 thread_create_result = pthread_create (&LXVST_gui_event_thread, &thread_attributes, gui_event_loop, NULL);
542 if (thread_create_result != 0)
544 /*There was a problem starting the GUI event thread*/
546 vstfx_error ("** ERROR ** VSTFX: Failed starting GUI event thread");
548 XCloseDisplay (LXVST_XDisplay);
558 /*The vstfx Quit function*/
567 /*We need to pthread_join the gui_thread here so
568 we know when it has stopped*/
570 pthread_join(LXVST_gui_event_thread, NULL);
571 pthread_mutex_destroy (&plugin_mutex);
574 /*Adds a new plugin (VSTFX) instance to the linked list*/
576 int vstfx_run_editor (VSTState* vstfx)
578 pthread_mutex_lock (&plugin_mutex);
580 /* Add the new VSTFX instance to the linked list */
582 if (vstfx_first == NULL) {
585 VSTState* p = vstfx_first;
592 /* Mark the new end of the list */
597 pthread_mutex_unlock (&plugin_mutex);
599 /* wait for the plugin editor window to be created (or not) */
601 pthread_mutex_lock (&vstfx->lock);
603 if (!vstfx->linux_window) {
604 pthread_cond_wait (&vstfx->window_status_change, &vstfx->lock);
607 pthread_mutex_unlock (&vstfx->lock);
609 if (!vstfx->linux_window) {
617 /*Creates an editor for the plugin - normally called from within the gui event loop
618 after run_editor has added the plugin (editor) to the linked list*/
620 int vstfx_create_editor (VSTState* vstfx)
622 Window parent_window;
627 if (!LXVST_XDisplay) {
628 vstfx_error ("** ERROR ** VSTFX: No X11 Display available for plugin UI");
632 /* Note: vstfx->lock is held while this function is called */
634 if (!(vstfx->plugin->flags & effFlagsHasEditor))
636 vstfx_error ("** ERROR ** VSTFX: Plugin \"%s\" has no editor", vstfx->handle->name);
641 /*Create an XWindow for the plugin to inhabit*/
643 parent_window = XCreateSimpleWindow (
645 DefaultRootWindow(LXVST_XDisplay),
655 /*Select the events we are interested in receiving - we need Substructure notify so that
656 if the plugin resizes its window - e.g. Loomer Manifold then we get a message*/
658 XSelectInput(LXVST_XDisplay,
660 SubstructureNotifyMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | ExposureMask);
662 vstfx->linux_window = parent_window;
664 vstfx->xid = parent_window; //vstfx->xid will be referenced to connect to GTK UI in ardour later
666 /*Because the plugin may be operating on a different Display* to us, and therefore
667 the two event queues can be asynchronous, although we have created the window on
668 our display, we can't guarantee it exists in the server yet, which will
669 cause BadWindow crashes if the plugin tries to use it.
671 It would be nice to use CreateNotify events here, but they don't get
672 through on all window managers, so instead we pass a client message
673 into out queue, after the XCreateWindow. When this message pops out
674 in our event handler, it will trigger the second stage of plugin
675 Editor instantiation, and by then the Window should be valid...*/
677 XClientMessageEvent event;
679 /*Create an atom to identify our message (only if it doesn't already exist)*/
681 Atom WindowActiveAtom = XInternAtom(LXVST_XDisplay, "LaunchEditor", false);
683 event.type = ClientMessage;
684 event.send_event = true;
685 event.window = parent_window;
686 event.message_type = WindowActiveAtom;
688 event.format = 32; //Data format
689 event.data.l[0] = 0x0FEEDBAC; //Something we can recognize later
691 /*Push the event into the queue on our Display*/
693 XSendEvent(LXVST_XDisplay, parent_window, FALSE, NoEventMask, (XEvent*)&event);
699 vstfx_launch_editor (VSTState* vstfx)
701 /*This is the second stage of launching the editor (see vstfx_create editor)
702 we get called here in response to receiving the ClientMessage on our Window,
703 therefore it's about as safe (as can be) to assume that the Window we created
704 is now valid in the XServer and can be passed to the plugin in effEditOpen
705 without generating BadWindow errors when the plugin reparents itself into our
708 if(vstfx->been_activated)
711 Window parent_window;
712 struct ERect* er = NULL;
717 parent_window = vstfx->linux_window;
719 /*Open the editor - Bah! we have to pass the int windowID as a void pointer - yuck
720 it gets cast back to an int as the parent window XID in the plugin - and we have to pass the
721 Display* as a long */
723 /**************************************************************/
724 /* 64Bit --- parent window is an int passed as a void* so */
725 /* that should be ok for 64Bit machines */
727 /* Display is passed in as a long - ok on arch's where sizeof */
730 /* Most linux VST plugins open a connection to X on their own */
731 /* Display anyway so it may not matter */
733 /* linuxDSP VSTs don't use the host Display* at all */
734 /**************************************************************/
736 vstfx->plugin->dispatcher (vstfx->plugin, effEditOpen, 0, (long)LXVST_XDisplay, (void*)(parent_window), 0);
738 /*QUIRK - some plugins need a slight delay after opening the editor before you can
739 ask the window size or they might return zero - specifically discoDSP */
741 Glib::usleep(100000);
743 /*Now we can find out how big the parent window should be (and try) to resize it*/
745 vstfx->plugin->dispatcher (vstfx->plugin, effEditGetRect, 0, 0, &er, 0);
748 // Don't crash is plugin does not implement effEditGetRect
749 // it'll result in 1x1 px window but that's not our problem :)
750 x_size = er->right - er->left;
751 y_size = er->bottom - er->top;
754 vstfx->width = x_size;
755 vstfx->height = y_size;
757 XResizeWindow (LXVST_XDisplay, parent_window, x_size, y_size);
759 XFlush (LXVST_XDisplay);
761 /*Not sure if we need to map the window or if the plugin will do it for us
762 it should be ok because XReparentWindow generates a Map event*/
764 /*mark the editor as activated - mainly so that vstfx_get_XID
765 will know it is valid*/
767 vstfx->been_activated = TRUE;
769 pthread_cond_signal (&vstfx->window_status_change);
773 /** Destroy the editor window */
775 vstfx_destroy_editor (VSTState* vstfx)
777 pthread_mutex_lock (&vstfx->lock);
778 if (vstfx->linux_window) {
779 vstfx->destroy = TRUE;
780 pthread_cond_wait (&vstfx->window_status_change, &vstfx->lock);
782 pthread_mutex_unlock (&vstfx->lock);
785 /** Remove a vstfx instance from the linked list parsed by the
789 vstfx_event_loop_remove_plugin (VSTState* vstfx)
791 /* This only ever gets called from within our GUI thread
792 so we don't need to lock here - if we did there would be
799 for (p = vstfx_first, prev = NULL; p; prev = p, p = p->next) {
802 prev->next = p->next;
808 // if this function is called, there must be
809 // at least one plugin in the linked list
810 assert (vstfx_first);
812 if (vstfx_first == vstfx) {
813 vstfx_first = vstfx_first->next;