X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Froute.h;h=bac33ae7a147f622dc39d86580e6a9eac8e27102;hb=633f2189111be18cb03fe847707b0f598e453abe;hp=d59c1e061075a3acfd7180021ab629b99c5427cc;hpb=22b07e0233a29d9633ffa825a79503befaf2e16e;p=ardour.git diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h index d59c1e0610..bac33ae7a1 100644 --- a/libs/ardour/ardour/route.h +++ b/libs/ardour/ardour/route.h @@ -41,8 +41,10 @@ #include "pbd/destructible.h" #include "ardour/ardour.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" @@ -88,6 +90,8 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr input() const { return _input; } boost::shared_ptr 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(); } @@ -101,7 +105,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou void set_comment (std::string str, void *src); bool set_name (const std::string& str); - static void set_name_in_state (XMLNode &, const std::string &); + static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true); uint32_t order_key () const; bool has_order_key () const; @@ -127,9 +131,9 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou virtual bool can_record() { return false; } - virtual void set_record_enabled (bool /*yn*/, void * /*src*/) {} + virtual void set_record_enabled (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {} virtual bool record_enabled() const { return false; } - virtual void set_record_safe (bool yn, void *src) {} + virtual void set_record_safe (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {} virtual bool record_safe () const {return false; } virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors); virtual void realtime_handle_transport_stopped () {} @@ -141,39 +145,38 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou void shift (framepos_t, framecnt_t); - void set_gain (gain_t val, void *src); - void inc_gain (gain_t delta, void *src); + void set_gain (gain_t val, PBD::Controllable::GroupControlDisposition); + void inc_gain (gain_t delta); - void set_trim (gain_t val, void *src); - void inc_trim (gain_t delta, void *src); + void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition); void set_mute_points (MuteMaster::MutePoint); MuteMaster::MutePoint mute_points () const; bool muted () const; - void set_mute (bool yn, void* src); + void set_mute (bool yn, PBD::Controllable::GroupControlDisposition); bool muted_by_others() const; /* controls use set_solo() to modify this route's solo state */ - void set_solo (bool yn, void *src); + void set_solo (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup); bool soloed () const { return self_soloed () || soloed_by_others (); } - void cancel_solo_after_disconnect (bool upstream); + void clear_all_solo_state (); bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; } bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; } bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; } bool self_soloed () const { return _self_solo; } - void set_solo_isolated (bool yn, void *src); + void set_solo_isolated (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup); bool solo_isolated() const; - void set_solo_safe (bool yn, void *src); + void set_solo_safe (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup); bool solo_safe() const; - void set_listen (bool yn, void* src); + void set_listen (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup); bool listening_via_monitor () const; void enable_monitor_send (); @@ -224,8 +227,8 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr processor_by_id (PBD::ID) const; - boost::shared_ptr nth_plugin (uint32_t n); - boost::shared_ptr nth_send (uint32_t n); + boost::shared_ptr nth_plugin (uint32_t n) const; + boost::shared_ptr nth_send (uint32_t n) const; bool has_io_processor_named (const std::string&); ChanCount max_processor_streams () const { return processor_max_streams; } @@ -235,6 +238,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou /* special processors */ boost::shared_ptr monitor_send() const { return _monitor_send; } + /** the signal processorat at end of the processing chain which produces output */ boost::shared_ptr main_outs() const { return _main_outs; } boost::shared_ptr internal_return() const { return _intreturn; } boost::shared_ptr monitor_control() const { return _monitor_control; } @@ -262,7 +266,22 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr before_processor_for_placement (Placement); boost::shared_ptr before_processor_for_index (int); bool processors_reorder_needs_configure (const ProcessorList& new_order); - int remove_processor (boost::shared_ptr, 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 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 old, boost::shared_ptr 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); @@ -273,6 +292,46 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou 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 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 proc, uint32_t count, ChanCount outs, ChanCount sinks); + bool add_remove_sidechain (boost::shared_ptr proc, bool); + bool plugin_preset_output (boost::shared_ptr 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 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 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; @@ -286,12 +345,12 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou PBD::Signal0 active_changed; PBD::Signal0 phase_invert_changed; PBD::Signal0 denormal_protection_changed; - PBD::Signal1 listen_changed; - PBD::Signal2 solo_changed; - PBD::Signal1 solo_safe_changed; - PBD::Signal1 solo_isolated_changed; - PBD::Signal1 comment_changed; - PBD::Signal1 mute_changed; + PBD::Signal1 listen_changed; + PBD::Signal2 solo_changed; + PBD::Signal0 solo_safe_changed; + PBD::Signal0 solo_isolated_changed; + PBD::Signal0 comment_changed; + PBD::Signal0 mute_changed; PBD::Signal0 mute_points_changed; /** track numbers - assigned by session @@ -360,6 +419,8 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou */ bool direct_feeds_according_to_graph (boost::shared_ptr, bool* via_send_only = 0); + bool feeds_according_to_graph (boost::shared_ptr); + struct FeedRecord { boost::weak_ptr r; bool sends_only; @@ -381,24 +442,65 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou void clear_fed_by (); bool add_fed_by (boost::shared_ptr, bool sends_only); - /* Controls (not all directly owned by the Route */ + /* Controls (not all directly owned by the Route) */ boost::shared_ptr get_control (const Evoral::Parameter& param); - class SoloControllable : public AutomationControl { + class RouteAutomationControl : public AutomationControl { + public: + RouteAutomationControl (const std::string& name, + AutomationType atype, + boost::shared_ptr alist, + boost::shared_ptr route); + protected: + friend class Route; + + void route_set_value (double val) { + AutomationControl::set_value (val, Controllable::NoGroup); + } + + boost::weak_ptr _route; + }; + + class GainControllable : public GainControl { + public: + GainControllable (Session& session, + AutomationType type, + boost::shared_ptr route); + + void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) { + boost::shared_ptr r = _route.lock(); + if (r) { + /* Route must mediate group control */ + r->set_control ((AutomationType) parameter().type(), val, group_override); + } + } + + protected: + friend class Route; + + void route_set_value (double val) { + GainControl::set_value (val, Controllable::NoGroup); + } + + boost::weak_ptr _route; + }; + + class SoloControllable : public RouteAutomationControl { public: SoloControllable (std::string name, boost::shared_ptr); - void set_value (double); + void set_value (double, PBD::Controllable::GroupControlDisposition group_override); + void set_value_unchecked (double); double get_value () const; - private: - boost::weak_ptr _route; + void _set_value (double, PBD::Controllable::GroupControlDisposition group_override); }; - struct MuteControllable : public AutomationControl { + struct MuteControllable : public RouteAutomationControl { public: MuteControllable (std::string name, boost::shared_ptr); - void set_value (double); + void set_value (double, PBD::Controllable::GroupControlDisposition group_override); + void set_value_unchecked (double); double get_value () const; /* Pretend to change value, but do not affect actual route mute. */ @@ -406,8 +508,44 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou private: boost::weak_ptr _route; + void _set_value (double, PBD::Controllable::GroupControlDisposition group_override); + }; + + class LIBARDOUR_API PhaseControllable : public RouteAutomationControl { + public: + PhaseControllable (std::string name, boost::shared_ptr); + void set_value (double, PBD::Controllable::GroupControlDisposition group_override); + /* currently no automation, so no need for set_value_unchecked() */ + void set_channel (uint32_t); + double get_value () const; + uint32_t channel() const; + private: + uint32_t _current_phase; + void _set_value (double, PBD::Controllable::GroupControlDisposition group_override); + }; + + class LIBARDOUR_API SoloIsolateControllable : public RouteAutomationControl { + public: + SoloIsolateControllable (std::string name, boost::shared_ptr); + 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); + 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 solo_control() const { return _solo_control; } @@ -420,6 +558,21 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou return _mute_master; } + boost::shared_ptr solo_isolate_control() const { + return _solo_isolate_control; + } + + boost::shared_ptr solo_safe_control() const { + return _solo_safe_control; + } + + boost::shared_ptr monitoring_control() const { + /* tracks override this to provide actual monitoring control; + busses have no possible choices except input monitoring. + */ + return boost::shared_ptr (); + } + /* Route doesn't own these items, but sub-objects that it does own have them and to make UI code a bit simpler, we provide direct access to them here. @@ -427,8 +580,11 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr panner() const; /* may return null */ boost::shared_ptr panner_shell() const; - boost::shared_ptr gain_control() const; + boost::shared_ptr gain_control() const; boost::shared_ptr pannable() const; + boost::shared_ptr trim_control() const; + + boost::shared_ptr phase_control() const; /** Return the first processor that accepts has at least one MIDI input @@ -440,7 +596,73 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr the_instrument() const; InstrumentInfo& instrument_info() { return _instrument_info; } - void protect_automation (); + /* "well-known" controls for panning. Any or all of these may return + * null. + */ + + boost::shared_ptr pan_azimuth_control() const; + boost::shared_ptr pan_elevation_control() const; + boost::shared_ptr pan_width_control() const; + boost::shared_ptr pan_frontback_control() const; + boost::shared_ptr 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 eq_gain_controllable (uint32_t band) const; + boost::shared_ptr eq_freq_controllable (uint32_t band) const; + boost::shared_ptr eq_q_controllable (uint32_t band) const; + boost::shared_ptr eq_shape_controllable (uint32_t band) const; + boost::shared_ptr eq_enable_controllable () const; + boost::shared_ptr eq_hpf_controllable () const; + + /* "well-known" controls for a compressor in this route. Any or all may + * be null. + */ + boost::shared_ptr comp_enable_controllable () const; + boost::shared_ptr comp_threshold_controllable () const; + boost::shared_ptr comp_speed_controllable () const; + boost::shared_ptr comp_mode_controllable () const; + boost::shared_ptr comp_makeup_controllable () const; + boost::shared_ptr 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 send_level_controllable (uint32_t n) const; + boost::shared_ptr 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 master_send_enable_controllable () const; + + void protect_automation (); enum { /* These numbers are taken from MIDI Machine Control, @@ -467,7 +689,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou bool has_external_redirects() const; /* can only be executed by a route for which is_monitor() is true - (i.e. the monitor out) + (i.e. the monitor out) */ void monitor_run (framepos_t start_frame, framepos_t end_frame, pframes_t nframes, int declick); @@ -546,7 +768,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou bool _solo_isolated; uint32_t _solo_isolated_by_upstream; - void mod_solo_isolated_by_upstream (bool, void*); + void mod_solo_isolated_by_upstream (bool); bool _denormal_protection; @@ -557,6 +779,9 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou boost::shared_ptr _solo_control; boost::shared_ptr _mute_control; boost::shared_ptr _mute_master; + boost::shared_ptr _phase_control; + boost::shared_ptr _solo_isolate_control; + boost::shared_ptr _solo_safe_control; virtual void act_on_mute () {} @@ -589,7 +814,9 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou virtual void maybe_declick (BufferSet&, framecnt_t, int); + boost::shared_ptr _gain_control; boost::shared_ptr _amp; + boost::shared_ptr _trim_control; boost::shared_ptr _trim; boost::shared_ptr _meter; boost::shared_ptr _delayline; @@ -600,7 +827,7 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou int set_state_2X (const XMLNode&, int); void set_processor_state_2X (XMLNodeList const &, int); - uint32_t _order_key; + uint32_t _order_key; bool _has_order_key; uint32_t _remote_control_id; @@ -608,14 +835,20 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou 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); + std::vector > 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); @@ -635,6 +868,8 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou void setup_invisible_processors (); void unpan (); + void set_plugin_state_dir (boost::weak_ptr, const std::string&); + boost::shared_ptr _capturing_processor; /** A handy class to keep processor state while we attempt a reconfiguration @@ -664,6 +899,8 @@ class LIBARDOUR_API Route : public SessionObject, public Automatable, public Rou friend class ProcessorState; + bool _strict_io; + /* no copy construction */ Route (Route const &);