X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fplugin_insert.h;h=d9b85fe9c9fd844c2762788a5d4168375c6beb4c;hb=90172686b92b53cc5ab1d60c0e6daecb65d17d3d;hp=0694fa2a683e03c22da78577b4b5616fe31634d0;hpb=a1052b0eca7bdc8ec1e3ac2996cd16bb48e2a6d2;p=ardour.git

diff --git a/libs/ardour/ardour/plugin_insert.h b/libs/ardour/ardour/plugin_insert.h
index 0694fa2a68..d9b85fe9c9 100644
--- a/libs/ardour/ardour/plugin_insert.h
+++ b/libs/ardour/ardour/plugin_insert.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000,2007 Paul Davis 
+    Copyright (C) 2000,2007 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
@@ -23,12 +23,12 @@
 #include <vector>
 #include <string>
 
-#include <sigc++/signal.h>
-#include <ardour/ardour.h>
-#include <ardour/plugin_state.h>
-#include <ardour/types.h>
-#include <ardour/processor.h>
-#include <ardour/automation_event.h>
+#include <boost/weak_ptr.hpp>
+
+#include "ardour/ardour.h"
+#include "ardour/types.h"
+#include "ardour/processor.h"
+#include "ardour/automation_control.h"
 
 class XMLNode;
 
@@ -43,24 +43,23 @@ class Plugin;
 class PluginInsert : public Processor
 {
   public:
-	PluginInsert (Session&, boost::shared_ptr<Plugin>, Placement);
-	PluginInsert (Session&, const XMLNode&);
-	PluginInsert (const PluginInsert&);
+	PluginInsert (Session&, boost::shared_ptr<Plugin> = boost::shared_ptr<Plugin>());
 	~PluginInsert ();
 
-	static const string port_automation_node_name;
-	
+	static const std::string port_automation_node_name;
+
 	XMLNode& state(bool);
 	XMLNode& get_state(void);
-	int set_state(const XMLNode&);
+	int set_state(const XMLNode&, int version);
+
+	void run (BufferSet& in, framepos_t start_frame, framepos_t end_frame, nframes_t nframes, bool);
+	void silence (nframes_t nframes);
 
-	void run_in_place (BufferSet& in, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset);
-	void silence (nframes_t nframes, nframes_t offset);
-	
 	void activate ();
 	void deactivate ();
+        void flush ();
 
-	void set_block_size (nframes_t nframes);
+	int set_block_size (nframes_t nframes);
 
 	ChanCount output_streams() const;
 	ChanCount input_streams() const;
@@ -70,32 +69,27 @@ class PluginInsert : public Processor
 	bool     set_count (uint32_t num);
 	uint32_t get_count () const { return _plugins.size(); }
 
-	virtual bool      can_support_input_configuration (ChanCount in) const;
-	virtual ChanCount output_for_input_configuration (ChanCount in) const;
-	virtual bool      configure_io (ChanCount in, ChanCount out);
+	bool can_support_io_configuration (const ChanCount& in, ChanCount& out) const;
+	bool configure_io (ChanCount in, ChanCount out);
 
 	bool is_generator() const;
 
-	void set_parameter (Parameter param, float val);
-	float get_parameter (Parameter param);
-
-	float default_parameter_value (Parameter param);
-	
-	struct PluginControl : public AutomationControl {
-	    PluginControl (PluginInsert& p, boost::shared_ptr<AutomationList> list);
-	    
-		void set_value (float val);
-	    float get_value (void) const;
-	
+	struct PluginControl : public AutomationControl
+	{
+		PluginControl (PluginInsert* p, const Evoral::Parameter &param,
+				boost::shared_ptr<AutomationList> list = boost::shared_ptr<AutomationList>());
+
+		void set_value (double val);
+		double get_value (void) const;
+
 	private:
-		PluginInsert& _plugin;
-		boost::shared_ptr<AutomationList> _list;
+		PluginInsert* _plugin;
 		bool _logarithmic;
 		bool _toggled;
 	};
 
 	boost::shared_ptr<Plugin> plugin(uint32_t num=0) const {
-		if (num < _plugins.size()) { 
+		if (num < _plugins.size()) {
 			return _plugins[num];
 		} else {
 			return _plugins[0]; // we always have one
@@ -104,26 +98,49 @@ class PluginInsert : public Processor
 
 	PluginType type ();
 
-	string describe_parameter (Parameter param);
+	std::string describe_parameter (Evoral::Parameter param);
 
 	nframes_t signal_latency() const;
 
+	boost::shared_ptr<Plugin> get_impulse_analysis_plugin();
+
+	void collect_signal_for_analysis(nframes_t nframes);
+
+	PBD::Signal2<void,BufferSet*, BufferSet*> AnalysisDataGathered;
+
   private:
+	/* disallow copy construction */
+	PluginInsert (const PluginInsert&);
+
+	void parameter_changed (Evoral::Parameter, float);
+
+	void  set_parameter (Evoral::Parameter param, float val);
+	float get_parameter (Evoral::Parameter param);
+
+	float default_parameter_value (const Evoral::Parameter& param);
+
+	typedef std::vector<boost::shared_ptr<Plugin> > Plugins;
+	Plugins _plugins;
+
+	boost::weak_ptr<Plugin> _impulseAnalysisPlugin;
+
+	nframes_t _signal_analysis_collected_nframes;
+	nframes_t _signal_analysis_collect_nframes_max;
+
+	BufferSet _signal_analysis_inputs;
+	BufferSet _signal_analysis_outputs;
 
-	void parameter_changed (Parameter, float);
-	
-	std::vector<boost::shared_ptr<Plugin> > _plugins;
-	
-	void automation_run (BufferSet& bufs, nframes_t nframes, nframes_t offset);
+	void automation_run (BufferSet& bufs, nframes_t nframes);
 	void connect_and_run (BufferSet& bufs, nframes_t nframes, nframes_t offset, bool with_auto, nframes_t now = 0);
 
-	void init ();
 	void set_automatable ();
-	void auto_state_changed (Parameter which);
+	void control_list_automation_state_changed (Evoral::Parameter, AutoState);
+	void set_parameter_state_2X (const XMLNode& node, int version);
 
 	int32_t count_for_configuration (ChanCount in, ChanCount out) const;
 
 	boost::shared_ptr<Plugin> plugin_factory (boost::shared_ptr<Plugin>);
+	void add_plugin_with_activation (boost::shared_ptr<Plugin>);
 };
 
 } // namespace ARDOUR