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_route_h__
#include "ardour/gain_control.h"
#include "ardour/instrument_info.h"
#include "ardour/io.h"
+#include "ardour/io_vector.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
#include "ardour/mute_master.h"
#include "ardour/automatable.h"
#include "ardour/unknown_processor.h"
+class RoutePinWindowProxy;
+
namespace ARDOUR {
class Amp;
class PannerShell;
class PortSet;
class Processor;
+class PluginInsert;
class RouteGroup;
class Send;
class InternalReturn;
class LIBARDOUR_API Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
{
- public:
+public:
typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
boost::shared_ptr<IO> input() const { return _input; }
boost::shared_ptr<IO> output() const { return _output; }
+ IOVector all_inputs () const;
+ IOVector all_outputs () const;
ChanCount n_inputs() const { return _input->n_ports(); }
ChanCount n_outputs() const { return _output->n_ports(); }
bool set_name (const std::string& str);
static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true);
- uint32_t order_key () const;
- bool has_order_key () const;
+ uint32_t order_key () const;
+ bool has_order_key () const;
void set_order_key (uint32_t);
bool is_auditioner() const { return _flags & Auditioner; }
virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
virtual void realtime_handle_transport_stopped () {}
virtual void realtime_locate () {}
- virtual void non_realtime_locate (framepos_t);
+ virtual void non_realtime_locate (framepos_t);
virtual void set_pending_declick (int);
/* end of vfunc-based API */
std::list<std::string> unknown_processors () const;
+ RoutePinWindowProxy * pinmgr_proxy () const { return _pinmgr_proxy; }
+ void set_pingmgr_proxy (RoutePinWindowProxy* wp) { _pinmgr_proxy = wp ; }
+
/* special processors */
boost::shared_ptr<InternalSend> monitor_send() const { return _monitor_send; }
+ /** the signal processorat at end of the processing chain which produces output */
boost::shared_ptr<Delivery> main_outs() const { return _main_outs; }
boost::shared_ptr<InternalReturn> internal_return() const { return _intreturn; }
boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
boost::shared_ptr<Processor> before_processor_for_placement (Placement);
boost::shared_ptr<Processor> before_processor_for_index (int);
bool processors_reorder_needs_configure (const ProcessorList& new_order);
- int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool need_process_lock = true);
+ /** remove plugin/processor
+ *
+ * @param proc processor to remove
+ * @param err error report (index where removal vailed, channel-count why it failed) may be nil
+ * @param need_process_lock if locking is required (set to true, unless called from RT context with lock)
+ * @returns 0 on success
+ */
+ int remove_processor (boost::shared_ptr<Processor> proc, ProcessorStreams* err = 0, bool need_process_lock = true);
+ /** replace plugin/processor with another
+ *
+ * @param old processor to remove
+ * @param sub processor to substitute the old one with
+ * @param err error report (index where removal vailed, channel-count why it failed) may be nil
+ * @returns 0 on success
+ */
+ int replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err = 0);
int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
void disable_processors (Placement);
void clear_processors (Placement);
void all_visible_processors_active (bool);
+ bool strict_io () const { return _strict_io; }
+ bool set_strict_io (bool);
+ /** reset plugin-insert configuration to default, disable customizations.
+ *
+ * This is equivalent to calling
+ * @code
+ * customize_plugin_insert (proc, 0, unused)
+ * @endcode
+ *
+ * @param proc Processor to reset
+ * @returns true if successful
+ */
+ bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
+ /** enable custom plugin-insert configuration
+ * @param proc Processor to customize
+ * @param count number of plugin instances to use (if zero, reset to default)
+ * @param outs output port customization
+ * @param sinks input pins for variable-I/O plugins
+ * @returns true if successful
+ */
+ bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks);
+ bool add_remove_sidechain (boost::shared_ptr<Processor> proc, bool);
+ bool plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs);
+
+ /* enable sidechain input for a given processor
+ *
+ * The sidechain itself is an IO port object with variable number of channels and configured independently.
+ * Adding/removing the port itself however requires reconfiguring the route and is hence
+ * not a plugin operation itself.
+ *
+ * @param proc the processor to add sidechain inputs to
+ * @returns true on success
+ */
+ bool add_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, true); }
+ /* remove sidechain input from given processor
+ * @param proc the processor to remove the sidechain input from
+ * @returns true on success
+ */
+ bool remove_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, false); }
+
framecnt_t set_private_port_latencies (bool playback) const;
void set_public_port_latencies (framecnt_t, bool playback) const;
PropertyChanged (ARDOUR::Properties::name);
}
+ enum PluginSetupOptions {
+ None = 0x0,
+ CanReplace = 0x1,
+ MultiOut = 0x2,
+ };
+
+ static PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, PluginSetupOptions > PluginSetup;
+
/** the processors have changed; the parameter indicates what changed */
PBD::Signal1<void,RouteProcessorChange> processors_changed;
PBD::Signal1<void,void*> record_enable_changed;
*/
bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
+ bool feeds_according_to_graph (boost::shared_ptr<Route>);
+
struct FeedRecord {
boost::weak_ptr<Route> r;
bool sends_only;
AutomationType atype,
boost::shared_ptr<AutomationList> alist,
boost::shared_ptr<Route> route);
-
- void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) {
- boost::shared_ptr<Route> r = _route.lock();
- if (r) {
- r->set_control ((AutomationType) parameter().type(), val, group_override);
- }
- }
-
protected:
friend class Route;
void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) {
boost::shared_ptr<Route> r = _route.lock();
if (r) {
+ /* Route must mediate group control */
r->set_control ((AutomationType) parameter().type(), val, group_override);
}
}
void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
};
+ class LIBARDOUR_API SoloIsolateControllable : public RouteAutomationControl {
+ public:
+ SoloIsolateControllable (std::string name, boost::shared_ptr<Route>);
+ void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+ /* currently no automation, so no need for set_value_unchecked() */
+ double get_value () const;
+ private:
+ void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+ };
+
+ class LIBARDOUR_API SoloSafeControllable : public RouteAutomationControl {
+ public:
+ SoloSafeControllable (std::string name, boost::shared_ptr<Route>);
+ void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+ /* currently no automation, so no need for set_value_unchecked() */
+ double get_value () const;
+ private:
+ void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+ };
+
void set_control (AutomationType, double val, PBD::Controllable::GroupControlDisposition group_override);
boost::shared_ptr<SoloControllable> solo_control() const {
return _mute_master;
}
- boost::shared_ptr<PhaseControllable> phase_control() const {
- return _phase_control;
+ boost::shared_ptr<SoloIsolateControllable> solo_isolate_control() const {
+ return _solo_isolate_control;
+ }
+
+ boost::shared_ptr<SoloSafeControllable> solo_safe_control() const {
+ return _solo_safe_control;
+ }
+
+ boost::shared_ptr<AutomationControl> monitoring_control() const {
+ /* tracks override this to provide actual monitoring control;
+ busses have no possible choices except input monitoring.
+ */
+ return boost::shared_ptr<AutomationControl> ();
}
/* Route doesn't own these items, but sub-objects that it does own have them
boost::shared_ptr<Pannable> pannable() const;
boost::shared_ptr<GainControl> trim_control() const;
+ boost::shared_ptr<PhaseControllable> phase_control() const;
+
/**
Return the first processor that accepts has at least one MIDI input
and at least one audio output. In the vast majority of cases, this
special case not covered by this utility function.
*/
boost::shared_ptr<Processor> the_instrument() const;
- InstrumentInfo& instrument_info() { return _instrument_info; }
-
- /* "well-known" controls for panning. Any or all of these may return
- * null.
- */
-
- boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
- boost::shared_ptr<AutomationControl> pan_elevation_control() const;
- boost::shared_ptr<AutomationControl> pan_width_control() const;
- boost::shared_ptr<AutomationControl> pan_frontback_control() const;
- boost::shared_ptr<AutomationControl> pan_lfe_control() const;
-
- /* "well-known" controls for an EQ in this route. Any or all may
- * be null. eq_band_cnt() must return 0 if there is no EQ present.
- * Passing an @param band value >= eq_band_cnt() will guarantee the
- * return of a null ptr (or an empty string for eq_band_name()).
- */
- uint32_t eq_band_cnt () const;
- std::string eq_band_name (uint32_t) const;
- boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
- boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
- boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
- boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
- boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
- boost::shared_ptr<AutomationControl> eq_hpf_controllable () const;
-
- /* "well-known" controls for a compressor in this route. Any or all may
- * be null.
- */
- boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
- boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
- boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
- boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
- boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
- boost::shared_ptr<AutomationControl> comp_redux_controllable () const;
-
- /* @param mode must be supplied by the comp_mode_controllable(). All other values
- * result in undefined behaviour
- */
- std::string comp_mode_name (uint32_t mode) const;
- /* @param mode - as for comp mode name. This returns the name for the
- * parameter/control accessed via comp_speed_controllable(), which can
- * be mode dependent.
- */
- std::string comp_speed_name (uint32_t mode) const;
-
- /* "well-known" controls for sends to well-known busses in this route. Any or all may
- * be null.
- *
- * In Mixbus, these are the sends that connect to the mixbusses.
- * In Ardour, these are user-created sends that connect to user-created
- * Aux busses.
- */
- boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
- boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
- /* for the same value of @param n, this returns the name of the send
- * associated with the pair of controllables returned by the above two methods.
- */
- std::string send_name (uint32_t n) const;
-
- /* well known control that enables/disables sending to the master bus.
- *
- * In Ardour, this returns null.
- * In Mixbus, it will return a suitable control, or null depending on
- * the route.
- */
- boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
-
- void protect_automation ();
+ InstrumentInfo& instrument_info() { return _instrument_info; }
+
+ /* "well-known" controls for panning. Any or all of these may return
+ * null.
+ */
+
+ boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
+ boost::shared_ptr<AutomationControl> pan_elevation_control() const;
+ boost::shared_ptr<AutomationControl> pan_width_control() const;
+ boost::shared_ptr<AutomationControl> pan_frontback_control() const;
+ boost::shared_ptr<AutomationControl> pan_lfe_control() const;
+
+ /* "well-known" controls for an EQ in this route. Any or all may
+ * be null. eq_band_cnt() must return 0 if there is no EQ present.
+ * Passing an @param band value >= eq_band_cnt() will guarantee the
+ * return of a null ptr (or an empty string for eq_band_name()).
+ */
+ uint32_t eq_band_cnt () const;
+ std::string eq_band_name (uint32_t) const;
+ boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
+ boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
+ boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
+ boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
+ boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
+ boost::shared_ptr<AutomationControl> eq_hpf_controllable () const;
+
+ /* "well-known" controls for a compressor in this route. Any or all may
+ * be null.
+ */
+ boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
+ boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
+ boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
+ boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
+ boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
+ boost::shared_ptr<AutomationControl> comp_redux_controllable () const;
+
+ /* @param mode must be supplied by the comp_mode_controllable(). All other values
+ * result in undefined behaviour
+ */
+ std::string comp_mode_name (uint32_t mode) const;
+ /* @param mode - as for comp mode name. This returns the name for the
+ * parameter/control accessed via comp_speed_controllable(), which can
+ * be mode dependent.
+ */
+ std::string comp_speed_name (uint32_t mode) const;
+
+ /* "well-known" controls for sends to well-known busses in this route. Any or all may
+ * be null.
+ *
+ * In Mixbus, these are the sends that connect to the mixbusses.
+ * In Ardour, these are user-created sends that connect to user-created
+ * Aux busses.
+ */
+ boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
+ boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
+ /* for the same value of @param n, this returns the name of the send
+ * associated with the pair of controllables returned by the above two methods.
+ */
+ std::string send_name (uint32_t n) const;
+
+ /* well known control that enables/disables sending to the master bus.
+ *
+ * In Ardour, this returns null.
+ * In Mixbus, it will return a suitable control, or null depending on
+ * the route.
+ */
+ boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
+
+ void protect_automation ();
enum {
/* These numbers are taken from MIDI Machine Control,
void set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
uint32_t remote_control_id () const;
- void set_remote_control_id_explicit (uint32_t order_key);
+ void set_remote_control_id_explicit (uint32_t order_key);
/* for things concerned about *this* route's RID */
bool has_external_redirects() const;
- /* can only be executed by a route for which is_monitor() is true
- (i.e. the monitor out)
- */
- void monitor_run (framepos_t start_frame, framepos_t end_frame,
- pframes_t nframes, int declick);
+ /* can only be executed by a route for which is_monitor() is true
+ * (i.e. the monitor out)
+ */
+ void monitor_run (framepos_t start_frame, framepos_t end_frame,
+ pframes_t nframes, int declick);
- protected:
+protected:
friend class Session;
void catch_up_on_solo_mute_override ();
void curve_reallocate ();
virtual void set_block_size (pframes_t nframes);
- protected:
+protected:
virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
- void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
+ void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
- void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
+ void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
pframes_t nframes, int declick);
virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
boost::shared_ptr<MuteControllable> _mute_control;
boost::shared_ptr<MuteMaster> _mute_master;
boost::shared_ptr<PhaseControllable> _phase_control;
+ boost::shared_ptr<SoloIsolateControllable> _solo_isolate_control;
+ boost::shared_ptr<SoloSafeControllable> _solo_safe_control;
virtual void act_on_mute () {}
DataType _default_type;
FedBy _fed_by;
- InstrumentInfo _instrument_info;
+ InstrumentInfo _instrument_info;
virtual ChanCount input_streams () const;
- protected:
+protected:
virtual XMLNode& state(bool);
int configure_processors (ProcessorStreams*);
boost::shared_ptr<Processor> the_instrument_unlocked() const;
- private:
+private:
int set_state_2X (const XMLNode&, int);
void set_processor_state_2X (XMLNodeList const &, int);
uint32_t _order_key;
bool _has_order_key;
- uint32_t _remote_control_id;
+ uint32_t _remote_control_id;
int64_t _track_number;
void input_change_handler (IOChange, void *src);
void output_change_handler (IOChange, void *src);
+ void sidechain_change_handler (IOChange, void *src);
+
+ void processor_selfdestruct (boost::weak_ptr<Processor>);
+ std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
+ Glib::Threads::Mutex selfdestruct_lock;
bool input_port_count_changing (ChanCount);
bool output_port_count_changing (ChanCount);
bool _in_configure_processors;
bool _initial_io_setup;
+ bool _in_sidechain_setup;
- int configure_processors_unlocked (ProcessorStreams*);
+ int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
bool set_meter_point_unlocked ();
void apply_processor_order (const ProcessorList& new_order);
friend class ProcessorState;
+ bool _strict_io;
+
/* no copy construction */
Route (Route const &);
or 0.
*/
boost::weak_ptr<Processor> _processor_after_last_custom_meter;
+ RoutePinWindowProxy *_pinmgr_proxy;
- void reset_instrument_info ();
+ void reset_instrument_info ();
- void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
+ void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
};
} // namespace ARDOUR