#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
-#include <boost/dynamic_bitset.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <glibmm/threads.h>
#include "ardour/io_vector.h"
#include "ardour/libardour_visibility.h"
#include "ardour/types.h"
+#include "ardour/monitorable.h"
+#include "ardour/muteable.h"
#include "ardour/mute_master.h"
+#include "ardour/mute_control.h"
#include "ardour/route_group_member.h"
#include "ardour/stripable.h"
#include "ardour/graphnode.h"
#include "ardour/automatable.h"
#include "ardour/unknown_processor.h"
+#include "ardour/soloable.h"
+#include "ardour/solo_control.h"
+#include "ardour/solo_safe_control.h"
+#include "ardour/slavable.h"
class RoutePinWindowProxy;
class CapturingProcessor;
class InternalSend;
class VCA;
-
-class LIBARDOUR_API Route : public Stripable, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
+class SoloIsolateControl;
+class PhaseControl;
+class MonitorControl;
+
+class LIBARDOUR_API Route : public Stripable,
+ public GraphNode,
+ public Soloable,
+ public Muteable,
+ public Monitorable,
+ public Automatable,
+ public RouteGroupMember,
+ public boost::enable_shared_from_this<Route>
{
public:
typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
- enum Flag {
- Auditioner = 0x1,
- MasterOut = 0x2,
- MonitorOut = 0x4
- };
-
- Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
+ Route (Session&, std::string name, PresentationInfo::Flag flags = PresentationInfo::Flag(0), DataType default_type = DataType::AUDIO);
virtual ~Route();
virtual int init ();
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;
- void set_order_key (uint32_t);
-
- bool is_auditioner() const { return _flags & Auditioner; }
- bool is_master() const { return _flags & MasterOut; }
- bool is_monitor() const { return _flags & MonitorOut; }
-
- virtual MonitorState monitoring_state () const;
+ MonitorState monitoring_state () const;
virtual MeterState metering_state () const;
/* these are the core of the API of a Route. see the protected sections as well */
virtual bool can_record() { return false; }
- virtual void set_record_enabled (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {}
- virtual bool record_enabled() const { return false; }
- 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 () {}
virtual void realtime_locate () {}
void shift (framepos_t, framecnt_t);
- void set_gain (gain_t val, PBD::Controllable::GroupControlDisposition);
- void inc_gain (gain_t delta);
-
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, PBD::Controllable::GroupControlDisposition);
-
- bool muted_by_others_soloing () const;
- bool muted_by_others () const;
-
/* controls use set_solo() to modify this route's solo state
*/
- void set_solo (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
- bool soloed () const { return self_soloed () || soloed_by_others (); }
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, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
- bool solo_isolated() const;
-
- void set_solo_safe (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
- bool solo_safe() const;
+ bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
+ bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
+ bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
+ bool self_soloed () const { return _solo_control->self_soloed(); }
+ bool soloed () const { return self_soloed () || soloed_by_others (); }
- void set_listen (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
- bool listening_via_monitor () const;
+ void push_solo_upstream (int32_t delta);
+ void push_solo_isolate_upstream (int32_t delta);
+ bool can_solo () const {
+ return !(is_master() || is_monitor() || is_auditioner());
+ }
+ bool is_safe () const {
+ return _solo_safe_control->get_value();
+ }
void enable_monitor_send ();
- void set_phase_invert (uint32_t, bool yn);
- void set_phase_invert (boost::dynamic_bitset<>);
- bool phase_invert (uint32_t) const;
- boost::dynamic_bitset<> phase_invert () const;
-
void set_denormal_protection (bool yn);
bool denormal_protection() const;
PBD::Signal0<void> active_changed;
PBD::Signal0<void> denormal_protection_changed;
PBD::Signal0<void> comment_changed;
- PBD::Signal0<void> mute_points_changed;
/** track numbers - assigned by session
* nubers > 0 indicate tracks (audio+midi)
/** the processors have changed; the parameter indicates what changed */
PBD::Signal1<void,RouteProcessorChange> processors_changed;
PBD::Signal1<void,void*> record_enable_changed;
+ PBD::Signal0<void> processor_latency_changed;
/** the metering point has changed */
PBD::Signal0<void> meter_change;
PBD::Signal0<void> signal_latency_changed;
/** Emitted with the process lock held */
PBD::Signal0<void> io_changed;
- /* gui's call this for their own purposes. */
-
- PBD::Signal2<void,std::string,void*> gui_changed;
-
/* stateful */
XMLNode& get_state();
boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
- class RouteAutomationControl : public AutomationControl {
- public:
- RouteAutomationControl (const std::string& name,
- AutomationType atype,
- boost::shared_ptr<AutomationList> alist,
- boost::shared_ptr<Route> route);
- protected:
- friend class Route;
-
- void route_set_value (double val) {
- AutomationControl::set_value (val, Controllable::NoGroup);
- }
-
- boost::weak_ptr<Route> _route;
- };
-
- class BooleanRouteAutomationControl : public RouteAutomationControl {
- public:
- BooleanRouteAutomationControl (const std::string& name,
- AutomationType atype,
- boost::shared_ptr<AutomationList> alist,
- boost::shared_ptr<Route> route)
- : RouteAutomationControl (name, atype, alist, route) {}
- protected:
- double get_masters_value_locked() const;
-
- };
-
- class GainControllable : public GainControl {
- public:
- GainControllable (Session& session,
- AutomationType type,
- boost::shared_ptr<Route> 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);
- }
- }
-
- protected:
- friend class Route;
-
- void route_set_value (double val) {
- GainControl::set_value (val, Controllable::NoGroup);
- }
-
- boost::weak_ptr<Route> _route;
- };
-
- class SoloControllable : public BooleanRouteAutomationControl {
- public:
- SoloControllable (std::string name, boost::shared_ptr<Route>);
- void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
- void set_value_unchecked (double);
- double get_value () const;
-
- /* Export additional API so that objects that only get access
- * to a Controllable/AutomationControl can do more fine-grained
- * operations with respect to solo. Obviously, they would need
- * to dynamic_cast<Route::SoloControllable> first.
- *
- * Solo state is not representable by a single scalar value,
- * so this AutomationControl maps set_value() and get_value()
- * to r->set_self_solo() and r->soloed() respectively. This
- * means that the Controllable is technically asymmetric. It is
- * possible to call ::set_value (0.0) to disable (self)solo,
- * and then call ::get_value() and get a return of 1.0 because
- * the Route owner is soloed by upstream/downstream.
- */
-
- void set_self_solo (bool yn) {
- boost::shared_ptr<Route> r(_route.lock()); if (r) r->set_self_solo (yn);
- }
- void mod_solo_by_others_upstream (int32_t delta) {
- boost::shared_ptr<Route> r(_route.lock()); if (r) r->mod_solo_by_others_upstream (delta);
- }
- void mod_solo_by_others_downstream (int32_t delta) {
- boost::shared_ptr<Route> r(_route.lock()); if (r) r->mod_solo_by_others_downstream (delta);
- }
- bool soloed_by_others () const {
- boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others(); else return false;
- }
- bool soloed_by_others_upstream () const {
- boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others_upstream(); else return false;
- }
- bool soloed_by_others_downstream () const {
- boost::shared_ptr<Route> r(_route.lock()); if (r) return r->soloed_by_others_downstream(); else return false;
- }
- bool self_soloed () const {
- boost::shared_ptr<Route> r(_route.lock()); if (r) return r->self_soloed(); else return false;
- }
-
- protected:
- void master_changed (bool, PBD::Controllable::GroupControlDisposition);
-
- private:
- void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
- };
-
- struct MuteControllable : public BooleanRouteAutomationControl {
- public:
- MuteControllable (std::string name, boost::shared_ptr<Route>);
- 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. */
- void set_superficial_value(bool muted);
- protected:
- void master_changed (bool, PBD::Controllable::GroupControlDisposition);
-
- private:
- boost::weak_ptr<Route> _route;
- void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
- };
-
- class LIBARDOUR_API PhaseControllable : public BooleanRouteAutomationControl {
- public:
- PhaseControllable (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() */
- 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 BooleanRouteAutomationControl {
- 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 BooleanRouteAutomationControl {
- 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<AutomationControl> solo_control() const {
+ boost::shared_ptr<SoloControl> solo_control() const {
return _solo_control;
}
- boost::shared_ptr<AutomationControl> mute_control() const {
+ boost::shared_ptr<MuteControl> mute_control() const {
return _mute_control;
}
- boost::shared_ptr<MuteMaster> mute_master() const {
- return _mute_master;
- }
+ bool can_be_muted_by_others () const { return !is_master(); }
+ bool muted () const { return _mute_control->muted(); }
+ bool muted_by_masters () const { return _mute_control->muted_by_masters(); }
+ bool muted_by_self () const { return _mute_control->muted_by_self(); }
+ bool muted_by_others_soloing () const;
- boost::shared_ptr<AutomationControl> solo_isolate_control() const {
+ boost::shared_ptr<SoloIsolateControl> solo_isolate_control() const {
return _solo_isolate_control;
}
- boost::shared_ptr<AutomationControl> solo_safe_control() const {
+ boost::shared_ptr<SoloSafeControl> solo_safe_control() const {
return _solo_safe_control;
}
- boost::shared_ptr<AutomationControl> monitoring_control() const {
+ boost::shared_ptr<MonitorControl> monitoring_control() const {
/* tracks override this to provide actual monitoring control;
busses have no possible choices except input monitoring.
*/
- return boost::shared_ptr<AutomationControl> ();
+ return boost::shared_ptr<MonitorControl> ();
}
/* 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> gain_control() const;
- boost::shared_ptr<AutomationControl> trim_control() const;
- boost::shared_ptr<AutomationControl> phase_control() const;
+ boost::shared_ptr<GainControl> trim_control() const;
+ boost::shared_ptr<PhaseControl> phase_control() const;
/**
Return the first processor that accepts has at least one MIDI input
void protect_automation ();
- enum {
- /* These numbers are taken from MIDI Machine Control,
- which can only control up to 317 tracks without
- doing sysex segmentation.
- */
- MasterBusRemoteControlID = 318,
- MonitorBusRemoteControlID = 319,
- };
-
- 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);
-
- /* for things concerned about *this* route's RID */
-
- PBD::Signal0<void> RemoteControlIDChanged;
-
- /* for things concerned about *any* route's RID changes */
-
- static PBD::Signal0<void> RemoteControlIDChange;
- static PBD::Signal0<void> SyncOrderKeys;
-
bool has_external_redirects() const;
/* can only be executed by a route for which is_monitor() is true
pframes_t nframes, int declick);
bool slaved_to (boost::shared_ptr<VCA>) const;
- void vca_assign (boost::shared_ptr<VCA>);
- void vca_unassign (boost::shared_ptr<VCA>);
+ bool slaved () const;
protected:
friend class Session;
void catch_up_on_solo_mute_override ();
- void mod_solo_by_others_upstream (int32_t);
- void mod_solo_by_others_downstream (int32_t);
+ void set_listen (bool);
+
void curve_reallocate ();
virtual void set_block_size (pframes_t nframes);
-protected:
- virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
+ 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);
gint _pending_process_reorder; // atomic
gint _pending_signals; // atomic
- Flag _flags;
int _pending_declick;
MeterPoint _meter_point;
MeterPoint _pending_meter_point;
MeterType _meter_type;
- boost::dynamic_bitset<> _phase_invert;
- bool _self_solo;
- uint32_t _soloed_by_others_upstream;
- uint32_t _soloed_by_others_downstream;
- bool _solo_isolated;
- uint32_t _solo_isolated_by_upstream;
-
- void mod_solo_isolated_by_upstream (bool);
bool _denormal_protection;
bool _silent : 1;
bool _declickable : 1;
- boost::shared_ptr<SoloControllable> _solo_control;
- 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 () {}
+ boost::shared_ptr<SoloControl> _solo_control;
+ boost::shared_ptr<MuteControl> _mute_control;
+ boost::shared_ptr<PhaseControl> _phase_control;
+ boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
+ boost::shared_ptr<SoloSafeControl> _solo_safe_control;
std::string _comment;
bool _have_internal_generator;
- bool _solo_safe;
DataType _default_type;
FedBy _fed_by;
virtual void maybe_declick (BufferSet&, framecnt_t, int);
- boost::shared_ptr<GainControllable> _gain_control;
+ boost::shared_ptr<GainControl> _gain_control;
boost::shared_ptr<Amp> _amp;
- boost::shared_ptr<GainControllable> _trim_control;
+ boost::shared_ptr<GainControl> _trim_control;
boost::shared_ptr<Amp> _trim;
boost::shared_ptr<PeakMeter> _meter;
boost::shared_ptr<DelayLine> _delayline;
boost::shared_ptr<Processor> the_instrument_unlocked() const;
-private:
+ private:
+ int64_t _track_number;
+
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;
-
- 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 placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
void set_self_solo (bool yn);
- void set_mute_master_solo ();
void set_processor_positions ();
framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
void reset_instrument_info ();
- void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
+ void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
};
} // namespace ARDOUR
projects / ardour.git / blobdiff