X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fplugin.h;h=a22d138770c6ace95115c2dae9e1fb503cb3cb7d;hb=e4304f3bf2daa24395f7b520476115ca418ad93e;hp=7bef40ab88814dc28601a4e4b931bd8d45578e3b;hpb=f806f059b3c229004cfbac50234062333fc38229;p=ardour.git diff --git a/libs/ardour/ardour/plugin.h b/libs/ardour/ardour/plugin.h index 7bef40ab88..a22d138770 100644 --- a/libs/ardour/ardour/plugin.h +++ b/libs/ardour/ardour/plugin.h @@ -22,6 +22,7 @@ #include #include +#include #include "pbd/statefuldestructible.h" #include "pbd/controllable.h" @@ -32,6 +33,7 @@ #include "ardour/cycles.h" #include "ardour/latent.h" #include "ardour/libardour_visibility.h" +#include "ardour/midi_ring_buffer.h" #include "ardour/midi_state_tracker.h" #include "ardour/parameter_descriptor.h" #include "ardour/types.h" @@ -48,47 +50,23 @@ class Session; class BufferSet; class PluginInsert; class Plugin; +class PluginInfo; +class AutomationControl; +class SessionObject; typedef boost::shared_ptr PluginPtr; - -class LIBARDOUR_API PluginInfo { - public: - PluginInfo () { } - virtual ~PluginInfo () { } - - std::string name; - std::string category; - std::string creator; - std::string path; - ChanCount n_inputs; - ChanCount n_outputs; - ARDOUR::PluginType type; - - std::string unique_id; - - virtual PluginPtr load (Session& session) = 0; - virtual bool is_instrument() const; - - /* NOTE: this block of virtual methods looks like the interface - to a Processor, but Plugin does not inherit from Processor. - It is therefore not required that these precisely match - the interface, but it is likely that they will evolve together. - */ - - /* this returns true if the plugin can change its inputs or outputs on demand. - LADSPA, LV2 and VST plugins cannot do this. AudioUnits can. - */ - - virtual bool reconfigurable_io() const { return false; } - - protected: - friend class PluginManager; - uint32_t index; -}; - typedef boost::shared_ptr PluginInfoPtr; typedef std::list PluginInfoList; - +typedef std::set PluginOutputConfiguration; + +/** A plugin is an external module (usually 3rd party provided) loaded into Ardour + * for the purpose of digital signal processing. + * + * This class provides an abstraction for methords provided by + * all supported plugin standards such as presets, name, parameters etc. + * + * Plugins are not used directly in Ardour but always wrapped by a PluginInsert. + */ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent { public: @@ -100,6 +78,7 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent virtual int set_state (const XMLNode &, int version); virtual void set_insert_id (PBD::ID id) {} + virtual void set_state_dir (const std::string& d = "") {} virtual std::string unique_id() const = 0; virtual const char * label() const = 0; @@ -111,17 +90,33 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent virtual std::string get_docs () const { return ""; } virtual std::string get_parameter_docs (uint32_t /*which*/) const { return ""; } + struct UILayoutHint { + UILayoutHint () + : x0(-1), x1(-1), y0(-1), y1(-1), knob(false) {} + int x0; + int x1; + int y0; + int y1; + bool knob; + }; + + virtual bool get_layout (uint32_t which, UILayoutHint&) const { return false; } + virtual int get_parameter_descriptor (uint32_t which, ParameterDescriptor&) const = 0; virtual uint32_t nth_parameter (uint32_t which, bool& ok) const = 0; + virtual std::string parameter_label (uint32_t which) const; virtual void activate () = 0; virtual void deactivate () = 0; virtual void flush () { deactivate(); activate(); } virtual int set_block_size (pframes_t nframes) = 0; + virtual bool requires_fixed_sized_buffers() const { return false; } + virtual bool inplace_broken() const { return false; } virtual int connect_and_run (BufferSet& bufs, - ChanMapping in, ChanMapping out, - pframes_t nframes, framecnt_t offset); + samplepos_t start, samplepos_t end, double speed, + ChanMapping const& in, ChanMapping const& out, + pframes_t nframes, samplecnt_t offset); virtual std::set automatable() const = 0; virtual std::string describe_parameter (Evoral::Parameter) = 0; @@ -133,26 +128,80 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent virtual bool parameter_is_input(uint32_t) const = 0; virtual bool parameter_is_output(uint32_t) const = 0; + virtual uint32_t designated_bypass_port () { return UINT32_MAX; } + + struct LIBARDOUR_API IOPortDescription { + public: + IOPortDescription (const std::string& n) + : name (n) + , is_sidechain (false) + , group_name (n) + , group_channel (0) + {} + IOPortDescription (const IOPortDescription &other) + : name (other.name) + , is_sidechain (other.is_sidechain) + , group_name (other.group_name) + , group_channel (other.group_channel) + {} + std::string name; + bool is_sidechain; + + std::string group_name; + uint32_t group_channel; + }; + + virtual IOPortDescription describe_io_port (DataType dt, bool input, uint32_t id) const; + virtual PluginOutputConfiguration possible_output () const; + + virtual void set_automation_control (uint32_t /*port_index*/, boost::shared_ptr) { } + virtual boost::shared_ptr get_scale_points(uint32_t /*port_index*/) const { return boost::shared_ptr(); } + bool write_immediate_event (size_t size, const uint8_t* buf); + void realtime_handle_transport_stopped (); void realtime_locate (); void monitoring_changed (); + typedef struct { + unsigned char *data; + int width; + int height; + int stride; + } Display_Image_Surface; + + virtual bool has_inline_display () { return false; } + virtual bool inline_display_in_gui () { return false; } + virtual Display_Image_Surface* render_inline_display (uint32_t, uint32_t) { return NULL; } + PBD::Signal0 QueueDraw; + + virtual bool has_midnam () { return false; } + virtual bool read_midnam () { return false; } + virtual std::string midnam_model () { return ""; } + PBD::Signal0 UpdateMidnam; + PBD::Signal0 UpdatedMidnam; + + virtual bool knows_bank_patch () { return false; } + virtual uint32_t bank_patch (uint8_t chn) { return UINT32_MAX; } + PBD::Signal1 BankPatchChange; + struct PresetRecord { - PresetRecord () : number (-1), user (true) {} - PresetRecord (const std::string& u, const std::string& l, int n = -1, bool s = true) : uri (u), label (l), number (n), user (s) {} + PresetRecord () : valid (false) {} + PresetRecord (const std::string& u, const std::string& l, bool s = true, const std::string& d = "") + : uri (u), label (l), description (d), user (s), valid (true) {} bool operator!= (PresetRecord const & a) const { - return number != a.number || uri != a.uri || label != a.label; + return uri != a.uri || label != a.label; } std::string uri; std::string label; - int number; // if <0, invalid + std::string description; bool user; + bool valid; }; PresetRecord save_preset (std::string); @@ -201,10 +250,16 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent return 0; } + /** the max possible latency a plugin will have */ + virtual samplecnt_t max_latency () const { return 0; } // TODO = 0, require implementation + /** Emitted when a preset is added or removed, respectively */ PBD::Signal0 PresetAdded; PBD::Signal0 PresetRemoved; + /** Emitted when any preset has been changed */ + static PBD::Signal2 PresetsChanged; + /** Emitted when a preset has been loaded */ PBD::Signal0 PresetLoaded; @@ -213,6 +268,9 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent */ PBD::Signal0 PresetDirty; + /** Emitted for preset-load to set a control-port */ + PBD::Signal2 PresetPortSetValue; + virtual bool has_editor () const = 0; /** Emitted when a parameter is altered by something outside of our @@ -225,13 +283,16 @@ class LIBARDOUR_API Plugin : public PBD::StatefulDestructible, public Latent /* specific types of plugins can overload this. As of September 2008, only AUPlugin does this. */ - virtual bool can_support_io_configuration (const ChanCount& /*in*/, ChanCount& /*out*/) { return false; } + virtual bool can_support_io_configuration (const ChanCount& /*in*/, ChanCount& /*out*/, ChanCount* imprecise = 0) { return false; } virtual ChanCount output_streams() const; virtual ChanCount input_streams() const; PluginInfoPtr get_info() const { return _info; } virtual void set_info (const PluginInfoPtr inf); + virtual void set_owner (SessionObject* o) { _owner = o; } + SessionObject* owner() const { return _owner; } + ARDOUR::AudioEngine& engine() const { return _engine; } ARDOUR::Session& session() const { return _session; } @@ -284,7 +345,7 @@ protected: /* Called when a parameter of the plugin is changed outside of this * host's control (typical via a plugin's own GUI/editor) */ - void parameter_changed_externally (uint32_t which, float val); + virtual void parameter_changed_externally (uint32_t which, float val); /* should be overridden by plugin API specific derived types to * actually implement changing the parameter. The derived type should @@ -305,6 +366,8 @@ protected: uint32_t _cycles; std::map _presets; + SessionObject* _owner; + private: /** Fill _presets with our presets */ @@ -320,11 +383,80 @@ private: PresetRecord _last_preset; bool _parameter_changed_since_last_preset; + PBD::ScopedConnection _preset_connection; + + MidiRingBuffer _immediate_events; + void resolve_midi (); }; +struct PluginPreset { + PluginInfoPtr _pip; + Plugin::PresetRecord _preset; + + PluginPreset (PluginInfoPtr pip, const Plugin::PresetRecord *preset = NULL) + : _pip (pip) + { + if (preset) { + _preset.uri = preset->uri; + _preset.label = preset->label; + _preset.user = preset->user; + _preset.valid = preset->valid; + } + } +}; + +typedef boost::shared_ptr PluginPresetPtr; +typedef std::list PluginPresetList; + PluginPtr find_plugin(ARDOUR::Session&, std::string unique_id, ARDOUR::PluginType); +class LIBARDOUR_API PluginInfo { + public: + PluginInfo () { } + virtual ~PluginInfo () { } + + std::string name; + std::string category; + std::string creator; + std::string path; + ChanCount n_inputs; + ChanCount n_outputs; + ARDOUR::PluginType type; + + std::string unique_id; + + virtual PluginPtr load (Session& session) = 0; + + /* NOTE: it is possible for a plugin to be an effect AND an instrument. + * override these funcs as necessary to support that. + */ + virtual bool is_effect () const; + virtual bool is_instrument () const; + virtual bool is_utility () const; //this includes things like "generators" and "midi filters" + virtual bool is_analyzer () const; + + virtual bool needs_midi_input() const; + + virtual std::vector get_presets (bool user_only) const = 0; + + /* NOTE: this block of virtual methods looks like the interface + to a Processor, but Plugin does not inherit from Processor. + It is therefore not required that these precisely match + the interface, but it is likely that they will evolve together. + */ + + /* this returns true if the plugin can change its inputs or outputs on demand. + LADSPA, LV2 and VST plugins cannot do this. AudioUnits can. + */ + + virtual bool reconfigurable_io() const { return false; } + + protected: + friend class PluginManager; + uint32_t index; +}; + } // namespace ARDOUR #endif /* __ardour_plugin_h__ */