void close_external_ui_windows();
#endif
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
-extern int gui_init (int* argc, char** argv[]);
+extern int windows_vst_gui_init (int* argc, char** argv[]);
/* this is called from the entry point of a wine-compiled
executable that is linked against gtk2_ardour built
gtk_set_locale ();
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
/* this does some magic that is needed to make GTK and Wine's own
X11 client interact properly.
*/
- gui_init (&argc, &argv);
+ windows_vst_gui_init (&argc, &argv);
#endif
(void) bindtextdomain (PACKAGE, localedir);
#endif
return 0;
}
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
} // end of extern C block
#endif
<< _(" -N, --new session-name Create a new session from the command line\n")
<< _(" -O, --no-hw-optimizations Disable h/w specific optimizations\n")
<< _(" -S, --sync Draw the gui synchronously \n")
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
<< _(" -V, --novst Do not use VST support\n")
#endif
<< _(" -E, --save <file> Load the specified session, save it to <file> and then quit\n")
break;
case 'V':
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
use_vst = false;
-#endif /* VST_SUPPORT */
+#endif /* WINDOWS_VST_SUPPORT */
break;
case 'c':
case LV2:
compstr = X_("LV2");
break;
- case VST:
+ case Windows_VST:
compstr = X_("VST");
break;
case LXVST:
}
void
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
PluginSelector::vst_refiller (const std::string& filterstr)
#else
PluginSelector::vst_refiller (const std::string&)
#endif
{
-#ifdef VST_SUPPORT
- refiller (manager.vst_plugin_info(), filterstr, "VST");
+#ifdef WINDOWS_VST_SUPPORT
+ refiller (manager.windows_vst_plugin_info(), filterstr, "VST");
#endif
}
PluginInfoList all_plugs;
all_plugs.insert (all_plugs.end(), manager.ladspa_plugin_info().begin(), manager.ladspa_plugin_info().end());
-#ifdef VST_SUPPORT
- all_plugs.insert (all_plugs.end(), manager.vst_plugin_info().begin(), manager.vst_plugin_info().end());
+#ifdef WINDOWS_VST_SUPPORT
+ all_plugs.insert (all_plugs.end(), manager.windows_vst_plugin_info().begin(), manager.windows_vst_plugin_info().end());
#endif
#ifdef LXVST_SUPPORT
all_plugs.insert (all_plugs.end(), manager.lxvst_plugin_info().begin(), manager.lxvst_plugin_info().end());
#include "ardour/plugin.h"
#include "ardour/plugin_insert.h"
#include "ardour/ladspa_plugin.h"
-#ifdef VST_SUPPORT
-#include "ardour/vst_plugin.h"
-#include "vst_pluginui.h"
+#ifdef WINDOWS_VST_SUPPORT
+#include "ardour/windows_vst_plugin.h"
+#include "windows_vst_plugin_ui.h"
#endif
#ifdef LXVST_SUPPORT
#include "ardour/lxvst_plugin.h"
<< " editor: " << editor << std::endl;
if (editor && insert->plugin()->has_editor()) {
switch (insert->type()) {
- case ARDOUR::VST:
- have_gui = create_vst_editor (insert);
+ case ARDOUR::Windows_VST:
+ have_gui = create_windows_vst_editor (insert);
break;
case ARDOUR::LXVST:
break;
default:
-#ifndef VST_SUPPORT
+#ifndef WINDOWS_VST_SUPPORT
error << _("unknown type of editor-supplying plugin (note: no VST support in this version of ardour)")
<< endmsg;
#else
}
bool
-#ifdef VST_SUPPORT
-PluginUIWindow::create_vst_editor(boost::shared_ptr<PluginInsert> insert)
+#ifdef WINDOWS_VST_SUPPORT
+PluginUIWindow::create_
windows_vst_editor(boost::shared_ptr<PluginInsert> insert)
#else
-PluginUIWindow::create_vst_editor(boost::shared_ptr<PluginInsert>)
+PluginUIWindow::create_
windows_vst_editor(boost::shared_ptr<PluginInsert>)
#endif
{
-#ifndef VST_SUPPORT
+#ifndef WINDOWS_VST_SUPPORT
return false;
#else
- boost::shared_ptr<VSTPlugin> vp;
+ boost::shared_ptr<WindowsVSTPlugin> vp;
- if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (insert->plugin())) == 0) {
+ if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (insert->plugin())) == 0) {
error << _("unknown type of editor-supplying plugin (note: no VST support in this version of ardour)")
<< endmsg;
throw failed_constructor ();
} else {
- VSTPluginUI* vpu = new VSTPluginUI (insert, vp);
+ WindowsVSTPluginUI* vpu = new WindowsVSTPluginUI (insert, vp);
_pluginui = vpu;
_pluginui->KeyboardFocused.connect (sigc::mem_fun (*this, &PluginUIWindow::keyboard_focused));
namespace ARDOUR {
class PluginInsert;
class Plugin;
- class VSTPlugin;
+ class WindowsVSTPlugin;
class LXVSTPlugin;
class IOProcessor;
class AUPlugin;
void app_activated (bool);
void plugin_going_away ();
- bool create_vst_editor (boost::shared_ptr<ARDOUR::PluginInsert>);
+ bool create_
windows_vst_editor (boost::shared_ptr<ARDOUR::PluginInsert>);
bool create_lxvst_editor(boost::shared_ptr<ARDOUR::PluginInsert>);
bool create_audiounit_editor (boost::shared_ptr<ARDOUR::PluginInsert>);
bool create_lv2_editor (boost::shared_ptr<ARDOUR::PluginInsert>);
+++ /dev/null
-/*
- Copyright (C) 2004 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#include <fst.h>
-#include <gtk/gtk.h>
-#include <gtk/gtksocket.h>
-#include "ardour/plugin_insert.h"
-#include "ardour/vst_plugin.h"
-
-#include "vst_pluginui.h"
-
-#include <gdk/gdkx.h>
-
-using namespace Gtk;
-using namespace ARDOUR;
-using namespace PBD;
-
-VSTPluginUI::VSTPluginUI (boost::shared_ptr<PluginInsert> pi, boost::shared_ptr<VSTPlugin> vp)
- : PlugUIBase (pi),
- vst (vp)
-{
- fst_run_editor (vst->fst());
-
- preset_box.set_spacing (6);
- preset_box.set_border_width (6);
- preset_box.pack_end (focus_button, false, false);
- preset_box.pack_end (bypass_button, false, false, 10);
- preset_box.pack_end (delete_button, false, false);
- preset_box.pack_end (save_button, false, false);
- preset_box.pack_end (add_button, false, false);
- preset_box.pack_end (_preset_box, false, false);
-
- bypass_button.set_active (!insert->active());
-
- pack_start (preset_box, false, false);
- pack_start (socket, true, true);
- pack_start (plugin_analysis_expander, true, true);
-}
-
-VSTPluginUI::~VSTPluginUI ()
-{
- // plugin destructor destroys the custom GUI, via Windows fun-and-games,
- // and then our PluginUIWindow does the rest
-}
-
-void
-VSTPluginUI::preset_selected ()
-{
- socket.grab_focus ();
- PlugUIBase::preset_selected ();
-}
-
-int
-VSTPluginUI::get_preferred_height ()
-{
- return vst->fst()->height;
-}
-
-int
-VSTPluginUI::get_preferred_width ()
-{
- return vst->fst()->width;
-}
-
-int
-VSTPluginUI::package (Gtk::Window& win)
-{
- /* forward configure events to plugin window */
-
- win.signal_configure_event().connect (sigc::bind (sigc::mem_fun (*this, &VSTPluginUI::configure_handler), &socket), false);
-
- /*
- this assumes that the window's owner understands the XEmbed protocol.
- */
-
- socket.add_id (fst_get_XID (vst->fst()));
-
- fst_move_window_into_view (vst->fst());
-
- return 0;
-}
-
-bool
-VSTPluginUI::configure_handler (GdkEventConfigure* ev, Gtk::Socket *socket)
-{
- XEvent event;
- gint x, y;
- GdkWindow* w;
-
- if (socket == 0 || ((w = socket->gobj()->plug_window) == 0)) {
- return false;
- }
-
- event.xconfigure.type = ConfigureNotify;
- event.xconfigure.event = GDK_WINDOW_XWINDOW (w);
- event.xconfigure.window = GDK_WINDOW_XWINDOW (w);
-
- /* The ICCCM says that synthetic events should have root relative
- * coordinates. We still aren't really ICCCM compliant, since
- * we don't send events when the real toplevel is moved.
- */
- gdk_error_trap_push ();
- gdk_window_get_origin (w, &x, &y);
- gdk_error_trap_pop ();
-
- event.xconfigure.x = x;
- event.xconfigure.y = y;
- event.xconfigure.width = GTK_WIDGET(socket->gobj())->allocation.width;
- event.xconfigure.height = GTK_WIDGET(socket->gobj())->allocation.height;
-
- event.xconfigure.border_width = 0;
- event.xconfigure.above = None;
- event.xconfigure.override_redirect = False;
-
- gdk_error_trap_push ();
- XSendEvent (GDK_WINDOW_XDISPLAY (w), GDK_WINDOW_XWINDOW (w), False, StructureNotifyMask, &event);
- gdk_error_trap_pop ();
-
- return false;
-}
-
-void
-VSTPluginUI::forward_key_event (GdkEventKey* ev)
-{
- if (ev->type == GDK_KEY_PRESS) {
-
- FST* fst = vst->fst ();
- pthread_mutex_lock (&fst->lock);
-
- if (fst->n_pending_keys == (sizeof (fst->pending_keys) * sizeof (FSTKey))) {
- /* buffer full */
- return;
- }
-
- int special_windows_key = 0;
- int character_windows_key = 0;
-
- switch (ev->keyval) {
- case GDK_Left:
- special_windows_key = 0x25;
- break;
- case GDK_Right:
- special_windows_key = 0x27;
- break;
- case GDK_Up:
- special_windows_key = 0x26;
- break;
- case GDK_Down:
- special_windows_key = 0x28;
- break;
- case GDK_Return:
- case GDK_KP_Enter:
- special_windows_key = 0xd;
- break;
- default:
- character_windows_key = ev->keyval;
- break;
- }
-
- fst->pending_keys[fst->n_pending_keys].special = special_windows_key;
- fst->pending_keys[fst->n_pending_keys].character = character_windows_key;
- fst->n_pending_keys++;
-
- pthread_mutex_unlock (&fst->lock);
- }
-}
-
-typedef int (*error_handler_t)( Display *, XErrorEvent *);
-static Display *the_gtk_display;
-static error_handler_t wine_error_handler;
-static error_handler_t gtk_error_handler;
-
-static int
-fst_xerror_handler( Display *disp, XErrorEvent *ev )
-{
- if (disp == the_gtk_display) {
- printf ("relaying error to gtk\n");
- return gtk_error_handler (disp, ev);
- } else {
- printf( "relaying error to wine\n" );
- return wine_error_handler (disp, ev);
- }
-}
-
-void
-gui_init (int *argc, char **argv[])
-{
- wine_error_handler = XSetErrorHandler (NULL);
- gtk_init (argc, argv);
- the_gtk_display = gdk_x11_display_get_xdisplay (gdk_display_get_default());
- gtk_error_handler = XSetErrorHandler( fst_xerror_handler );
-}
-
+++ /dev/null
-/*
- Copyright (C) 2000-2006 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#include "plugin_ui.h"
-
-class VSTPluginUI : public PlugUIBase, public Gtk::VBox
-{
- public:
- VSTPluginUI (boost::shared_ptr<ARDOUR::PluginInsert>, boost::shared_ptr<ARDOUR::VSTPlugin>);
- ~VSTPluginUI ();
-
- gint get_preferred_height ();
- gint get_preferred_width ();
- bool start_updating(GdkEventAny*) {return false;}
- bool stop_updating(GdkEventAny*) {return false;}
-
- int package (Gtk::Window&);
-
- void forward_key_event (GdkEventKey *);
- bool non_gtk_gui () const { return true; }
-
- private:
- boost::shared_ptr<ARDOUR::VSTPlugin> vst;
- Gtk::Socket socket;
- Gtk::HBox preset_box;
- Gtk::VBox vpacker;
-
- bool configure_handler (GdkEventConfigure*, Gtk::Socket*);
- void save_plugin_setting ();
- void preset_selected ();
-};
--- /dev/null
+/*
+ Copyright (C) 2004 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <fst.h>
+#include <gtk/gtk.h>
+#include <gtk/gtksocket.h>
+#include "ardour/plugin_insert.h"
+#include "ardour/windows_vst_plugin.h"
+
+#include "windows_vst_plugin_ui.h"
+
+#include <gdk/gdkx.h>
+
+using namespace Gtk;
+using namespace ARDOUR;
+using namespace PBD;
+
+WindowsVSTPluginUI::WindowsVSTPluginUI (boost::shared_ptr<PluginInsert> pi, boost::shared_ptr<WindowsVSTPlugin> vp)
+ : PlugUIBase (pi),
+ vst (vp)
+{
+ fst_run_editor (vst->fst());
+
+ preset_box.set_spacing (6);
+ preset_box.set_border_width (6);
+ preset_box.pack_end (focus_button, false, false);
+ preset_box.pack_end (bypass_button, false, false, 10);
+ preset_box.pack_end (delete_button, false, false);
+ preset_box.pack_end (save_button, false, false);
+ preset_box.pack_end (add_button, false, false);
+ preset_box.pack_end (_preset_box, false, false);
+
+ bypass_button.set_active (!insert->active());
+
+ pack_start (preset_box, false, false);
+ pack_start (socket, true, true);
+ pack_start (plugin_analysis_expander, true, true);
+}
+
+WindowsVSTPluginUI::~WindowsVSTPluginUI ()
+{
+ // plugin destructor destroys the custom GUI, via Windows fun-and-games,
+ // and then our PluginUIWindow does the rest
+}
+
+void
+WindowsVSTPluginUI::preset_selected ()
+{
+ socket.grab_focus ();
+ PlugUIBase::preset_selected ();
+}
+
+int
+WindowsVSTPluginUI::get_preferred_height ()
+{
+ return vst->fst()->height;
+}
+
+int
+WindowsVSTPluginUI::get_preferred_width ()
+{
+ return vst->fst()->width;
+}
+
+int
+WindowsVSTPluginUI::package (Gtk::Window& win)
+{
+ /* forward configure events to plugin window */
+
+ win.signal_configure_event().connect (sigc::bind (sigc::mem_fun (*this, &WindowsVSTPluginUI::configure_handler), &socket), false);
+
+ /*
+ this assumes that the window's owner understands the XEmbed protocol.
+ */
+
+ socket.add_id (fst_get_XID (vst->fst()));
+
+ fst_move_window_into_view (vst->fst());
+
+ return 0;
+}
+
+bool
+WindowsVSTPluginUI::configure_handler (GdkEventConfigure* ev, Gtk::Socket *socket)
+{
+ XEvent event;
+ gint x, y;
+ GdkWindow* w;
+
+ if (socket == 0 || ((w = socket->gobj()->plug_window) == 0)) {
+ return false;
+ }
+
+ event.xconfigure.type = ConfigureNotify;
+ event.xconfigure.event = GDK_WINDOW_XWINDOW (w);
+ event.xconfigure.window = GDK_WINDOW_XWINDOW (w);
+
+ /* The ICCCM says that synthetic events should have root relative
+ * coordinates. We still aren't really ICCCM compliant, since
+ * we don't send events when the real toplevel is moved.
+ */
+ gdk_error_trap_push ();
+ gdk_window_get_origin (w, &x, &y);
+ gdk_error_trap_pop ();
+
+ event.xconfigure.x = x;
+ event.xconfigure.y = y;
+ event.xconfigure.width = GTK_WIDGET(socket->gobj())->allocation.width;
+ event.xconfigure.height = GTK_WIDGET(socket->gobj())->allocation.height;
+
+ event.xconfigure.border_width = 0;
+ event.xconfigure.above = None;
+ event.xconfigure.override_redirect = False;
+
+ gdk_error_trap_push ();
+ XSendEvent (GDK_WINDOW_XDISPLAY (w), GDK_WINDOW_XWINDOW (w), False, StructureNotifyMask, &event);
+ gdk_error_trap_pop ();
+
+ return false;
+}
+
+void
+WindowsVSTPluginUI::forward_key_event (GdkEventKey* ev)
+{
+ if (ev->type == GDK_KEY_PRESS) {
+
+ FST* fst = vst->fst ();
+ pthread_mutex_lock (&fst->lock);
+
+ if (fst->n_pending_keys == (sizeof (fst->pending_keys) * sizeof (FSTKey))) {
+ /* buffer full */
+ return;
+ }
+
+ int special_windows_key = 0;
+ int character_windows_key = 0;
+
+ switch (ev->keyval) {
+ case GDK_Left:
+ special_windows_key = 0x25;
+ break;
+ case GDK_Right:
+ special_windows_key = 0x27;
+ break;
+ case GDK_Up:
+ special_windows_key = 0x26;
+ break;
+ case GDK_Down:
+ special_windows_key = 0x28;
+ break;
+ case GDK_Return:
+ case GDK_KP_Enter:
+ special_windows_key = 0xd;
+ break;
+ default:
+ character_windows_key = ev->keyval;
+ break;
+ }
+
+ fst->pending_keys[fst->n_pending_keys].special = special_windows_key;
+ fst->pending_keys[fst->n_pending_keys].character = character_windows_key;
+ fst->n_pending_keys++;
+
+ pthread_mutex_unlock (&fst->lock);
+ }
+}
+
+typedef int (*error_handler_t)( Display *, XErrorEvent *);
+static Display *the_gtk_display;
+static error_handler_t wine_error_handler;
+static error_handler_t gtk_error_handler;
+
+static int
+fst_xerror_handler( Display *disp, XErrorEvent *ev )
+{
+ if (disp == the_gtk_display) {
+ printf ("relaying error to gtk\n");
+ return gtk_error_handler (disp, ev);
+ } else {
+ printf( "relaying error to wine\n" );
+ return wine_error_handler (disp, ev);
+ }
+}
+
+void
+windows_vst_gui_init (int *argc, char **argv[])
+{
+ wine_error_handler = XSetErrorHandler (NULL);
+ gtk_init (argc, argv);
+ the_gtk_display = gdk_x11_display_get_xdisplay (gdk_display_get_default());
+ gtk_error_handler = XSetErrorHandler( fst_xerror_handler );
+}
+
--- /dev/null
+/*
+ Copyright (C) 2000-2006 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include "plugin_ui.h"
+
+class WindowsVSTPluginUI : public PlugUIBase, public Gtk::VBox
+{
+ public:
+ WindowsVSTPluginUI (boost::shared_ptr<ARDOUR::PluginInsert>, boost::shared_ptr<ARDOUR::WindowsVSTPlugin>);
+ ~WindowsVSTPluginUI ();
+
+ gint get_preferred_height ();
+ gint get_preferred_width ();
+ bool start_updating(GdkEventAny*) {return false;}
+ bool stop_updating(GdkEventAny*) {return false;}
+
+ int package (Gtk::Window&);
+
+ void forward_key_event (GdkEventKey *);
+ bool non_gtk_gui () const { return true; }
+
+ private:
+ boost::shared_ptr<ARDOUR::WindowsVSTPlugin> vst;
+ Gtk::Socket socket;
+ Gtk::HBox preset_box;
+ Gtk::VBox vpacker;
+
+ bool configure_handler (GdkEventConfigure*, Gtk::Socket*);
+ void save_plugin_setting ();
+ void preset_selected ();
+};
def build(bld):
# GTK front-end; if we're using VST we build this as a shared library,
# otherwise it's a normal executabale
- if bld.is_defined('VST_SUPPORT'):
+ if bld.is_defined('WINDOWS_VST_SUPPORT'):
obj = bld(features = 'cxx c cxxshlib')
else:
obj = bld(features = 'cxx c cxxprogram')
obj.source = gtk2_ardour_sources
obj.name = 'gtk2_ardour'
obj.linkflags = []
- if bld.is_defined('VST_SUPPORT'):
+ if bld.is_defined('WINDOWS_VST_SUPPORT'):
obj.target = 'gtk2_ardour'
obj.includes += ['../libs/fst']
else:
obj.source += [ 'sfdb_freesound_mootcher.cc' ]
obj.defines += [ 'FREESOUND' ]
- if bld.is_defined('VST_SUPPORT'):
- obj.source += [ 'vst_pluginui.cc' ]
- obj.defines += [ 'VST_SUPPORT' ]
+ if bld.is_defined('WINDOWS_VST_SUPPORT'):
+ obj.source += [ 'windows_vst_plugin_ui.cc' ]
+ obj.defines += [ 'WINDOWS_VST_SUPPORT' ]
obj.uselib += ' X11 '
if bld.is_defined('LXVST_SUPPORT'):
obj.source += [ 'cocoacarbon.mm', 'au_pluginui.mm' ]
obj.use += ' libappleutility '
- if bld.is_defined('VST_SUPPORT'):
+ if bld.is_defined('WINDOWS_VST_SUPPORT'):
# If we require VST support we build a stub main() and the FST library
# here using winegcc, and link it to the GTK front-end library
obj = bld(features = 'cxx c cxxprogram wine')
'''
obj.includes = '../libs/fst'
obj.target = 'ardour-3.0-vst'
- obj.linkflags += ['-mwindows', '-Wl,--export-dynamic', '-lpthread']
+ obj.linkflags = ['-mwindows', '-Wl,--export-dynamic', '-lpthread']
obj.defines = ['_POSIX_SOURCE', 'USE_WS_PREFIX']
obj.uselib = 'ALSA'
obj.use = ['libpbd','libmidipp','libtaglib','libardour',
~PluginManager ();
- ARDOUR::PluginInfoList &vst_plugin_info ();
+ ARDOUR::PluginInfoList &windows_vst_plugin_info ();
ARDOUR::PluginInfoList &lxvst_plugin_info ();
ARDOUR::PluginInfoList &ladspa_plugin_info ();
ARDOUR::PluginInfoList &lv2_plugin_info ();
void refresh ();
int add_ladspa_directory (std::string dirpath);
- int add_vst_directory (std::string dirpath);
+ int add_windows_vst_directory (std::string dirpath);
int add_lxvst_directory (std::string dirpath);
enum PluginStatusType {
PluginStatusList statuses;
ARDOUR::PluginInfoList _empty_plugin_info;
- ARDOUR::PluginInfoList* _vst_plugin_info;
+ ARDOUR::PluginInfoList* _windows_vst_plugin_info;
ARDOUR::PluginInfoList* _lxvst_plugin_info;
ARDOUR::PluginInfoList* _ladspa_plugin_info;
ARDOUR::PluginInfoList* _lv2_plugin_info;
std::map<uint32_t, std::string> rdf_type;
std::string ladspa_path;
- std::string vst_path;
+ std::string windows_vst_path;
std::string lxvst_path;
void ladspa_refresh ();
- void vst_refresh ();
+ void windows_vst_refresh ();
void lxvst_refresh ();
void add_lrdf_data (const std::string &path);
void add_ladspa_presets ();
- void add_vst_presets ();
+ void add_windows_vst_presets ();
void add_lxvst_presets ();
void add_presets (std::string domain);
void lv2_refresh ();
- int vst_discover_from_path (std::string path);
- int vst_discover (std::string path);
+ int windows_vst_discover_from_path (std::string path);
+ int windows_vst_discover (std::string path);
int lxvst_discover_from_path (std::string path);
int lxvst_discover (std::string path);
CONFIG_VARIABLE (bool, hiding_groups_deactivates_groups, "hiding-groups-deactivates-groups", true)
CONFIG_VARIABLE (bool, verify_remove_last_capture, "verify-remove-last-capture", true)
CONFIG_VARIABLE (bool, no_new_session_dialog, "no-new-session-dialog", false)
-CONFIG_VARIABLE (bool, use_vst, "use-vst", true)
+CONFIG_VARIABLE (bool, use_windows_vst, "use-windows-vst", true)
CONFIG_VARIABLE (bool, use_lxvst, "use-lxvst", true)
CONFIG_VARIABLE (bool, save_history, "save-history", true)
CONFIG_VARIABLE (int32_t, saved_history_depth, "save-history-depth", 20)
class Speakers;
class TempoMap;
class Track;
-class VSTPlugin;
+class WindowsVSTPlugin;
extern void setup_enum_writer ();
boost::shared_ptr<Route> _master_out;
boost::shared_ptr<Route> _monitor_out;
- /* VST support */
+ /* Windows VST support */
- long _vst_callback (VSTPlugin*,
- long opcode,
- long index,
- long value,
- void* ptr,
- float opt);
+ long _windows_vst_callback (
+ WindowsVSTPlugin*,
+ long opcode,
+ long index,
+ long value,
+ void* ptr,
+ float opt
+ );
/* number of hardware ports we're using,
based on max (requested,available)
AudioUnit,
LADSPA,
LV2,
- VST,
+ Windows_VST,
LXVST,
};
+++ /dev/null
-/*
- Copyright (C) 2004 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#ifndef __ardour_vst_plugin_h__
-#define __ardour_vst_plugin_h__
-
-#include <list>
-#include <map>
-#include <set>
-#include <vector>
-#include <string>
-#include <dlfcn.h>
-
-#include "pbd/stateful.h"
-#include "ardour/plugin.h"
-
-struct _FSTHandle;
-struct _FST;
-typedef struct _FSTHandle FSTHandle;
-typedef struct _FST FST;
-class AEffect;
-
-namespace ARDOUR {
-class AudioEngine;
-class Session;
-
-class VSTPlugin : public ARDOUR::Plugin
-{
- public:
- VSTPlugin (ARDOUR::AudioEngine&, ARDOUR::Session&, FSTHandle* handle);
- VSTPlugin (const VSTPlugin &);
- ~VSTPlugin ();
-
- /* Plugin interface */
-
- std::string unique_id() const;
- const char * label() const;
- const char * name() const;
- const char * maker() const;
- uint32_t parameter_count() const;
- float default_value (uint32_t port);
- framecnt_t signal_latency() const;
- void set_parameter (uint32_t port, float val);
- float get_parameter (uint32_t port) const;
- int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
- std::set<Evoral::Parameter> automatable() const;
- uint32_t nth_parameter (uint32_t port, bool& ok) const;
- void activate ();
- void deactivate ();
- int set_block_size (pframes_t);
-
- int connect_and_run (BufferSet&,
- ChanMapping in, ChanMapping out,
- pframes_t nframes, framecnt_t offset);
-
- std::string describe_parameter (Evoral::Parameter);
- std::string state_node_name() const { return "vst"; }
- void print_parameter (uint32_t, char*, uint32_t len) const;
-
- bool parameter_is_audio(uint32_t i) const { return false; }
- bool parameter_is_control(uint32_t i) const { return true; }
- bool parameter_is_input(uint32_t i) const { return true; }
- bool parameter_is_output(uint32_t i) const { return false; }
-
- bool load_preset (PresetRecord);
- int first_user_preset_index () const;
-
- bool has_editor () const;
-
- int set_state (XMLNode const &, int);
-
- AEffect * plugin () const { return _plugin; }
- FST * fst () const { return _fst; }
-
-private:
-
- void do_remove_preset (std::string name);
- std::string do_save_preset (std::string name);
- gchar* get_chunk (bool) const;
- int set_chunk (gchar const *, bool);
- XMLTree * presets_tree () const;
- std::string presets_file () const;
- void find_presets ();
- bool load_user_preset (PresetRecord);
- bool load_plugin_preset (PresetRecord);
- void add_state (XMLNode *) const;
-
- FSTHandle* handle;
- FST* _fst;
- AEffect* _plugin;
- bool been_resumed;
-};
-
-class VSTPluginInfo : public PluginInfo
-{
- public:
- VSTPluginInfo ();
- ~VSTPluginInfo () {}
-
- PluginPtr load (Session& session);
-};
-
-typedef boost::shared_ptr<VSTPluginInfo> VSTPluginInfoPtr;
-
-} // namespace ARDOUR
-
-#endif /* __ardour_vst_plugin_h__ */
--- /dev/null
+/*
+ Copyright (C) 2004 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_windows_vst_plugin_h__
+#define __ardour_windows_vst_plugin_h__
+
+#include <list>
+#include <map>
+#include <set>
+#include <vector>
+#include <string>
+#include <dlfcn.h>
+
+#include "pbd/stateful.h"
+#include "ardour/plugin.h"
+
+struct _FSTHandle;
+struct _FST;
+typedef struct _FSTHandle FSTHandle;
+typedef struct _FST FST;
+class AEffect;
+
+namespace ARDOUR {
+class AudioEngine;
+class Session;
+
+class WindowsVSTPlugin : public ARDOUR::Plugin
+{
+ public:
+ WindowsVSTPlugin (ARDOUR::AudioEngine&, ARDOUR::Session&, FSTHandle* handle);
+ WindowsVSTPlugin (const WindowsVSTPlugin &);
+ ~WindowsVSTPlugin ();
+
+ /* Plugin interface */
+
+ std::string unique_id() const;
+ const char * label() const;
+ const char * name() const;
+ const char * maker() const;
+ uint32_t parameter_count() const;
+ float default_value (uint32_t port);
+ framecnt_t signal_latency() const;
+ void set_parameter (uint32_t port, float val);
+ float get_parameter (uint32_t port) const;
+ int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const;
+ std::set<Evoral::Parameter> automatable() const;
+ uint32_t nth_parameter (uint32_t port, bool& ok) const;
+ void activate ();
+ void deactivate ();
+ int set_block_size (pframes_t);
+
+ int connect_and_run (BufferSet&,
+ ChanMapping in, ChanMapping out,
+ pframes_t nframes, framecnt_t offset);
+
+ std::string describe_parameter (Evoral::Parameter);
+ std::string state_node_name() const { return "windows-vst"; }
+ void print_parameter (uint32_t, char*, uint32_t len) const;
+
+ bool parameter_is_audio(uint32_t i) const { return false; }
+ bool parameter_is_control(uint32_t i) const { return true; }
+ bool parameter_is_input(uint32_t i) const { return true; }
+ bool parameter_is_output(uint32_t i) const { return false; }
+
+ bool load_preset (PresetRecord);
+ int first_user_preset_index () const;
+
+ bool has_editor () const;
+
+ int set_state (XMLNode const &, int);
+
+ AEffect * plugin () const { return _plugin; }
+ FST * fst () const { return _fst; }
+
+private:
+
+ void do_remove_preset (std::string name);
+ std::string do_save_preset (std::string name);
+ gchar* get_chunk (bool) const;
+ int set_chunk (gchar const *, bool);
+ XMLTree * presets_tree () const;
+ std::string presets_file () const;
+ void find_presets ();
+ bool load_user_preset (PresetRecord);
+ bool load_plugin_preset (PresetRecord);
+ void add_state (XMLNode *) const;
+
+ FSTHandle* handle;
+ FST* _fst;
+ AEffect* _plugin;
+ bool been_resumed;
+};
+
+class WindowsVSTPluginInfo : public PluginInfo
+{
+ public:
+ WindowsVSTPluginInfo ();
+ ~WindowsVSTPluginInfo () {}
+
+ PluginPtr load (Session& session);
+};
+
+typedef boost::shared_ptr<WindowsVSTPluginInfo> WindowsVSTPluginInfoPtr;
+
+} // namespace ARDOUR
+
+#endif /* __ardour_vst_plugin_h__ */
#include "ardour/lv2_plugin.h"
#include "ardour/lv2_event_buffer.h"
#endif
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
#include "vestige/aeffectx.h"
#endif
_count.reset();
_available.reset();
-#if defined VST_SUPPORT || defined LXVST_SUPPORT
+#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
for (VSTBuffers::iterator i = _vst_buffers.begin(); i != _vst_buffers.end(); ++i) {
delete *i;
}
}
#endif
-#if defined VST_SUPPORT || defined LXVST_SUPPORT
+#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
// As above but for VST
if (type == DataType::MIDI) {
while (_vst_buffers.size() < _buffers[type].size()) {
#endif /* LV2_SUPPORT */
-#if defined VST_SUPPORT || defined LXVST_SUPPORT
+#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT
VstEvents*
BufferSet::get_vst_midi (size_t b)
_events->numEvents++;
}
-#endif /* VST_SUPPORT */
+#endif /* WINDOWS_VST_SUPPORT */
/** Copy buffers of one type from `in' to this BufferSet */
void
REGISTER_ENUM (AudioUnit);
REGISTER_ENUM (LADSPA);
- REGISTER_ENUM (VST);
+ REGISTER_ENUM (Windows_VST);
+ REGISTER_ENUM (LXVST);
REGISTER (_PluginType);
REGISTER_ENUM (MTC);
#include <fcntl.h>
#include <errno.h>
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
#include <fst.h>
#endif
}
int
-ARDOUR::init (bool use_vst, bool try_optimization)
+ARDOUR::init (bool use_windows_vst, bool try_optimization)
{
if (!Glib::thread_supported()) {
Glib::thread_init();
return -1;
}
- Config->set_use_vst (use_vst);
+ Config->set_use_windows_vst (use_windows_vst);
#ifdef LXVST_SUPPORT
Config->set_use_lxvst(true);
#endif
Profile = new RuntimeProfile;
-#ifdef VST_SUPPORT
- if (Config->get_use_vst() && fst_init (0)) {
+#ifdef WINDOWS_VST_SUPPORT
+ if (Config->get_use_windows_vst() && fst_init (0)) {
return -1;
}
#endif
delete Library;
lrdf_cleanup ();
delete &ControlProtocolManager::instance();
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
fst_exit ();
#endif
break;
#endif
-#ifdef VST_SUPPORT
- case ARDOUR::VST:
- plugs = mgr.vst_plugin_info();
+#ifdef WINDOWS_VST_SUPPORT
+ case ARDOUR::Windows_VST:
+ plugs = mgr.windows_vst_plugin_info();
break;
#endif
}
}
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
/* hmm, we didn't find it. could be because in older versions of Ardour.
we used to store the name of a VST plugin, not its unique ID. so try
again.
#include "ardour/lv2_plugin.h"
#endif
-#ifdef VST_SUPPORT
-#include "ardour/vst_plugin.h"
+#ifdef WINDOWS_VST_SUPPORT
+#include "ardour/windows_vst_plugin.h"
#endif
#ifdef LXVST_SUPPORT
#ifdef LV2_SUPPORT
boost::shared_ptr<LV2Plugin> lv2p;
#endif
-#ifdef VST_SUPPORT
- boost::shared_ptr<VSTPlugin> vp;
+#ifdef WINDOWS_VST_SUPPORT
+ boost::shared_ptr<WindowsVSTPlugin> vp;
#endif
#ifdef LXVST_SUPPORT
boost::shared_ptr<LXVSTPlugin> lxvp;
} else if ((lv2p = boost::dynamic_pointer_cast<LV2Plugin> (other)) != 0) {
return boost::shared_ptr<Plugin> (new LV2Plugin (*lv2p));
#endif
-#ifdef VST_SUPPORT
- } else if ((vp = boost::dynamic_pointer_cast<VSTPlugin> (other)) != 0) {
- return boost::shared_ptr<Plugin> (new VSTPlugin (*vp));
+#ifdef WINDOWS_VST_SUPPORT
+ } else if ((vp = boost::dynamic_pointer_cast<WindowsVSTPlugin> (other)) != 0) {
+ return boost::shared_ptr<Plugin> (new WindowsVSTPlugin (*vp));
#endif
#ifdef LXVST_SUPPORT
} else if ((lxvp = boost::dynamic_pointer_cast<LXVSTPlugin> (other)) != 0) {
type = ARDOUR::LADSPA;
} else if (prop->value() == X_("lv2")) {
type = ARDOUR::LV2;
- } else if (prop->value() == X_("vst")) {
- type = ARDOUR::VST;
+ } else if (prop->value() == X_("windows-vst")) {
+ type = ARDOUR::Windows_VST;
} else if (prop->value() == X_("lxvst")) {
type = ARDOUR::LXVST;
} else if (prop->value() == X_("audiounit")) {
prop = node.property ("unique-id");
if (prop == 0) {
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
/* older sessions contain VST plugins with only an "id" field.
*/
- if (type == ARDOUR::VST) {
+ if (type == ARDOUR::Windows_VST) {
prop = node.property ("id");
}
#endif
#include <cstdlib>
#include <fstream>
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
#include <fst.h>
#include "pbd/basename.h"
#include <cstring>
-#endif // VST_SUPPORT
+#endif // WINDOWS_VST_SUPPORT
#ifdef LXVST_SUPPORT
#include <ardour/vstfx.h>
#include "ardour/lv2_plugin.h"
#endif
-#ifdef VST_SUPPORT
-#include "ardour/vst_plugin.h"
+#ifdef WINDOWS_VST_SUPPORT
+#include "ardour/windows_vst_plugin.h"
#endif
#ifdef LXVST_SUPPORT
}
PluginManager::PluginManager ()
- : _vst_plugin_info(0)
+ : _windows_vst_plugin_info(0)
, _lxvst_plugin_info(0)
, _ladspa_plugin_info(0)
, _lv2_plugin_info(0)
add_lrdf_data(lrdf_path);
add_ladspa_presets();
-#ifdef VST_SUPPORT
- if (Config->get_use_vst()) {
- add_vst_presets();
+#ifdef WINDOWS_VST_SUPPORT
+ if (Config->get_use_windows_vst ()) {
+ add_windows_vst_presets ();
}
-#endif /* VST_SUPPORT */
+#endif /* WINDOWS_VST_SUPPORT */
#ifdef LXVST_SUPPORT
if (Config->get_use_lxvst()) {
}
if ((s = getenv ("VST_PATH"))) {
- vst_path = s;
+ windows_vst_path = s;
} else if ((s = getenv ("VST_PLUGINS"))) {
- vst_path = s;
+ windows_vst_path = s;
}
if ((s = getenv ("LXVST_PATH"))) {
#ifdef LV2_SUPPORT
lv2_refresh ();
#endif
-#ifdef VST_SUPPORT
- if (Config->get_use_vst()) {
- vst_refresh ();
+#ifdef WINDOWS_VST_SUPPORT
+ if (Config->get_use_windows_vst()) {
+ windows_vst_refresh ();
}
-#endif // VST_SUPPORT
+#endif // WINDOWS_VST_SUPPORT
#ifdef LXVST_SUPPORT
if(Config->get_use_lxvst()) {
}
void
-PluginManager::add_vst_presets()
+PluginManager::add_windows_vst_presets()
{
- add_presets ("vst");
+ add_presets ("windows-vst");
}
void
#endif
-#ifdef VST_SUPPORT
+#ifdef WINDOWS_VST_SUPPORT
void
-PluginManager::vst_refresh ()
+PluginManager::windows_vst_refresh ()
{
- if (_vst_plugin_info)
- _vst_plugin_info->clear ();
- else
- _vst_plugin_info = new ARDOUR::PluginInfoList();
+ if (_windows_vst_plugin_info) {
+ _windows_vst_plugin_info->clear ();
+ } else {
+ _windows_vst_plugin_info = new ARDOUR::PluginInfoList();
+ }
- if (vst_path.length() == 0) {
- vst_path = "/usr/local/lib/vst:/usr/lib/vst";
+ if (windows_vst_path.length() == 0) {
+ windows_vst_path = "/usr/local/lib/vst:/usr/lib/vst";
}
- vst_discover_from_path (vst_path);
+ windows_vst_discover_from_path (windows_vst_path);
}
int
-PluginManager::add_vst_directory (string path)
+PluginManager::add_windows_vst_directory (string path)
{
- if (vst_discover_from_path (path) == 0) {
- vst_path += ':';
- vst_path += path;
+ if (windows_vst_discover_from_path (path) == 0) {
+ windows_vst_path += ':';
+ windows_vst_path += path;
return 0;
}
return -1;
}
-static bool vst_filter (const string& str, void *arg)
+static bool windows_vst_filter (const string& str, void *arg)
{
/* Not a dotfile, has a prefix before a period, suffix is "dll" */
}
int
-PluginManager::vst_discover_from_path (string path)
+PluginManager::windows_vst_discover_from_path (string path)
{
PathScanner scanner;
vector<string *> *plugin_objects;
vector<string *>::iterator x;
int ret = 0;
- DEBUG_TRACE (DEBUG::PluginManager, string_compose ("detecting VST plugins along %1\n", path));
+ DEBUG_TRACE (DEBUG::PluginManager, string_compose ("detecting Windows VST plugins along %1\n", path));
- plugin_objects = scanner (vst_path, vst_filter, 0, false, true);
+ plugin_objects = scanner (windows_vst_path, windows_vst_filter, 0, false, true);
if (plugin_objects) {
for (x = plugin_objects->begin(); x != plugin_objects->end (); ++x) {
- vst_discover (**x);
+ windows_vst_discover (**x);
}
}
}
int
-PluginManager::vst_discover (string path)
+PluginManager::windows_vst_discover (string path)
{
FSTInfo* finfo;
char buf[32];
if ((finfo = fst_get_info (const_cast<char *> (path.c_str()))) == 0) {
- warning << "Cannot get VST information from " << path << endmsg;
+ warning << "Cannot get Windows VST information from " << path << endmsg;
return -1;
}
<< endl;
}
- PluginInfoPtr info(new VSTPluginInfo);
+ PluginInfoPtr info (new WindowsVSTPluginInfo);
/* what a joke freeware VST is */
info->n_inputs.set_audio (finfo->numInputs);
info->n_outputs.set_audio (finfo->numOutputs);
info->n_inputs.set_midi (finfo->wantMidi ? 1 : 0);
- info->type = ARDOUR::VST;
+ info->type = ARDOUR::Windows_VST;
- _vst_plugin_info->push_back (info);
+ _windows_vst_plugin_info->push_back (info);
fst_free_info (finfo);
return 0;
}
-#endif // VST_SUPPORT
+#endif // WINDOWS_VST_SUPPORT
#ifdef LXVST_SUPPORT
case LV2:
ofs << "LV2";
break;
- case VST:
- ofs << "VST";
+ case Windows_VST:
+ ofs << "Windows-VST";
break;
case LXVST:
ofs << "LXVST";
type = AudioUnit;
} else if (stype == "LV2") {
type = LV2;
- } else if (stype == "VST") {
- type = VST;
+ } else if (stype == "Windows-VST") {
+ type = Windows_VST;
} else if (stype == "LXVST") {
type = LXVST;
} else {
}
ARDOUR::PluginInfoList&
-PluginManager::vst_plugin_info ()
+PluginManager::windows_vst_plugin_info ()
{
-#ifdef VST_SUPPORT
- if (!_vst_plugin_info)
- vst_refresh();
- return *_vst_plugin_info;
+#ifdef WINDOWS_VST_SUPPORT
+ if (!_windows_vst_plugin_info) {
+ windows_vst_refresh ();
+ }
+ return *_windows_vst_plugin_info;
#else
return _empty_plugin_info;
#endif
#include "ardour/port_insert.h"
#include "ardour/plugin_insert.h"
-#ifdef VST_SUPPORT
-#include "ardour/vst_plugin.h"
+#ifdef WINDOWS_VST_SUPPORT
+#include "ardour/windows_vst_plugin.h"
#endif
#ifdef AUDIOUNIT_SUPPORT
#include "ardour/session.h"
#include "ardour/tempo.h"
-#include "ardour/vst_plugin.h"
+#include "ardour/windows_vst_plugin.h"
#include "i18n.h"
float opt)
{
static VstTimeInfo _timeInfo;
- VSTPlugin* plug;
+ WindowsVSTPlugin* plug;
Session* session;
if (debug_callbacks < 0) {
}
if (effect && effect->user) {
- plug = (VSTPlugin*) (effect->user);
+ plug = (WindowsVSTPlugin*) (effect->user);
session = &plug->session();
SHOW_CALLBACK ("am callback 0x%x, opcode = %ld, plugin = \"%s\" ", (int) pthread_self(), opcode, plug->name());
} else {
+++ /dev/null
-/*
- Copyright (C) 2004 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#include <algorithm>
-#include <vector>
-#include <string>
-#include <cctype>
-
-#include <cstdlib>
-#include <cstdio> // so libraptor doesn't complain
-#include <cmath>
-#include <dirent.h>
-#include <cstring> // for memmove
-#include <sys/stat.h>
-#include <cerrno>
-
-#include <glibmm/miscutils.h>
-
-#include <lrdf.h>
-#include <fst.h>
-
-#include "pbd/compose.h"
-#include "pbd/error.h"
-#include "pbd/pathscanner.h"
-#include "pbd/xml++.h"
-
-#include <fst.h>
-
-#include "ardour/session.h"
-#include "ardour/audioengine.h"
-#include "ardour/filesystem_paths.h"
-#include "ardour/vst_plugin.h"
-#include "ardour/buffer_set.h"
-#include "ardour/audio_buffer.h"
-#include "ardour/midi_buffer.h"
-
-#include "pbd/stl_delete.h"
-
-#include "i18n.h"
-#include <locale.h>
-
-using namespace std;
-using namespace ARDOUR;
-using namespace PBD;
-using std::min;
-using std::max;
-
-VSTPlugin::VSTPlugin (AudioEngine& e, Session& session, FSTHandle* h)
- : Plugin (e, session)
-{
- handle = h;
-
- if ((_fst = fst_instantiate (handle, Session::vst_callback, this)) == 0) {
- throw failed_constructor();
- }
-
- _plugin = _fst->plugin;
- _plugin->user = this;
-
- /* set rate and blocksize */
-
- _plugin->dispatcher (_plugin, effSetSampleRate, 0, 0, NULL,
- (float) session.frame_rate());
- _plugin->dispatcher (_plugin, effSetBlockSize, 0,
- session.get_block_size(), NULL, 0.0f);
-
- /* set program to zero */
-
- _plugin->dispatcher (_plugin, effSetProgram, 0, 0, NULL, 0.0f);
-
- // Plugin::setup_controls ();
-}
-
-VSTPlugin::VSTPlugin (const VSTPlugin &other)
- : Plugin (other)
-{
- handle = other.handle;
-
- if ((_fst = fst_instantiate (handle, Session::vst_callback, this)) == 0) {
- throw failed_constructor();
- }
- _plugin = _fst->plugin;
-
- // Plugin::setup_controls ();
-}
-
-VSTPlugin::~VSTPlugin ()
-{
- deactivate ();
- fst_close (_fst);
-}
-
-int
-VSTPlugin::set_block_size (pframes_t nframes)
-{
- deactivate ();
- _plugin->dispatcher (_plugin, effSetBlockSize, 0, nframes, NULL, 0.0f);
- activate ();
- return 0;
-}
-
-float
-VSTPlugin::default_value (uint32_t port)
-{
- return 0;
-}
-
-void
-VSTPlugin::set_parameter (uint32_t which, float val)
-{
- _plugin->setParameter (_plugin, which, val);
-
- if (_fst->want_program == -1 && _fst->want_chunk == 0) {
- /* Heinous hack: Plugin::set_parameter below updates the `modified' status of the
- current preset, but if _fst->want_program is not -1 then there is a preset
- setup pending or in progress, which we don't want any `modified' updates
- to happen for. So we only do this if _fst->want_program is -1.
- */
- Plugin::set_parameter (which, val);
- }
-}
-
-float
-VSTPlugin::get_parameter (uint32_t which) const
-{
- return _plugin->getParameter (_plugin, which);
-
-}
-
-uint32_t
-VSTPlugin::nth_parameter (uint32_t n, bool& ok) const
-{
- ok = true;
- return n;
-}
-
-/** Get VST chunk as base64-encoded data.
- * @param single true for single program, false for all programs.
- * @return 0-terminated base64-encoded data; must be passed to g_free () by caller.
- */
-gchar *
-VSTPlugin::get_chunk (bool single) const
-{
- guchar* data;
- int32_t data_size = _plugin->dispatcher (_plugin, 23 /* effGetChunk */, single ? 1 : 0, 0, &data, 0);
- if (data_size == 0) {
- return 0;
- }
-
- return g_base64_encode (data, data_size);
-}
-
-/** Set VST chunk from base64-encoded data.
- * @param 0-terminated base64-encoded data.
- * @param single true for single program, false for all programs.
- * @return 0 on success, non-0 on failure
- */
-int
-VSTPlugin::set_chunk (gchar const * data, bool single)
-{
- gsize size = 0;
- guchar* raw_data = g_base64_decode (data, &size);
- int const r = _plugin->dispatcher (_plugin, 24 /* effSetChunk */, single ? 1 : 0, size, raw_data, 0);
- g_free (raw_data);
- return r;
-}
-
-void
-VSTPlugin::add_state (XMLNode* root) const
-{
- LocaleGuard lg (X_("POSIX"));
-
- if (_fst->current_program != -1) {
- char buf[32];
- snprintf (buf, sizeof (buf), "%d", _fst->current_program);
- root->add_property ("current-program", buf);
- }
-
- if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
-
- gchar* data = get_chunk (false);
- if (data == 0) {
- return;
- }
-
- /* store information */
-
- XMLNode* chunk_node = new XMLNode (X_("chunk"));
-
- chunk_node->add_content (data);
- g_free (data);
-
- root->add_child_nocopy (*chunk_node);
-
- } else {
-
- XMLNode* parameters = new XMLNode ("parameters");
-
- for (int32_t n = 0; n < _plugin->numParams; ++n) {
- char index[64];
- char val[32];
- snprintf (index, sizeof (index), "param_%d", n);
- snprintf (val, sizeof (val), "%.12g", _plugin->getParameter (_plugin, n));
- parameters->add_property (index, val);
- }
-
- root->add_child_nocopy (*parameters);
- }
-}
-
-int
-VSTPlugin::set_state (const XMLNode& node, int version)
-{
- LocaleGuard lg (X_("POSIX"));
-
- if (node.name() != state_node_name()) {
- error << _("Bad node sent to VSTPlugin::set_state") << endmsg;
- return 0;
- }
-
- const XMLProperty* prop;
-
- if ((prop = node.property ("current-program")) != 0) {
- _fst->want_program = atoi (prop->value().c_str());
- }
-
- XMLNode* child;
- int ret = -1;
-
- if ((child = find_named_node (node, X_("chunk"))) != 0) {
-
- XMLPropertyList::const_iterator i;
- XMLNodeList::const_iterator n;
- int ret = -1;
-
- for (n = child->children ().begin (); n != child->children ().end (); ++n) {
- if ((*n)->is_content ()) {
- /* XXX: this may be dubious for the same reasons that we delay
- execution of load_preset.
- */
- ret = set_chunk ((*n)->content().c_str(), false);
- }
- }
-
- } else if ((child = find_named_node (node, X_("parameters"))) != 0) {
-
- XMLPropertyList::const_iterator i;
-
- for (i = child->properties().begin(); i != child->properties().end(); ++i) {
- int32_t param;
- float val;
-
- sscanf ((*i)->name().c_str(), "param_%d", ¶m);
- sscanf ((*i)->value().c_str(), "%f", &val);
-
- _plugin->setParameter (_plugin, param, val);
- }
-
- /* program number is not knowable */
-
- _fst->current_program = -1;
-
- ret = 0;
-
- }
-
- Plugin::set_state (node, version);
- return ret;
-}
-
-int
-VSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
-{
- VstParameterProperties prop;
-
- desc.min_unbound = false;
- desc.max_unbound = false;
- prop.flags = 0;
-
- if (_plugin->dispatcher (_plugin, effGetParameterProperties, which, 0, &prop, 0)) {
-
-#ifdef VESTIGE_COMPLETE
-
- /* i have yet to find or hear of a VST plugin that uses this */
-
- if (prop.flags & kVstParameterUsesIntegerMinMax) {
- desc.lower = prop.minInteger;
- desc.upper = prop.maxInteger;
- } else {
- desc.lower = 0;
- desc.upper = 1.0;
- }
-
- if (prop.flags & kVstParameterUsesIntStep) {
-
- desc.step = prop.stepInteger;
- desc.smallstep = prop.stepInteger;
- desc.largestep = prop.stepInteger;
-
- } else if (prop.flags & kVstParameterUsesFloatStep) {
-
- desc.step = prop.stepFloat;
- desc.smallstep = prop.smallStepFloat;
- desc.largestep = prop.largeStepFloat;
-
- } else {
-
- float range = desc.upper - desc.lower;
-
- desc.step = range / 100.0f;
- desc.smallstep = desc.step / 2.0f;
- desc.largestep = desc.step * 10.0f;
- }
-
- desc.toggled = prop.flags & kVstParameterIsSwitch;
- desc.logarithmic = false;
- desc.sr_dependent = false;
- desc.label = prop.label;
-#endif
-
- } else {
-
- /* old style */
-
- char label[64];
- label[0] = '\0';
-
- _plugin->dispatcher (_plugin, effGetParamName, which, 0, label, 0);
-
- desc.label = label;
- desc.integer_step = false;
- desc.lower = 0.0f;
- desc.upper = 1.0f;
- desc.step = 0.01f;
- desc.smallstep = 0.005f;
- desc.largestep = 0.1f;
- desc.toggled = false;
- desc.logarithmic = false;
- desc.sr_dependent = false;
- }
-
- return 0;
-}
-
-bool
-VSTPlugin::load_preset (PresetRecord r)
-{
- bool s;
-
- if (r.user) {
- s = load_user_preset (r);
- } else {
- s = load_plugin_preset (r);
- }
-
- if (s) {
- Plugin::load_preset (r);
- }
-
- return s;
-}
-
-bool
-VSTPlugin::load_plugin_preset (PresetRecord r)
-{
- /* This is a plugin-provided preset.
- We can't dispatch directly here; too many plugins expects only one GUI thread.
- */
-
- /* Extract the index of this preset from the URI */
- int id;
- int index;
- int const p = sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
- assert (p == 2);
-
- _fst->want_program = index;
- return true;
-}
-
-bool
-VSTPlugin::load_user_preset (PresetRecord r)
-{
- /* This is a user preset; we load it, and this code also knows about the
- non-direct-dispatch thing.
- */
-
- boost::shared_ptr<XMLTree> t (presets_tree ());
- if (t == 0) {
- return false;
- }
-
- XMLNode* root = t->root ();
-
- for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
-
- XMLProperty* uri = (*i)->property (X_("uri"));
- XMLProperty* label = (*i)->property (X_("label"));
-
- assert (uri);
- assert (label);
-
- if (label->value() != r.label) {
- continue;
- }
-
- if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
-
- /* Load a user preset chunk from our XML file and send it via a circuitous route to the plugin */
-
- if (_fst->wanted_chunk) {
- g_free (_fst->wanted_chunk);
- }
-
- for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
- if ((*j)->is_content ()) {
- /* we can't dispatch directly here; too many plugins expect only one GUI thread */
- gsize size = 0;
- guchar* raw_data = g_base64_decode ((*j)->content().c_str(), &size);
- _fst->wanted_chunk = raw_data;
- _fst->wanted_chunk_size = size;
- _fst->want_chunk = 1;
- return true;
- }
- }
-
- return false;
-
- } else {
-
- for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
- if ((*j)->name() == X_("Parameter")) {
-
- XMLProperty* index = (*j)->property (X_("index"));
- XMLProperty* value = (*j)->property (X_("value"));
-
- assert (index);
- assert (value);
-
- set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
- }
- }
-
- return true;
- }
- }
-
- return false;
-}
-
-string
-VSTPlugin::do_save_preset (string name)
-{
- boost::shared_ptr<XMLTree> t (presets_tree ());
- if (t == 0) {
- return "";
- }
-
- XMLNode* p = 0;
- /* XXX: use of _presets.size() + 1 for the unique ID here is dubious at best */
- string const uri = string_compose (X_("VST:%1:%2"), unique_id (), _presets.size() + 1);
-
- if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
-
- p = new XMLNode (X_("ChunkPreset"));
- p->add_property (X_("uri"), uri);
- p->add_property (X_("label"), name);
- gchar* data = get_chunk (true);
- p->add_content (string (data));
- g_free (data);
-
- } else {
-
- p = new XMLNode (X_("Preset"));
- p->add_property (X_("uri"), uri);
- p->add_property (X_("label"), name);
-
- for (uint32_t i = 0; i < parameter_count(); ++i) {
- if (parameter_is_input (i)) {
- XMLNode* c = new XMLNode (X_("Parameter"));
- c->add_property (X_("index"), string_compose ("%1", i));
- c->add_property (X_("value"), string_compose ("%1", get_parameter (i)));
- p->add_child_nocopy (*c);
- }
- }
-
- }
-
- t->root()->add_child_nocopy (*p);
-
- sys::path f = ARDOUR::user_config_directory ();
- f /= "presets";
- f /= presets_file ();
-
- t->write (f.to_string ());
- return uri;
-}
-
-void
-VSTPlugin::do_remove_preset (string name)
-{
- boost::shared_ptr<XMLTree> t (presets_tree ());
- if (t == 0) {
- return;
- }
-
- t->root()->remove_nodes_and_delete (X_("label"), name);
-
- sys::path f = ARDOUR::user_config_directory ();
- f /= "presets";
- f /= presets_file ();
-
- t->write (f.to_string ());
-}
-
-string
-VSTPlugin::describe_parameter (Evoral::Parameter param)
-{
- char name[64];
- _plugin->dispatcher (_plugin, effGetParamName, param.id(), 0, name, 0);
- return name;
-}
-
-framecnt_t
-VSTPlugin::signal_latency () const
-{
- if (_user_latency) {
- return _user_latency;
- }
-
-#ifdef VESTIGE_HEADER
- return *((framecnt_t *) (((char *) &_plugin->flags) + 12)); /* initialDelay */
-#else
- return _plugin->initial_delay;
-#endif
-}
-
-set<Evoral::Parameter>
-VSTPlugin::automatable () const
-{
- set<Evoral::Parameter> ret;
-
- for (uint32_t i = 0; i < parameter_count(); ++i){
- ret.insert (ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
- }
-
- return ret;
-}
-
-int
-VSTPlugin::connect_and_run (BufferSet& bufs,
- ChanMapping in_map, ChanMapping out_map,
- pframes_t nframes, framecnt_t offset)
-{
- Plugin::connect_and_run (bufs, in_map, out_map, nframes, offset);
-
- float *ins[_plugin->numInputs];
- float *outs[_plugin->numOutputs];
- int32_t i;
-
- const uint32_t nbufs = bufs.count().n_audio();
-
- int in_index = 0;
- for (i = 0; i < (int32_t) _plugin->numInputs; ++i) {
- ins[i] = bufs.get_audio(min((uint32_t) in_index, nbufs - 1)).data() + offset;
- in_index++;
- }
-
- int out_index = 0;
- for (i = 0; i < (int32_t) _plugin->numOutputs; ++i) {
- outs[i] = bufs.get_audio(min((uint32_t) out_index, nbufs - 1)).data() + offset;
-
- /* unbelievably, several VST plugins still rely on Cubase
- behaviour and do not silence the buffer in processReplacing
- when they have no output.
- */
-
- // memset (outs[i], 0, sizeof (Sample) * nframes);
- out_index++;
- }
-
-
- if (bufs.count().n_midi() > 0) {
- VstEvents* v = bufs.get_vst_midi (0);
- _plugin->dispatcher (_plugin, effProcessEvents, 0, 0, v, 0);
- }
-
- /* we already know it can support processReplacing */
- _plugin->processReplacing (_plugin, ins, outs, nframes);
-
- return 0;
-}
-
-void
-VSTPlugin::deactivate ()
-{
- _plugin->dispatcher (_plugin, effMainsChanged, 0, 0, NULL, 0.0f);
-}
-
-void
-VSTPlugin::activate ()
-{
- _plugin->dispatcher (_plugin, effMainsChanged, 0, 1, NULL, 0.0f);
-}
-
-string
-VSTPlugin::unique_id() const
-{
- char buf[32];
-
-#ifdef VESTIGE_HEADER
- snprintf (buf, sizeof (buf), "%d", *((int32_t*) &_plugin->unused_id));
-#else
- snprintf (buf, sizeof (buf), "%d", _plugin->uniqueID);
-#endif
- return string (buf);
-}
-
-
-const char *
-VSTPlugin::name () const
-{
- return handle->name;
-}
-
-const char *
-VSTPlugin::maker () const
-{
- return _info->creator.c_str();
-}
-
-const char *
-VSTPlugin::label () const
-{
- return handle->name;
-}
-
-uint32_t
-VSTPlugin::parameter_count() const
-{
- return _plugin->numParams;
-}
-
-bool
-VSTPlugin::has_editor () const
-{
- return _plugin->flags & effFlagsHasEditor;
-}
-
-void
-VSTPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
-{
- char *first_nonws;
-
- _plugin->dispatcher (_plugin, 7 /* effGetParamDisplay */, param, 0, buf, 0);
-
- if (buf[0] == '\0') {
- return;
- }
-
- first_nonws = buf;
- while (*first_nonws && isspace (*first_nonws)) {
- first_nonws++;
- }
- if (*first_nonws == '\0') {
- return;
- }
-
- memmove (buf, first_nonws, strlen (buf) - (first_nonws - buf) + 1);
-}
-
-PluginPtr
-VSTPluginInfo::load (Session& session)
-{
- try {
- PluginPtr plugin;
-
- if (Config->get_use_vst()) {
- FSTHandle* handle;
-
- handle = fst_load(path.c_str());
-
- if ( (int)handle == -1) {
- error << string_compose(_("VST: cannot load module from \"%1\""), path) << endmsg;
- } else {
- plugin.reset (new VSTPlugin (session.engine(), session, handle));
- }
- } else {
- error << _("You asked ardour to not use any VST plugins") << endmsg;
- return PluginPtr ((Plugin*) 0);
- }
-
- plugin->set_info(PluginInfoPtr(new VSTPluginInfo(*this)));
- return plugin;
- }
-
- catch (failed_constructor &err) {
- return PluginPtr ((Plugin*) 0);
- }
-}
-
-void
-VSTPlugin::find_presets ()
-{
- /* Built-in presets */
-
- int const vst_version = _plugin->dispatcher (_plugin, effGetVstVersion, 0, 0, NULL, 0);
- for (int i = 0; i < _plugin->numPrograms; ++i) {
- PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "", false);
-
- if (vst_version >= 2) {
- char buf[256];
- if (_plugin->dispatcher (_plugin, 29, i, 0, buf, 0) == 1) {
- r.label = buf;
- } else {
- r.label = string_compose (_("Preset %1"), i);
- }
- } else {
- r.label = string_compose (_("Preset %1"), i);
- }
-
- _presets.insert (make_pair (r.uri, r));
- }
-
- /* User presets from our XML file */
-
- boost::shared_ptr<XMLTree> t (presets_tree ());
-
- if (t) {
- XMLNode* root = t->root ();
- for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
-
- XMLProperty* uri = (*i)->property (X_("uri"));
- XMLProperty* label = (*i)->property (X_("label"));
-
- assert (uri);
- assert (label);
-
- PresetRecord r (uri->value(), label->value(), true);
- _presets.insert (make_pair (r.uri, r));
- }
- }
-
-}
-
-/** @return XMLTree with our user presets; could be a new one if no existing
- * one was found, or 0 if one was present but badly-formatted.
- */
-XMLTree *
-VSTPlugin::presets_tree () const
-{
- XMLTree* t = new XMLTree;
-
- sys::path p = ARDOUR::user_config_directory ();
- p /= "presets";
-
- if (!is_directory (p)) {
- create_directory (p);
- }
-
- p /= presets_file ();
-
- if (!exists (p)) {
- t->set_root (new XMLNode (X_("VSTPresets")));
- return t;
- }
-
- t->set_filename (p.to_string ());
- if (!t->read ()) {
- delete t;
- return 0;
- }
-
- return t;
-}
-
-/** @return Index of the first user preset in our lists */
-int
-VSTPlugin::first_user_preset_index () const
-{
- return _plugin->numPrograms;
-}
-
-string
-VSTPlugin::presets_file () const
-{
- return string_compose ("vst-%1", unique_id ());
-}
-
-VSTPluginInfo::VSTPluginInfo()
-{
- type = ARDOUR::VST;
-}
-
--- /dev/null
+/*
+ Copyright (C) 2004 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <cctype>
+
+#include <cstdlib>
+#include <cstdio> // so libraptor doesn't complain
+#include <cmath>
+#include <dirent.h>
+#include <cstring> // for memmove
+#include <sys/stat.h>
+#include <cerrno>
+
+#include <glibmm/miscutils.h>
+
+#include <lrdf.h>
+#include <fst.h>
+
+#include "pbd/compose.h"
+#include "pbd/error.h"
+#include "pbd/pathscanner.h"
+#include "pbd/xml++.h"
+
+#include <fst.h>
+
+#include "ardour/session.h"
+#include "ardour/audioengine.h"
+#include "ardour/filesystem_paths.h"
+#include "ardour/windows_vst_plugin.h"
+#include "ardour/buffer_set.h"
+#include "ardour/audio_buffer.h"
+#include "ardour/midi_buffer.h"
+
+#include "pbd/stl_delete.h"
+
+#include "i18n.h"
+#include <locale.h>
+
+using namespace std;
+using namespace ARDOUR;
+using namespace PBD;
+using std::min;
+using std::max;
+
+WindowsVSTPlugin::WindowsVSTPlugin (AudioEngine& e, Session& session, FSTHandle* h)
+ : Plugin (e, session)
+{
+ handle = h;
+
+ if ((_fst = fst_instantiate (handle, Session::vst_callback, this)) == 0) {
+ throw failed_constructor();
+ }
+
+ _plugin = _fst->plugin;
+ _plugin->user = this;
+
+ /* set rate and blocksize */
+
+ _plugin->dispatcher (_plugin, effSetSampleRate, 0, 0, NULL,
+ (float) session.frame_rate());
+ _plugin->dispatcher (_plugin, effSetBlockSize, 0,
+ session.get_block_size(), NULL, 0.0f);
+
+ /* set program to zero */
+
+ _plugin->dispatcher (_plugin, effSetProgram, 0, 0, NULL, 0.0f);
+
+ // Plugin::setup_controls ();
+}
+
+WindowsVSTPlugin::WindowsVSTPlugin (const WindowsVSTPlugin &other)
+ : Plugin (other)
+{
+ handle = other.handle;
+
+ if ((_fst = fst_instantiate (handle, Session::vst_callback, this)) == 0) {
+ throw failed_constructor();
+ }
+ _plugin = _fst->plugin;
+
+ // Plugin::setup_controls ();
+}
+
+WindowsVSTPlugin::~WindowsVSTPlugin ()
+{
+ deactivate ();
+ fst_close (_fst);
+}
+
+int
+WindowsVSTPlugin::set_block_size (pframes_t nframes)
+{
+ deactivate ();
+ _plugin->dispatcher (_plugin, effSetBlockSize, 0, nframes, NULL, 0.0f);
+ activate ();
+ return 0;
+}
+
+float
+WindowsVSTPlugin::default_value (uint32_t port)
+{
+ return 0;
+}
+
+void
+WindowsVSTPlugin::set_parameter (uint32_t which, float val)
+{
+ _plugin->setParameter (_plugin, which, val);
+
+ if (_fst->want_program == -1 && _fst->want_chunk == 0) {
+ /* Heinous hack: Plugin::set_parameter below updates the `modified' status of the
+ current preset, but if _fst->want_program is not -1 then there is a preset
+ setup pending or in progress, which we don't want any `modified' updates
+ to happen for. So we only do this if _fst->want_program is -1.
+ */
+ Plugin::set_parameter (which, val);
+ }
+}
+
+float
+WindowsVSTPlugin::get_parameter (uint32_t which) const
+{
+ return _plugin->getParameter (_plugin, which);
+
+}
+
+uint32_t
+WindowsVSTPlugin::nth_parameter (uint32_t n, bool& ok) const
+{
+ ok = true;
+ return n;
+}
+
+/** Get VST chunk as base64-encoded data.
+ * @param single true for single program, false for all programs.
+ * @return 0-terminated base64-encoded data; must be passed to g_free () by caller.
+ */
+gchar *
+WindowsVSTPlugin::get_chunk (bool single) const
+{
+ guchar* data;
+ int32_t data_size = _plugin->dispatcher (_plugin, 23 /* effGetChunk */, single ? 1 : 0, 0, &data, 0);
+ if (data_size == 0) {
+ return 0;
+ }
+
+ return g_base64_encode (data, data_size);
+}
+
+/** Set VST chunk from base64-encoded data.
+ * @param 0-terminated base64-encoded data.
+ * @param single true for single program, false for all programs.
+ * @return 0 on success, non-0 on failure
+ */
+int
+WindowsVSTPlugin::set_chunk (gchar const * data, bool single)
+{
+ gsize size = 0;
+ guchar* raw_data = g_base64_decode (data, &size);
+ int const r = _plugin->dispatcher (_plugin, 24 /* effSetChunk */, single ? 1 : 0, size, raw_data, 0);
+ g_free (raw_data);
+ return r;
+}
+
+void
+WindowsVSTPlugin::add_state (XMLNode* root) const
+{
+ LocaleGuard lg (X_("POSIX"));
+
+ if (_fst->current_program != -1) {
+ char buf[32];
+ snprintf (buf, sizeof (buf), "%d", _fst->current_program);
+ root->add_property ("current-program", buf);
+ }
+
+ if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
+
+ gchar* data = get_chunk (false);
+ if (data == 0) {
+ return;
+ }
+
+ /* store information */
+
+ XMLNode* chunk_node = new XMLNode (X_("chunk"));
+
+ chunk_node->add_content (data);
+ g_free (data);
+
+ root->add_child_nocopy (*chunk_node);
+
+ } else {
+
+ XMLNode* parameters = new XMLNode ("parameters");
+
+ for (int32_t n = 0; n < _plugin->numParams; ++n) {
+ char index[64];
+ char val[32];
+ snprintf (index, sizeof (index), "param_%d", n);
+ snprintf (val, sizeof (val), "%.12g", _plugin->getParameter (_plugin, n));
+ parameters->add_property (index, val);
+ }
+
+ root->add_child_nocopy (*parameters);
+ }
+}
+
+int
+WindowsVSTPlugin::set_state (const XMLNode& node, int version)
+{
+ LocaleGuard lg (X_("POSIX"));
+
+ if (node.name() != state_node_name()) {
+ error << _("Bad node sent to WindowsVSTPlugin::set_state") << endmsg;
+ return 0;
+ }
+
+ const XMLProperty* prop;
+
+ if ((prop = node.property ("current-program")) != 0) {
+ _fst->want_program = atoi (prop->value().c_str());
+ }
+
+ XMLNode* child;
+ int ret = -1;
+
+ if ((child = find_named_node (node, X_("chunk"))) != 0) {
+
+ XMLPropertyList::const_iterator i;
+ XMLNodeList::const_iterator n;
+ int ret = -1;
+
+ for (n = child->children ().begin (); n != child->children ().end (); ++n) {
+ if ((*n)->is_content ()) {
+ /* XXX: this may be dubious for the same reasons that we delay
+ execution of load_preset.
+ */
+ ret = set_chunk ((*n)->content().c_str(), false);
+ }
+ }
+
+ } else if ((child = find_named_node (node, X_("parameters"))) != 0) {
+
+ XMLPropertyList::const_iterator i;
+
+ for (i = child->properties().begin(); i != child->properties().end(); ++i) {
+ int32_t param;
+ float val;
+
+ sscanf ((*i)->name().c_str(), "param_%d", ¶m);
+ sscanf ((*i)->value().c_str(), "%f", &val);
+
+ _plugin->setParameter (_plugin, param, val);
+ }
+
+ /* program number is not knowable */
+
+ _fst->current_program = -1;
+
+ ret = 0;
+
+ }
+
+ Plugin::set_state (node, version);
+ return ret;
+}
+
+int
+WindowsVSTPlugin::get_parameter_descriptor (uint32_t which, ParameterDescriptor& desc) const
+{
+ VstParameterProperties prop;
+
+ desc.min_unbound = false;
+ desc.max_unbound = false;
+ prop.flags = 0;
+
+ if (_plugin->dispatcher (_plugin, effGetParameterProperties, which, 0, &prop, 0)) {
+
+#ifdef VESTIGE_COMPLETE
+
+ /* i have yet to find or hear of a VST plugin that uses this */
+
+ if (prop.flags & kVstParameterUsesIntegerMinMax) {
+ desc.lower = prop.minInteger;
+ desc.upper = prop.maxInteger;
+ } else {
+ desc.lower = 0;
+ desc.upper = 1.0;
+ }
+
+ if (prop.flags & kVstParameterUsesIntStep) {
+
+ desc.step = prop.stepInteger;
+ desc.smallstep = prop.stepInteger;
+ desc.largestep = prop.stepInteger;
+
+ } else if (prop.flags & kVstParameterUsesFloatStep) {
+
+ desc.step = prop.stepFloat;
+ desc.smallstep = prop.smallStepFloat;
+ desc.largestep = prop.largeStepFloat;
+
+ } else {
+
+ float range = desc.upper - desc.lower;
+
+ desc.step = range / 100.0f;
+ desc.smallstep = desc.step / 2.0f;
+ desc.largestep = desc.step * 10.0f;
+ }
+
+ desc.toggled = prop.flags & kVstParameterIsSwitch;
+ desc.logarithmic = false;
+ desc.sr_dependent = false;
+ desc.label = prop.label;
+#endif
+
+ } else {
+
+ /* old style */
+
+ char label[64];
+ label[0] = '\0';
+
+ _plugin->dispatcher (_plugin, effGetParamName, which, 0, label, 0);
+
+ desc.label = label;
+ desc.integer_step = false;
+ desc.lower = 0.0f;
+ desc.upper = 1.0f;
+ desc.step = 0.01f;
+ desc.smallstep = 0.005f;
+ desc.largestep = 0.1f;
+ desc.toggled = false;
+ desc.logarithmic = false;
+ desc.sr_dependent = false;
+ }
+
+ return 0;
+}
+
+bool
+WindowsVSTPlugin::load_preset (PresetRecord r)
+{
+ bool s;
+
+ if (r.user) {
+ s = load_user_preset (r);
+ } else {
+ s = load_plugin_preset (r);
+ }
+
+ if (s) {
+ Plugin::load_preset (r);
+ }
+
+ return s;
+}
+
+bool
+WindowsVSTPlugin::load_plugin_preset (PresetRecord r)
+{
+ /* This is a plugin-provided preset.
+ We can't dispatch directly here; too many plugins expects only one GUI thread.
+ */
+
+ /* Extract the index of this preset from the URI */
+ int id;
+ int index;
+ int const p = sscanf (r.uri.c_str(), "VST:%d:%d", &id, &index);
+ assert (p == 2);
+
+ _fst->want_program = index;
+ return true;
+}
+
+bool
+WindowsVSTPlugin::load_user_preset (PresetRecord r)
+{
+ /* This is a user preset; we load it, and this code also knows about the
+ non-direct-dispatch thing.
+ */
+
+ boost::shared_ptr<XMLTree> t (presets_tree ());
+ if (t == 0) {
+ return false;
+ }
+
+ XMLNode* root = t->root ();
+
+ for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
+
+ XMLProperty* uri = (*i)->property (X_("uri"));
+ XMLProperty* label = (*i)->property (X_("label"));
+
+ assert (uri);
+ assert (label);
+
+ if (label->value() != r.label) {
+ continue;
+ }
+
+ if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
+
+ /* Load a user preset chunk from our XML file and send it via a circuitous route to the plugin */
+
+ if (_fst->wanted_chunk) {
+ g_free (_fst->wanted_chunk);
+ }
+
+ for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
+ if ((*j)->is_content ()) {
+ /* we can't dispatch directly here; too many plugins expect only one GUI thread */
+ gsize size = 0;
+ guchar* raw_data = g_base64_decode ((*j)->content().c_str(), &size);
+ _fst->wanted_chunk = raw_data;
+ _fst->wanted_chunk_size = size;
+ _fst->want_chunk = 1;
+ return true;
+ }
+ }
+
+ return false;
+
+ } else {
+
+ for (XMLNodeList::const_iterator j = (*i)->children().begin(); j != (*i)->children().end(); ++j) {
+ if ((*j)->name() == X_("Parameter")) {
+
+ XMLProperty* index = (*j)->property (X_("index"));
+ XMLProperty* value = (*j)->property (X_("value"));
+
+ assert (index);
+ assert (value);
+
+ set_parameter (atoi (index->value().c_str()), atof (value->value().c_str ()));
+ }
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+string
+WindowsVSTPlugin::do_save_preset (string name)
+{
+ boost::shared_ptr<XMLTree> t (presets_tree ());
+ if (t == 0) {
+ return "";
+ }
+
+ XMLNode* p = 0;
+ /* XXX: use of _presets.size() + 1 for the unique ID here is dubious at best */
+ string const uri = string_compose (X_("VST:%1:%2"), unique_id (), _presets.size() + 1);
+
+ if (_plugin->flags & 32 /* effFlagsProgramsChunks */) {
+
+ p = new XMLNode (X_("ChunkPreset"));
+ p->add_property (X_("uri"), uri);
+ p->add_property (X_("label"), name);
+ gchar* data = get_chunk (true);
+ p->add_content (string (data));
+ g_free (data);
+
+ } else {
+
+ p = new XMLNode (X_("Preset"));
+ p->add_property (X_("uri"), uri);
+ p->add_property (X_("label"), name);
+
+ for (uint32_t i = 0; i < parameter_count(); ++i) {
+ if (parameter_is_input (i)) {
+ XMLNode* c = new XMLNode (X_("Parameter"));
+ c->add_property (X_("index"), string_compose ("%1", i));
+ c->add_property (X_("value"), string_compose ("%1", get_parameter (i)));
+ p->add_child_nocopy (*c);
+ }
+ }
+
+ }
+
+ t->root()->add_child_nocopy (*p);
+
+ sys::path f = ARDOUR::user_config_directory ();
+ f /= "presets";
+ f /= presets_file ();
+
+ t->write (f.to_string ());
+ return uri;
+}
+
+void
+WindowsVSTPlugin::do_remove_preset (string name)
+{
+ boost::shared_ptr<XMLTree> t (presets_tree ());
+ if (t == 0) {
+ return;
+ }
+
+ t->root()->remove_nodes_and_delete (X_("label"), name);
+
+ sys::path f = ARDOUR::user_config_directory ();
+ f /= "presets";
+ f /= presets_file ();
+
+ t->write (f.to_string ());
+}
+
+string
+WindowsVSTPlugin::describe_parameter (Evoral::Parameter param)
+{
+ char name[64];
+ _plugin->dispatcher (_plugin, effGetParamName, param.id(), 0, name, 0);
+ return name;
+}
+
+framecnt_t
+WindowsVSTPlugin::signal_latency () const
+{
+ if (_user_latency) {
+ return _user_latency;
+ }
+
+#ifdef VESTIGE_HEADER
+ return *((framecnt_t *) (((char *) &_plugin->flags) + 12)); /* initialDelay */
+#else
+ return _plugin->initial_delay;
+#endif
+}
+
+set<Evoral::Parameter>
+WindowsVSTPlugin::automatable () const
+{
+ set<Evoral::Parameter> ret;
+
+ for (uint32_t i = 0; i < parameter_count(); ++i){
+ ret.insert (ret.end(), Evoral::Parameter(PluginAutomation, 0, i));
+ }
+
+ return ret;
+}
+
+int
+WindowsVSTPlugin::connect_and_run (BufferSet& bufs,
+ ChanMapping in_map, ChanMapping out_map,
+ pframes_t nframes, framecnt_t offset)
+{
+ Plugin::connect_and_run (bufs, in_map, out_map, nframes, offset);
+
+ float *ins[_plugin->numInputs];
+ float *outs[_plugin->numOutputs];
+ int32_t i;
+
+ const uint32_t nbufs = bufs.count().n_audio();
+
+ int in_index = 0;
+ for (i = 0; i < (int32_t) _plugin->numInputs; ++i) {
+ ins[i] = bufs.get_audio(min((uint32_t) in_index, nbufs - 1)).data() + offset;
+ in_index++;
+ }
+
+ int out_index = 0;
+ for (i = 0; i < (int32_t) _plugin->numOutputs; ++i) {
+ outs[i] = bufs.get_audio(min((uint32_t) out_index, nbufs - 1)).data() + offset;
+
+ /* unbelievably, several VST plugins still rely on Cubase
+ behaviour and do not silence the buffer in processReplacing
+ when they have no output.
+ */
+
+ // memset (outs[i], 0, sizeof (Sample) * nframes);
+ out_index++;
+ }
+
+
+ if (bufs.count().n_midi() > 0) {
+ VstEvents* v = bufs.get_vst_midi (0);
+ _plugin->dispatcher (_plugin, effProcessEvents, 0, 0, v, 0);
+ }
+
+ /* we already know it can support processReplacing */
+ _plugin->processReplacing (_plugin, ins, outs, nframes);
+
+ return 0;
+}
+
+void
+WindowsVSTPlugin::deactivate ()
+{
+ _plugin->dispatcher (_plugin, effMainsChanged, 0, 0, NULL, 0.0f);
+}
+
+void
+WindowsVSTPlugin::activate ()
+{
+ _plugin->dispatcher (_plugin, effMainsChanged, 0, 1, NULL, 0.0f);
+}
+
+string
+WindowsVSTPlugin::unique_id() const
+{
+ char buf[32];
+
+#ifdef VESTIGE_HEADER
+ snprintf (buf, sizeof (buf), "%d", *((int32_t*) &_plugin->unused_id));
+#else
+ snprintf (buf, sizeof (buf), "%d", _plugin->uniqueID);
+#endif
+ return string (buf);
+}
+
+
+const char *
+WindowsVSTPlugin::name () const
+{
+ return handle->name;
+}
+
+const char *
+WindowsVSTPlugin::maker () const
+{
+ return _info->creator.c_str();
+}
+
+const char *
+WindowsVSTPlugin::label () const
+{
+ return handle->name;
+}
+
+uint32_t
+WindowsVSTPlugin::parameter_count() const
+{
+ return _plugin->numParams;
+}
+
+bool
+WindowsVSTPlugin::has_editor () const
+{
+ return _plugin->flags & effFlagsHasEditor;
+}
+
+void
+WindowsVSTPlugin::print_parameter (uint32_t param, char *buf, uint32_t len) const
+{
+ char *first_nonws;
+
+ _plugin->dispatcher (_plugin, 7 /* effGetParamDisplay */, param, 0, buf, 0);
+
+ if (buf[0] == '\0') {
+ return;
+ }
+
+ first_nonws = buf;
+ while (*first_nonws && isspace (*first_nonws)) {
+ first_nonws++;
+ }
+ if (*first_nonws == '\0') {
+ return;
+ }
+
+ memmove (buf, first_nonws, strlen (buf) - (first_nonws - buf) + 1);
+}
+
+PluginPtr
+WindowsVSTPluginInfo::load (Session& session)
+{
+ try {
+ PluginPtr plugin;
+
+ if (Config->get_use_windows_vst ()) {
+ FSTHandle* handle;
+
+ handle = fst_load(path.c_str());
+
+ if ( (int)handle == -1) {
+ error << string_compose(_("VST: cannot load module from \"%1\""), path) << endmsg;
+ } else {
+ plugin.reset (new WindowsVSTPlugin (session.engine(), session, handle));
+ }
+ } else {
+ error << _("You asked ardour to not use any VST plugins") << endmsg;
+ return PluginPtr ((Plugin*) 0);
+ }
+
+ plugin->set_info(PluginInfoPtr(new WindowsVSTPluginInfo(*this)));
+ return plugin;
+ }
+
+ catch (failed_constructor &err) {
+ return PluginPtr ((Plugin*) 0);
+ }
+}
+
+void
+WindowsVSTPlugin::find_presets ()
+{
+ /* Built-in presets */
+
+ int const vst_version = _plugin->dispatcher (_plugin, effGetVstVersion, 0, 0, NULL, 0);
+ for (int i = 0; i < _plugin->numPrograms; ++i) {
+ PresetRecord r (string_compose (X_("VST:%1:%2"), unique_id (), i), "", false);
+
+ if (vst_version >= 2) {
+ char buf[256];
+ if (_plugin->dispatcher (_plugin, 29, i, 0, buf, 0) == 1) {
+ r.label = buf;
+ } else {
+ r.label = string_compose (_("Preset %1"), i);
+ }
+ } else {
+ r.label = string_compose (_("Preset %1"), i);
+ }
+
+ _presets.insert (make_pair (r.uri, r));
+ }
+
+ /* User presets from our XML file */
+
+ boost::shared_ptr<XMLTree> t (presets_tree ());
+
+ if (t) {
+ XMLNode* root = t->root ();
+ for (XMLNodeList::const_iterator i = root->children().begin(); i != root->children().end(); ++i) {
+
+ XMLProperty* uri = (*i)->property (X_("uri"));
+ XMLProperty* label = (*i)->property (X_("label"));
+
+ assert (uri);
+ assert (label);
+
+ PresetRecord r (uri->value(), label->value(), true);
+ _presets.insert (make_pair (r.uri, r));
+ }
+ }
+
+}
+
+/** @return XMLTree with our user presets; could be a new one if no existing
+ * one was found, or 0 if one was present but badly-formatted.
+ */
+XMLTree *
+WindowsVSTPlugin::presets_tree () const
+{
+ XMLTree* t = new XMLTree;
+
+ sys::path p = ARDOUR::user_config_directory ();
+ p /= "presets";
+
+ if (!is_directory (p)) {
+ create_directory (p);
+ }
+
+ p /= presets_file ();
+
+ if (!exists (p)) {
+ t->set_root (new XMLNode (X_("WindowsVSTPresets")));
+ return t;
+ }
+
+ t->set_filename (p.to_string ());
+ if (!t->read ()) {
+ delete t;
+ return 0;
+ }
+
+ return t;
+}
+
+/** @return Index of the first user preset in our lists */
+int
+WindowsVSTPlugin::first_user_preset_index () const
+{
+ return _plugin->numPrograms;
+}
+
+string
+WindowsVSTPlugin::presets_file () const
+{
+ return string_compose ("vst-%1", unique_id ());
+}
+
+WindowsVSTPluginInfo::WindowsVSTPluginInfo()
+{
+ type = ARDOUR::Windows_VST;
+}
+
if bld.is_defined('HAVE_SUIL'):
obj.uselib += ['SUIL']
- if bld.is_defined('VST_SUPPORT'):
- obj.source += [ 'vst_plugin.cc', 'session_vst.cc' ]
+ if bld.is_defined('WINDOWS_VST_SUPPORT'):
+ obj.source += [ 'windows_vst_plugin.cc', 'session_vst.cc' ]
obj.includes += [ '../fst' ]
- obj.defines += [ 'VST_SUPPORT' ]
+ obj.defines += [ 'WINDOWS_VST_SUPPORT' ]
if bld.is_defined('LXVST_SUPPORT'):
obj.source += [ 'lxvst_plugin.cc', 'session_lxvst.cc', 'vstfx.cc', 'vstfxinfofile.cc' ]
#!/bin/sh
-. `dirname "$0"`/../build/default/gtk2_ardour/ardev_common_waf.sh
+. `dirname "$0"`/../build/gtk2_ardour/ardev_common_waf.sh
export LD_LIBRARY_PATH=$libs/../gtk2_ardour:$LD_LIBRARY_PATH
-exec $libs/../gtk2_ardour/ardour-3.0-vst "$@"
+exec wine $libs/../gtk2_ardour/ardour-3.0-vst.exe.so "$@"
# no VST on x86_64
#
- if conf.env['build_target'] == 'x86_64' and opt.vst:
+ if conf.env['build_target'] == 'x86_64' and opt.windows_vst:
print("\n\n==================================================")
- print("You cannot use VST plugins with a 64 bit host. Please run waf with --vst=0")
+ print("You cannot use VST plugins with a 64 bit host. Please run waf with --windows-vst=0")
print("\nIt is theoretically possible to build a 32 bit host on a 64 bit system.")
print("However, this is tricky and not recommended for beginners.")
sys.exit (-1)
help='Compile as universal binary (requires that external libraries are universal)')
opt.add_option('--versioned', action='store_true', default=False, dest='versioned',
help='Add revision information to executable name inside the build directory')
- opt.add_option('--vst', action='store_true', default=False, dest='vst',
- help='Compile with support for VST')
+ opt.add_option('--windows-vst', action='store_true', default=False, dest='windows_vst',
+ help='Compile with support for Windows VST')
opt.add_option('--wiimote', action='store_true', default=False, dest='wiimote',
help='Build the wiimote control surface')
opt.add_option('--windows-key', type='string', action='store', dest='windows_key', default='Mod4><Super',
conf.env['BUILD_TESTS'] = opts.build_tests
if opts.tranzport:
conf.env['TRANZPORT'] = 1
- if opts.vst:
- conf.define('VST_SUPPORT', 1)
- conf.env['VST_SUPPORT'] = True
+ if opts.windows_vst:
+ conf.define('WINDOWS_VST_SUPPORT', 1)
+ conf.env['WINDOWS_VST_SUPPORT'] = True
conf.env.append_value('CFLAGS', '-I' + Options.options.wine_include)
conf.env.append_value('CXXFLAGS', '-I' + Options.options.wine_include)
autowaf.check_header(conf, 'cxx', 'windows.h', mandatory = True)
write_config_text('Tranzport', opts.tranzport)
write_config_text('Unit tests', conf.env['BUILD_TESTS'])
write_config_text('Universal binary', opts.universal)
- write_config_text('VST support', opts.vst)
+ write_config_text('Windows VST support', opts.windows_vst)
write_config_text('Wiimote support', opts.wiimote)
write_config_text('Windows key', opts.windows_key)
projects / ardour.git / commitdiff