remove reference "const int32_t&" -> const int32_t"

[ardour.git] / libs / ardour / ardour / ladspa_plugin.h

diff --git a/libs/ardour/ardour/ladspa_plugin.h b/libs/ardour/ardour/ladspa_plugin.h
index bdad8009f5307ba6daa4878d6114ef0e64a19f4a..dbb635fd91132fe3e80a1e36501a090c5b9d6ea5 100644 (file)
--- a/libs/ardour/ardour/ladspa_plugin.h
+++ b/libs/ardour/ardour/ladspa_plugin.h
@@ -23,12 +23,11 @@
 #include <set>
 #include <vector>
 #include <string>
-#include <dlfcn.h>
 
+#include <glibmm/module.h>
 
 #include "pbd/stateful.h"
 
-#include <jack/types.h>
 #include "ardour/ladspa.h"
 #include "ardour/plugin.h"
 
@@ -36,10 +35,10 @@ namespace ARDOUR {
 class AudioEngine;
 class Session;
 
-class LadspaPlugin : public ARDOUR::Plugin
+class LIBARDOUR_API LadspaPlugin : public ARDOUR::Plugin
 {
   public:
-       LadspaPlugin (void *module, ARDOUR::AudioEngine&, ARDOUR::Session&, uint32_t index, nframes_t sample_rate);
+       LadspaPlugin (std::string module_path, ARDOUR::AudioEngine&, ARDOUR::Session&, uint32_t index, framecnt_t sample_rate);
        LadspaPlugin (const LadspaPlugin &);
        ~LadspaPlugin ();
 
@@ -50,8 +49,8 @@ class LadspaPlugin : public ARDOUR::Plugin
        const char* name() const            { return _descriptor->Name; }
        const char* maker() const           { return _descriptor->Maker; }
        uint32_t    parameter_count() const { return _descriptor->PortCount; }
-       float       default_value (uint32_t port);
-       nframes_t   signal_latency() const;
+       float       default_value (uint32_t port) { return _default_value (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;
@@ -81,11 +80,12 @@ class LadspaPlugin : public ARDOUR::Plugin
                        _descriptor->cleanup (_handle);
        }
 
-       void set_block_size (nframes_t /*nframes*/) {}
+       int set_block_size (pframes_t /*nframes*/) { return 0; }
 
        int connect_and_run (BufferSet& bufs,
+                       framepos_t start, framepos_t end, double speed,
                        ChanMapping in, ChanMapping out,
-                       nframes_t nframes, nframes_t offset);
+                       pframes_t nframes, framecnt_t offset);
 
        std::string describe_parameter (Evoral::Parameter);
        std::string state_node_name() const { return "ladspa"; }
@@ -97,20 +97,21 @@ class LadspaPlugin : public ARDOUR::Plugin
        bool parameter_is_output(uint32_t) const;
        bool parameter_is_toggled(uint32_t) const;
 
-       XMLNode& get_state();
-       int      set_state (const XMLNode&, int version);
-       bool     save_preset(std::string name);
+       boost::shared_ptr<ScalePoints>
+       get_scale_points(uint32_t port_index) const;
 
-       bool has_editor() const { return false; }
+       int set_state (const XMLNode&, int version);
+
+       bool load_preset (PresetRecord);
 
-       int require_output_streams (uint32_t);
+       bool has_editor() const { return false; }
 
        /* LADSPA extras */
 
        LADSPA_Properties           properties() const                { return _descriptor->Properties; }
        uint32_t                    index() const                     { return _index; }
        const char *                copyright() const                 { return _descriptor->Copyright; }
-       LADSPA_PortDescriptor       port_descriptor(uint32_t i) const { return _descriptor->PortDescriptors[i]; }
+       LADSPA_PortDescriptor       port_descriptor(uint32_t i) const;
        const LADSPA_PortRangeHint* port_range_hints() const          { return _descriptor->PortRangeHints; }
        const char * const *        port_names() const                { return _descriptor->PortNames; }
 
@@ -119,28 +120,39 @@ class LadspaPlugin : public ARDOUR::Plugin
        void connect_port (uint32_t port, float *ptr) { _descriptor->connect_port (_handle, port, ptr); }
 
   private:
-       void*                    _module;
+       float                    _default_value (uint32_t port) const;
+       std::string              _module_path;
+       Glib::Module*            _module;
        const LADSPA_Descriptor* _descriptor;
        LADSPA_Handle            _handle;
-       nframes_t                _sample_rate;
+       framecnt_t               _sample_rate;
        LADSPA_Data*             _control_data;
        LADSPA_Data*             _shadow_data;
        LADSPA_Data*             _latency_control_port;
        uint32_t                 _index;
        bool                     _was_activated;
 
-       void init (void *mod, uint32_t index, nframes_t rate);
-       void run_in_place (nframes_t nsamples);
+       void find_presets ();
+
+       void init (std::string module_path, uint32_t index, framecnt_t rate);
+       void run_in_place (pframes_t nsamples);
        void latency_compute_run ();
        int set_state_2X (const XMLNode&, int version);
+       std::string do_save_preset (std::string name);
+       void do_remove_preset (std::string name);
+       std::string preset_envvar () const;
+       std::string preset_source (std::string) const;
+       bool write_preset_file (std::string);
+       void add_state (XMLNode *) const;
 };
 
-class LadspaPluginInfo : public PluginInfo {
+class LIBARDOUR_API LadspaPluginInfo : public PluginInfo {
   public:
        LadspaPluginInfo ();
        ~LadspaPluginInfo () { };
 
        PluginPtr load (Session& session);
+       std::vector<Plugin::PresetRecord> get_presets (bool user_only) const;
 };
 
 typedef boost::shared_ptr<LadspaPluginInfo> LadspaPluginInfoPtr;