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;
virtual 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 int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
bool muted () const;
void set_mute (bool yn, void* src);
-
+
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, void *src, bool group_override = false);
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; }
void set_solo_safe (bool yn, void *src);
bool solo_safe() const;
- void set_listen (bool yn, void* src);
+ void set_listen (bool yn, void* src, bool group_override = false);
bool listening_via_monitor () const;
void enable_monitor_send ();
void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
- break;
- }
method (boost::weak_ptr<Processor> (*i));
}
}
PBD::Signal0<void> active_changed;
PBD::Signal0<void> phase_invert_changed;
PBD::Signal0<void> denormal_protection_changed;
- PBD::Signal1<void,void*> listen_changed;
- PBD::Signal2<void,bool,void*> solo_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;
/* Controls (not all directly owned by the Route */
+ class RouteAutomationControl : public AutomationControl {
+ public:
+ RouteAutomationControl (const std::string& name,
+ 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 (*this, val, group_override);
+ }
+ }
+
+ protected:
+ friend class Route;
+
+ void route_set_value (double val) {
+ AutomationControl::set_value (val, Controllable::NoGroup);
+ }
+
+ boost::weak_ptr<Route> _route;
+ };
+
boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
- class SoloControllable : public AutomationControl {
+ class SoloControllable : public RouteAutomationControl {
public:
SoloControllable (std::string name, boost::shared_ptr<Route>);
- 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> _route;
};
- struct MuteControllable : public AutomationControl {
+ struct MuteControllable : public RouteAutomationControl {
public:
MuteControllable (std::string name, boost::shared_ptr<Route>);
- 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. */
boost::weak_ptr<Route> _route;
};
+ class LIBARDOUR_API PhaseControllable : public RouteAutomationControl {
+ public:
+ PhaseControllable (std::string name, boost::shared_ptr<Route>);
+ void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
+ void set_channel (uint32_t);
+ double get_value () const;
+ uint32_t channel() const;
+ private:
+ uint32_t _current_phase;
+ };
+
+ void set_control (RouteAutomationControl&, double val, PBD::Controllable::GroupControlDisposition group_override);
+
boost::shared_ptr<SoloControllable> solo_control() const {
return _solo_control;
}
return _mute_master;
}
+ boost::shared_ptr<PhaseControllable> phase_control() const {
+ return _phase_control;
+ }
+
/* 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.
boost::shared_ptr<PannerShell> panner_shell() const;
boost::shared_ptr<AutomationControl> gain_control() const;
boost::shared_ptr<Pannable> pannable() const;
+ boost::shared_ptr<AutomationControl> trim_control() const;
/**
Return the first processor that accepts has at least one MIDI input
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;
+
void protect_automation ();
- enum {
+ enum {
/* These numbers are taken from MIDI Machine Control,
which can only control up to 317 tracks without
doing sysex segmentation.
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);
bool _self_solo;
uint32_t _soloed_by_others_upstream;
uint32_t _soloed_by_others_downstream;
- uint32_t _solo_isolated;
+ bool _solo_isolated;
+ uint32_t _solo_isolated_by_upstream;
+
+ void mod_solo_isolated_by_upstream (bool, void*);
bool _denormal_protection;
boost::shared_ptr<SoloControllable> _solo_control;
boost::shared_ptr<MuteControllable> _mute_control;
boost::shared_ptr<MuteMaster> _mute_master;
+ boost::shared_ptr<PhaseControllable> _phase_control;
virtual void act_on_mute () {}
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;
void setup_invisible_processors ();
void unpan ();
+ void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
+
boost::shared_ptr<CapturingProcessor> _capturing_processor;
/** A handy class to keep processor state while we attempt a reconfiguration
Route (Route const &);
void maybe_note_meter_position ();
-
+
/** true if we've made a note of a custom meter position in these variables */
bool _custom_meter_position_noted;
/** the processor that came after the meter when it was last set to a custom position,
projects / ardour.git / blobdiff