#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"
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(); }
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; }
/* 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;
*/
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
*/
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,
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 () {}
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 &);
projects / ardour.git / blobdiff