35 #include <glibmm/threads.h>
81 class PolarityProcessor;
90 class MonitorProcessor;
92 class CapturingProcessor;
95 class SoloIsolateControl;
122 return _default_type;
125 std::shared_ptr<IO>
input()
const {
return _input; }
126 std::shared_ptr<IO>
output()
const {
return _output; }
145 std::shared_ptr<SurroundSend>
surround_send()
const {
return _surround_send; }
183 bool self_soloed ()
const {
return _solo_control->self_soloed(); }
184 bool soloed ()
const {
return self_soloed () || soloed_by_others (); }
189 return !(is_singleton() || is_auditioner() || is_foldbackbus());
192 return _solo_safe_control->get_value();
195 return can_solo() || is_foldbackbus ();
221 std::shared_ptr<Amp>
amp()
const {
return _amp; }
222 std::shared_ptr<Amp>
trim()
const {
return _trim; }
223 std::shared_ptr<PolarityProcessor>
polarity()
const {
return _polarity; }
225 std::shared_ptr<const PeakMeter>
peak_meter()
const {
return _meter; }
227 std::shared_ptr<TriggerBox>
triggerbox()
const {
return _triggerbox; }
232 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
233 for (ProcessorList::const_iterator i = _processors.begin(); i != _processors.end(); ++i) {
234 method (std::weak_ptr<Processor> (*i));
239 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
240 ProcessorList::iterator i;
241 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
242 if (i == _processors.end()) {
243 return std::shared_ptr<Processor> ();
252 std::shared_ptr<Processor>
nth_send (uint32_t n)
const;
270 _pending_surround_send.store (1);
275 std::shared_ptr<InternalSend>
monitor_send()
const {
return _monitor_send; }
277 std::shared_ptr<Delivery>
main_outs()
const {
return _main_outs; }
279 std::shared_ptr<MonitorProcessor>
monitor_control()
const {
return _monitor_control; }
364 bool add_sidechain (std::shared_ptr<Processor> proc) {
return add_remove_sidechain (proc,
true); }
369 bool remove_sidechain (std::shared_ptr<Processor> proc) {
return add_remove_sidechain (proc,
false); }
395 if (tn == _track_number) {
return; }
397 track_number_changed();
468 bool feeds (std::shared_ptr<Route>);
486 return _solo_control;
490 return _mute_control;
494 bool muted ()
const {
return _mute_control->muted(); }
500 return _solo_isolate_control;
504 return _solo_safe_control;
524 return _volume_applies_to_output;
598 bool gain_automation_ok,
599 bool run_disk_processors);
605 std::shared_ptr<Processor> endpoint,
bool include_endpoint,
606 bool for_export,
bool for_freeze);
631 std::shared_ptr<BeatBox> _beatbox;
641 EmitMeterChanged = 0x01,
642 EmitMeterVisibilityChange = 0x02,
643 EmitRtProcessorChange = 0x04,
644 EmitSendReturnChange = 0x08
766 , _processors (r->_processors)
767 , _processor_max_streams (r->processor_max_streams)
771 _route->_processors = _processors;
772 _route->processor_max_streams = _processor_max_streams;
798 std::map<WellKnownCtrl, std::vector<std::weak_ptr<AutomationControl>>>
_well_known_map;
ProcessorList _processors
ChanCount _processor_max_streams
std::shared_ptr< AutomationControl > send_level_controllable(uint32_t n, bool locked=false) const
static PBD::Signal< void(std::weak_ptr< Route >)> FanOut
bool reset_plugin_insert(std::shared_ptr< Processor > proc)
static PBD::Signal< int(std::shared_ptr< Route >, std::shared_ptr< PluginInsert >, PluginSetupOptions)> PluginSetup
void sidechain_change_handler(IOChange, void *src)
std::shared_ptr< AutomationControl > pan_lfe_control() const
void add_well_known_ctrl(WellKnownCtrl)
int set_state_2X(const XMLNode &, int)
std::shared_ptr< CapturingProcessor > _capturing_processor
std::shared_ptr< IO > _input
int replace_processor(std::shared_ptr< Processor > old, std::shared_ptr< Processor > sub, ProcessorStreams *err=0)
PBD::Signal< void()> io_changed
void clear_processors(Placement)
std::shared_ptr< MonitorControl > monitoring_control() const
void process_output_buffers(BufferSet &bufs, samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, bool gain_automation_ok, bool run_disk_processors)
std::shared_ptr< IO > input() const
bool output_port_count_changing(ChanCount)
void shift(timepos_t const &, timecnt_t const &)
void push_solo_upstream(int32_t delta)
std::map< Route *, bool > _connection_cache
bool add_sidechain(std::shared_ptr< Processor > proc)
bool _volume_applies_to_output
std::list< std::string > unknown_processors() const
XMLNode & get_processor_state()
int remove_processor(std::shared_ptr< Processor > proc, ProcessorStreams *err=0, bool need_process_lock=true)
virtual void write_out_of_band_data(BufferSet &, samplecnt_t) const
samplecnt_t playback_latency(bool incl_downstream=false) const
PBD::Signal< void()> track_number_changed
void reset_instrument_info()
void set_pingmgr_proxy(RoutePinWindowProxy *wp)
void set_processor_state(const XMLNode &, int version)
void move_instrument_down(bool postfader=false)
int remove_processors(const ProcessorList &, ProcessorStreams *err=0)
samplecnt_t update_signal_latency(bool apply_to_delayline=false, bool *delayline_update_needed=NULL)
bool processors_reorder_needs_configure(const ProcessorList &new_order)
std::shared_ptr< TriggerBox > triggerbox() const
bool muted_by_others_soloing() const
std::shared_ptr< InternalSend > _monitor_send
virtual bool set_processor_state(XMLNode const &node, int version, XMLProperty const *prop, ProcessorList &new_order, bool &must_configure)
ChanCount n_inputs() const
std::shared_ptr< Amp > _trim
std::shared_ptr< MonitorControl > _monitoring_control
void set_disk_io_point(DiskIOPoint)
int add_processor_by_index(std::shared_ptr< Processor >, int, ProcessorStreams *err=0, bool activation_allowed=true)
PBD::Signal< void()> processor_latency_changed
std::shared_ptr< SoloControl > _solo_control
std::shared_ptr< SoloSafeControl > solo_safe_control() const
std::shared_ptr< AutomationControl > pan_width_control() const
void remove_send_from_internal_return(InternalSend *)
void add_send_to_internal_return(InternalSend *)
bool instrument_fanned_out() const
SlavableAutomationControlList slavables() const
std::weak_ptr< Route > weakroute()
void maybe_note_meter_position()
virtual void non_realtime_locate(samplepos_t)
virtual bool declick_in_progress() const
std::shared_ptr< AutomationControl > pan_elevation_control() const
int64_t track_number() const
std::shared_ptr< GainControl > volume_control() const
PBD::Signal< void()> denormal_protection_changed
bool set_meter_point_unlocked()
bool has_io_processor_named(const std::string &)
ChanCount n_process_buffers()
void set_denormal_protection(bool yn)
std::atomic< int > _pending_listen_change
ChanCount processor_out_streams
std::string eq_band_name(uint32_t) const
std::shared_ptr< InternalReturn > internal_return() const
std::shared_ptr< PolarityProcessor > polarity() const
samplecnt_t set_private_port_latencies(bool playback) const
InstrumentInfo _instrument_info
samplecnt_t update_port_latencies(PortSet &ports, PortSet &feeders, bool playback, samplecnt_t) const
samplecnt_t _output_latency
bool can_be_muted_by_others() const
virtual XMLNode & state(bool save_template) const
void disable_plugins(Placement)
std::shared_ptr< MuteControl > _mute_control
std::shared_ptr< Processor > the_instrument_unlocked() const
std::shared_ptr< PeakMeter > _meter
bool _instrument_fanned_out
int add_processors(const ProcessorList &, std::shared_ptr< Processor >, ProcessorStreams *err=0)
void enable_surround_send()
std::shared_ptr< SurroundSend > _surround_send
std::shared_ptr< SoloIsolateControl > solo_isolate_control() const
void listen_position_changed()
ChanCount max_processor_streams() const
pframes_t latency_preroll(pframes_t nframes, samplepos_t &start_sample, samplepos_t &end_sample)
void all_visible_processors_active(bool)
bool _have_internal_generator
std::shared_ptr< Processor > nth_processor(uint32_t n)
std::vector< std::weak_ptr< Processor > > selfdestruct_sequence
bool _custom_meter_position_noted
std::atomic< int > _pending_process_reorder
void non_realtime_transport_stop(samplepos_t now, bool flush)
void processor_selfdestruct(std::weak_ptr< Processor >)
std::weak_ptr< Processor > _processor_after_last_custom_meter
void automatables(PBD::ControllableSet &) const
virtual int no_roll_unlocked(pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing)
void add_internal_return()
int save_as_template(const std::string &path, const std::string &name, const std::string &description)
int roll(pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool &need_butler)
bool direct_feeds_according_to_reality(std::shared_ptr< GraphNode >, bool *via_send_only=0)
IOVector all_inputs() const
std::shared_ptr< MonitorProcessor > _monitor_control
ProcessorList _pending_processor_order
void setup_invisible_processors()
std::shared_ptr< Pannable > _pannable
std::shared_ptr< Processor > before_processor_for_placement(Placement)
std::shared_ptr< IO > output() const
std::atomic< int > _pending_signals
std::shared_ptr< AutomationControl > automation_control_recurse(PBD::ID const &id) const
void run_route(samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, bool gain_automation_ok, bool run_disk_reader)
void ab_plugins(bool forward)
std::shared_ptr< GainControl > trim_control() const
bool volume_applies_to_output() const
int reorder_processors(const ProcessorList &new_order, ProcessorStreams *err=0)
void emit_pending_signals()
std::shared_ptr< SoloIsolateControl > _solo_isolate_control
DataType data_type() const
virtual void bounce_process(BufferSet &bufs, samplepos_t start_sample, samplecnt_t nframes, std::shared_ptr< Processor > endpoint, bool include_endpoint, bool for_export, bool for_freeze)
void flush_processor_buffers_locked(samplecnt_t nframes)
std::shared_ptr< PannerShell > panner_shell() const
std::shared_ptr< PolarityProcessor > _polarity
void set_active(bool yn, void *)
void input_change_handler(IOChange, void *src)
bool customize_plugin_insert(std::shared_ptr< Processor > proc, uint32_t count, ChanCount outs, ChanCount sinks)
PBD::Signal< void()> comment_changed
std::shared_ptr< AutomationControl > send_pan_azimuth_controllable(uint32_t n) const
void queue_surround_processors_changed()
std::shared_ptr< MonitorProcessor > monitor_control() const
samplecnt_t _signal_latency
std::shared_ptr< AutomationControl > send_pan_azimuth_enable_controllable(uint32_t n) const
std::shared_ptr< AutomationControl > send_enable_controllable(uint32_t n) const
virtual ChanCount input_streams() const
std::list< std::pair< ChanCount, ChanCount > > try_configure_processors_unlocked(ChanCount, ProcessorStreams *)
void set_meter_type(MeterType t)
bool denormal_protection() const
std::shared_ptr< Processor > nth_send(uint32_t n) const
MonitorState monitoring_state() const
int add_foldback_send(std::shared_ptr< Route >, bool post_fader)
std::shared_ptr< AutomationControl > master_send_enable_controllable() const
std::shared_ptr< SurroundReturn > surround_return() const
InstrumentInfo & instrument_info()
int configure_processors(ProcessorStreams *)
std::shared_ptr< Pannable > pannable() const
void apply_latency_compensation()
virtual MonitorState get_input_monitoring_state(bool recording, bool talkback) const
void enable_monitor_send()
std::list< std::shared_ptr< Processor > > ProcessorList
std::shared_ptr< MuteControl > mute_control() const
bool direct_feeds_according_to_graph(std::shared_ptr< Route >, bool *via_send_only=0)
std::shared_ptr< SoloControl > solo_control() const
MeterPoint meter_point() const
std::shared_ptr< IO > _output
void update_send_delaylines()
virtual void filter_input(BufferSet &)
std::list< std::pair< ChanCount, ChanCount > > try_configure_processors(ChanCount, ProcessorStreams *)
std::shared_ptr< AutomationControl > get_control(const Evoral::Parameter ¶m)
virtual void update_controls(BufferSet const &)
void set_volume_applies_to_output(bool)
void silence_unlocked(pframes_t)
std::string send_name(uint32_t n) const
std::shared_ptr< DelayLine > _delayline
void apply_processor_order(const ProcessorList &new_order)
std::shared_ptr< PhaseControl > _phase_control
void set_meter_point(MeterPoint)
void set_loop(ARDOUR::Location *)
IOVector all_outputs() const
ChanCount processor_max_streams
void push_solo_isolate_upstream(int32_t delta)
std::shared_ptr< GainControl > _gain_control
std::map< WellKnownCtrl, std::vector< std::weak_ptr< AutomationControl > > > _well_known_map
virtual bool can_record()
std::shared_ptr< InternalReturn > _intreturn
uint32_t eq_band_cnt() const
void remove_monitor_send()
int add_processor(std::shared_ptr< Processor >, Placement placement, ProcessorStreams *err=0, bool activation_allowed=true)
void disable_processors(Placement)
void set_processor_state_2X(XMLNodeList const &, int)
virtual void set_block_size(pframes_t nframes)
std::shared_ptr< SurroundSend > surround_send() const
virtual void snapshot_out_of_band_data(samplecnt_t)
void set_patch_selector_dialog(PatchChangeGridDialog *d)
void set_comment(std::string str, void *src)
PBD::Signal< void(RouteProcessorChange)> processors_changed
std::shared_ptr< const PeakMeter > peak_meter() const
std::shared_ptr< Send > internal_send_for(std::shared_ptr< const Route > target) const
bool muted_by_self() const
void set_plugin_state_dir(std::weak_ptr< Processor >, const std::string &)
Route(Session &, std::string name, PresentationInfo::Flag flags=PresentationInfo::Flag(0), DataType default_type=DataType::AUDIO)
std::shared_ptr< SurroundReturn > _surround_return
std::shared_ptr< GainControl > _volume_control
void disable_processors()
bool add_processor_from_xml_2X(const XMLNode &, int)
Glib::Threads::RWLock _processor_lock
PBD::Signal< void()> meter_change
RoutePinWindowProxy * _pinmgr_proxy
std::shared_ptr< AutomationControl > pan_azimuth_control() const
bool feeds(std::shared_ptr< Route >)
std::shared_ptr< Delivery > _main_outs
void monitor_run(samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes)
std::shared_ptr< GainControl > gain_control() const
PatchChangeGridDialog * _patch_selector_dialog
void cut_copy_section(timepos_t const &start, timepos_t const &end, timepos_t const &to, SectionOperation const op)
bool remove_sidechain(std::shared_ptr< Processor > proc)
Location * _loop_location
std::shared_ptr< Amp > trim() const
void fill_buffers_with_input(BufferSet &bufs, std::shared_ptr< IO > io, pframes_t nframes)
void set_track_number(int64_t tn)
std::shared_ptr< Panner > panner() const
void clear_all_solo_state()
virtual int set_state(const XMLNode &, int version)
void output_change_handler(IOChange, void *src)
ChanCount n_outputs() const
std::shared_ptr< Processor > nth_plugin(uint32_t n) const
virtual void realtime_locate(bool)
DiskIOPoint disk_io_point() const
static void set_name_in_state(XMLNode &, const std::string &)
std::shared_ptr< Processor > the_instrument() const
bool slaved_to(std::shared_ptr< VCA >) const
samplecnt_t bounce_get_latency(std::shared_ptr< Processor > endpoint, bool include_endpoint, bool for_export, bool for_freeze) const
void set_processor_positions()
virtual void realtime_handle_transport_stopped()
void catch_up_on_solo_mute_override()
XMLNode & get_state() const
bool is_internal_processor(std::shared_ptr< Processor >) const
virtual void use_captured_sources(SourceList &srcs, CaptureInfos const &)
samplecnt_t signal_latency() const
void protect_automation()
std::shared_ptr< SoloSafeControl > _solo_safe_control
std::shared_ptr< DiskWriter > _disk_writer
MeterPoint _pending_meter_point
std::atomic< int > _pending_surround_send
bool _in_configure_processors
Glib::Threads::Mutex selfdestruct_lock
std::shared_ptr< CapturingProcessor > add_export_point()
bool soloed_by_others_downstream() const
std::set< std::shared_ptr< Route > > signal_sources(bool via_sends_only=false)
RoutePinWindowProxy * pinmgr_proxy() const
std::shared_ptr< Amp > _amp
std::shared_ptr< Amp > amp() const
bool soloed_by_others_upstream() const
bool can_freeze_processor(std::shared_ptr< Processor >, bool allow_routing=false) const
ChanCount bounce_get_output_streams(ChanCount &cc, std::shared_ptr< Processor > endpoint, bool include_endpoint, bool for_export, bool for_freeze) const
std::shared_ptr< Processor > processor_by_id(PBD::ID) const
bool output_effectively_connected() const
std::shared_ptr< DiskReader > _disk_reader
std::shared_ptr< ReadOnlyControl > mapped_output(enum WellKnownData) const
bool plugin_preset_output(std::shared_ptr< Processor > proc, ChanCount outs)
void add_well_known_ctrl(WellKnownCtrl, std::shared_ptr< PluginInsert >, int param)
bool apply_processor_changes_rt()
std::shared_ptr< InternalSend > monitor_send() const
int add_processor(std::shared_ptr< Processor >, std::shared_ptr< Processor >, ProcessorStreams *err=0, bool activation_allowed=true)
int add_aux_send(std::shared_ptr< Route >, std::shared_ptr< Processor >)
uint32_t pans_required() const
void set_self_solo(bool yn)
std::shared_ptr< Amp > _volume
void foreach_processor(std::function< void(std::weak_ptr< Processor >)> method) const
std::shared_ptr< PhaseControl > phase_control() const
std::shared_ptr< Delivery > main_outs() const
bool has_external_redirects() const
bool input_port_count_changing(ChanCount)
PatchChangeGridDialog * patch_selector_dialog() const
std::shared_ptr< PeakMeter > peak_meter()
bool output_effectively_connected_real() const
int no_roll(pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool state_changing)
void placement_range(Placement p, ProcessorList::iterator &start, ProcessorList::iterator &end)
void stop_triggers(bool now)
void solo_control_changed(bool self, PBD::Controllable::GroupControlDisposition)
bool soloed_by_others() const
std::shared_ptr< GainControl > _trim_control
bool set_name(const std::string &str)
void set_public_port_latencies(samplecnt_t, bool playback, bool with_latcomp) const
int configure_processors_unlocked(ProcessorStreams *, Glib::Threads::RWLock::WriterLock *)
ProcessorList _processors
bool add_remove_sidechain(std::shared_ptr< Processor > proc, bool)
std::string ensure_track_or_route_name(std::string) const
PBD::Signal< void(void *)> record_enable_changed
bool _denormal_protection
DiskIOPoint _disk_io_point
std::shared_ptr< PeakMeter > shared_peak_meter() const
std::shared_ptr< AutomationControl > pan_frontback_control() const
MeterType meter_type() const
void remove_surround_send()
std::shared_ptr< Processor > before_processor_for_index(int)
PBD::Signal< void()> active_changed
std::shared_ptr< AutomationControl > mapped_control(enum WellKnownCtrl, uint32_t band=0) const
PBD::Signal< void(void *)> SelectedChanged
std::shared_ptr< TriggerBox > _triggerbox
std::string graph_node_name() const
bool muted_by_masters() const
GtkImageIconNameData name
PBD::PropertyDescriptor< std::string > name
PBD::PropertyDescriptor< timepos_t > start
PBD::PropertyDescriptor< bool > locked
std::vector< std::shared_ptr< Source > > SourceList
Temporal::samplecnt_t samplecnt_t
std::vector< CaptureInfo * > CaptureInfos
std::list< std::shared_ptr< SlavableAutomationControl > > SlavableAutomationControlList
Temporal::samplepos_t samplepos_t
std::set< std::shared_ptr< Controllable > > ControllableSet
ProcessorStreams(size_t i=0, ChanCount c=ChanCount())
uint32_t index
Index of processor where configuration failed.
ChanCount count
Input requested of processor.
std::vector< XMLNode * > XMLNodeList