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 () {}
void set_gain (gain_t val, PBD::Controllable::GroupControlDisposition);
void inc_gain (gain_t delta);
- void set_trim (gain_t val, 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, bool group_override = false);
+ 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_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, bool group_override = false);
+ void set_listen (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
bool listening_via_monitor () const;
void enable_monitor_send ();
boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
- boost::shared_ptr<Processor> nth_plugin (uint32_t n);
- boost::shared_ptr<Processor> nth_send (uint32_t n);
+ boost::shared_ptr<Processor> nth_plugin (uint32_t n) const;
+ boost::shared_ptr<Processor> nth_send (uint32_t n) const;
bool has_io_processor_named (const std::string&);
ChanCount max_processor_streams () const { return processor_max_streams; }
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);
+ int replace_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, 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);
+
framecnt_t set_private_port_latencies (bool playback) const;
void set_public_port_latencies (framecnt_t, bool playback) const;
PBD::Signal0<void> active_changed;
PBD::Signal0<void> phase_invert_changed;
PBD::Signal0<void> denormal_protection_changed;
- PBD::Signal2<void,void*,bool> listen_changed;
- PBD::Signal3<void,bool,void*,bool> solo_changed;
- PBD::Signal1<void,void*> solo_safe_changed;
- PBD::Signal1<void,void*> solo_isolated_changed;
- PBD::Signal1<void,void*> comment_changed;
- PBD::Signal1<void,void*> mute_changed;
+ PBD::Signal1<void,PBD::Controllable::GroupControlDisposition> listen_changed;
+ PBD::Signal2<void,bool,PBD::Controllable::GroupControlDisposition> solo_changed;
+ PBD::Signal0<void> solo_safe_changed;
+ PBD::Signal0<void> solo_isolated_changed;
+ PBD::Signal0<void> comment_changed;
+ PBD::Signal0<void> mute_changed;
PBD::Signal0<void> mute_points_changed;
/** track numbers - assigned by session
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);
void set_value_unchecked (double);
double get_value () const;
+ private:
+ void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
};
struct MuteControllable : public RouteAutomationControl {
private:
boost::weak_ptr<Route> _route;
+ void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
};
class LIBARDOUR_API PhaseControllable : public RouteAutomationControl {
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 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);
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<Panner> panner() const; /* may return null */
boost::shared_ptr<PannerShell> panner_shell() const;
- boost::shared_ptr<AutomationControl> gain_control() const;
+ boost::shared_ptr<GainControl> gain_control() const;
boost::shared_ptr<Pannable> pannable() const;
- boost::shared_ptr<AutomationControl> trim_control() 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
*/
std::string comp_speed_name (uint32_t mode) const;
- void protect_automation ();
+ /* "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,
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;
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 () {}
friend class ProcessorState;
+ bool _strict_io;
+
/* no copy construction */
Route (Route const &);
projects / ardour.git / blobdiff