2 Copyright (C) 2000-2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 #ifndef __ardour_route_h__
20 #define __ardour_route_h__
29 #include <boost/shared_ptr.hpp>
30 #include <boost/weak_ptr.hpp>
32 #include <glibmm/threads.h>
33 #include "pbd/fastlog.h"
34 #include "pbd/xml++.h"
36 #include "pbd/stateful.h"
37 #include "pbd/controllable.h"
38 #include "pbd/destructible.h"
40 #include "ardour/ardour.h"
41 #include "ardour/gain_control.h"
42 #include "ardour/instrument_info.h"
43 #include "ardour/io.h"
44 #include "ardour/io_vector.h"
45 #include "ardour/libardour_visibility.h"
46 #include "ardour/types.h"
47 #include "ardour/monitorable.h"
48 #include "ardour/muteable.h"
49 #include "ardour/mute_master.h"
50 #include "ardour/mute_control.h"
51 #include "ardour/route_group_member.h"
52 #include "ardour/stripable.h"
53 #include "ardour/graphnode.h"
54 #include "ardour/automatable.h"
55 #include "ardour/unknown_processor.h"
56 #include "ardour/soloable.h"
57 #include "ardour/solo_control.h"
58 #include "ardour/solo_safe_control.h"
59 #include "ardour/slavable.h"
61 class RoutePinWindowProxy;
62 class PatchChangeGridDialog;
81 class MonitorProcessor;
83 class CapturingProcessor;
86 class SoloIsolateControl;
90 class LIBARDOUR_API Route : public Stripable,
95 public RouteGroupMember
99 typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
101 Route (Session&, std::string name, PresentationInfo::Flag flags = PresentationInfo::Flag(0), DataType default_type = DataType::AUDIO);
106 DataType data_type () const {
107 /* XXX ultimately nice to do away with this concept, but it is
108 quite useful for coders and for users too.
110 return _default_type;
113 boost::shared_ptr<IO> input() const { return _input; }
114 boost::shared_ptr<IO> output() const { return _output; }
115 IOVector all_inputs () const;
116 IOVector all_outputs () const;
118 ChanCount n_inputs() const { return _input->n_ports(); }
119 ChanCount n_outputs() const { return _output->n_ports(); }
121 bool active() const { return _active; }
122 void set_active (bool yn, void *);
124 static std::string ensure_track_or_route_name(std::string, Session &);
126 std::string comment() { return _comment; }
127 void set_comment (std::string str, void *src);
129 bool set_name (const std::string& str);
130 static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true);
132 boost::shared_ptr<MonitorControl> monitoring_control() const { return _monitoring_control; }
134 MonitorState monitoring_state () const;
135 virtual MeterState metering_state () const;
137 /* these are the core of the API of a Route. see the protected sections as well */
139 virtual void filter_input (BufferSet &) {}
141 int roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, int declick, bool& need_butler);
143 int no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool state_changing);
145 int silent_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler);
147 virtual bool can_record() { return false; }
149 virtual void non_realtime_transport_stop (samplepos_t now, bool flush);
150 virtual void realtime_handle_transport_stopped () {}
151 virtual void realtime_locate () {}
152 virtual void non_realtime_locate (samplepos_t);
153 virtual void set_pending_declick (int);
155 /* end of vfunc-based API */
157 void shift (samplepos_t, samplecnt_t);
159 void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
161 /* controls use set_solo() to modify this route's solo state
164 void clear_all_solo_state ();
166 bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
167 bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
168 bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
169 bool self_soloed () const { return _solo_control->self_soloed(); }
170 bool soloed () const { return self_soloed () || soloed_by_others (); }
172 void push_solo_upstream (int32_t delta);
173 void push_solo_isolate_upstream (int32_t delta);
174 bool can_solo () const {
175 return !(is_master() || is_monitor() || is_auditioner());
177 bool is_safe () const {
178 return _solo_safe_control->get_value();
180 void enable_monitor_send ();
182 void set_denormal_protection (bool yn);
183 bool denormal_protection() const;
185 void set_meter_point (MeterPoint, bool force = false);
186 bool apply_processor_changes_rt ();
187 void emit_pending_signals ();
188 MeterPoint meter_point() const { return _pending_meter_point; }
190 void set_meter_type (MeterType t) { _meter_type = t; }
191 MeterType meter_type() const { return _meter_type; }
193 void set_disk_io_point (DiskIOPoint);
194 DiskIOPoint disk_io_point() const { return _disk_io_point; }
198 boost::shared_ptr<Amp> amp() const { return _amp; }
199 boost::shared_ptr<Amp> trim() const { return _trim; }
200 boost::shared_ptr<PeakMeter> peak_meter() { return _meter; }
201 boost::shared_ptr<const PeakMeter> peak_meter() const { return _meter; }
202 boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
204 void flush_processors ();
206 void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
207 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
208 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
209 method (boost::weak_ptr<Processor> (*i));
213 boost::shared_ptr<Processor> nth_processor (uint32_t n) {
214 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
215 ProcessorList::iterator i;
216 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
217 if (i == _processors.end()) {
218 return boost::shared_ptr<Processor> ();
224 boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
226 boost::shared_ptr<Processor> nth_plugin (uint32_t n) const;
227 boost::shared_ptr<Processor> nth_send (uint32_t n) const;
229 bool has_io_processor_named (const std::string&);
230 ChanCount max_processor_streams () const { return processor_max_streams; }
232 std::list<std::string> unknown_processors () const;
234 RoutePinWindowProxy * pinmgr_proxy () const { return _pinmgr_proxy; }
235 void set_pingmgr_proxy (RoutePinWindowProxy* wp) { _pinmgr_proxy = wp ; }
237 PatchChangeGridDialog* patch_selector_dialog () const { return _patch_selector_dialog; }
238 void set_patch_selector_dialog (PatchChangeGridDialog* d) { _patch_selector_dialog = d; }
240 boost::shared_ptr<AutomationControl> automation_control_recurse (PBD::ID const & id) const;
242 /* special processors */
244 boost::shared_ptr<InternalSend> monitor_send() const { return _monitor_send; }
245 /** the signal processorat at end of the processing chain which produces output */
246 boost::shared_ptr<Delivery> main_outs() const { return _main_outs; }
247 boost::shared_ptr<InternalReturn> internal_return() const { return _intreturn; }
248 boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
249 boost::shared_ptr<Send> internal_send_for (boost::shared_ptr<const Route> target) const;
250 void add_internal_return ();
251 void add_send_to_internal_return (InternalSend *);
252 void remove_send_from_internal_return (InternalSend *);
253 void listen_position_changed ();
254 boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
256 /** A record of the stream configuration at some point in the processor list.
257 * Used to return where and why an processor list configuration request failed.
259 struct ProcessorStreams {
260 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
262 uint32_t index; ///< Index of processor where configuration failed
263 ChanCount count; ///< Input requested of processor
266 int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
267 int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
268 int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
269 int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
270 boost::shared_ptr<Processor> before_processor_for_placement (Placement);
271 boost::shared_ptr<Processor> before_processor_for_index (int);
272 bool processors_reorder_needs_configure (const ProcessorList& new_order);
273 /** remove plugin/processor
275 * @param proc processor to remove
276 * @param err error report (index where removal vailed, channel-count why it failed) may be nil
277 * @param need_process_lock if locking is required (set to true, unless called from RT context with lock)
278 * @returns 0 on success
280 int remove_processor (boost::shared_ptr<Processor> proc, ProcessorStreams* err = 0, bool need_process_lock = true);
281 /** replace plugin/processor with another
283 * @param old processor to remove
284 * @param sub processor to substitute the old one with
285 * @param err error report (index where removal vailed, channel-count why it failed) may be nil
286 * @returns 0 on success
288 int replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err = 0);
289 int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
290 int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
291 void disable_processors (Placement);
292 void disable_processors ();
293 void disable_plugins (Placement);
294 void disable_plugins ();
295 void ab_plugins (bool forward);
296 void clear_processors (Placement);
297 void all_visible_processors_active (bool);
298 void move_instrument_down (bool postfader = false);
300 bool strict_io () const { return _strict_io; }
301 bool set_strict_io (bool);
302 /** reset plugin-insert configuration to default, disable customizations.
304 * This is equivalent to calling
306 * customize_plugin_insert (proc, 0, unused)
309 * @param proc Processor to reset
310 * @returns true if successful
312 bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
313 /** enable custom plugin-insert configuration
314 * @param proc Processor to customize
315 * @param count number of plugin instances to use (if zero, reset to default)
316 * @param outs output port customization
317 * @param sinks input pins for variable-I/O plugins
318 * @returns true if successful
320 bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks);
321 bool add_remove_sidechain (boost::shared_ptr<Processor> proc, bool);
322 bool plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs);
324 /* enable sidechain input for a given processor
326 * The sidechain itself is an IO port object with variable number of channels and configured independently.
327 * Adding/removing the port itself however requires reconfiguring the route and is hence
328 * not a plugin operation itself.
330 * @param proc the processor to add sidechain inputs to
331 * @returns true on success
333 bool add_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, true); }
334 /* remove sidechain input from given processor
335 * @param proc the processor to remove the sidechain input from
336 * @returns true on success
338 bool remove_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, false); }
340 samplecnt_t update_signal_latency (bool apply_to_delayline = false);
341 virtual void apply_latency_compensation ();
343 samplecnt_t set_private_port_latencies (bool playback) const;
344 void set_public_port_latencies (samplecnt_t, bool playback) const;
346 void set_user_latency (samplecnt_t);
347 samplecnt_t signal_latency() const { return _signal_latency; }
348 samplecnt_t playback_latency (bool incl_downstream = false) const;
350 PBD::Signal0<void> active_changed;
351 PBD::Signal0<void> denormal_protection_changed;
352 PBD::Signal0<void> comment_changed;
354 /** track numbers - assigned by session
355 * nubers > 0 indicate tracks (audio+midi)
356 * nubers < 0 indicate busses
357 * zero is reserved for unnumbered special busses.
359 PBD::Signal0<void> track_number_changed;
360 int64_t track_number() const { return _track_number; }
362 void set_track_number(int64_t tn) {
363 if (tn == _track_number) { return; }
365 track_number_changed();
366 PropertyChanged (ARDOUR::Properties::name);
369 enum PluginSetupOptions {
375 static PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, PluginSetupOptions > PluginSetup;
377 /** the processors have changed; the parameter indicates what changed */
378 PBD::Signal1<void,RouteProcessorChange> processors_changed;
379 PBD::Signal0<void> fan_out; // used to signal the GUI to fan-out (track-creation)
380 PBD::Signal1<void,void*> record_enable_changed;
381 PBD::Signal0<void> processor_latency_changed;
382 /** the metering point has changed */
383 PBD::Signal0<void> meter_change;
384 /** a processor's latency has changed */
385 PBD::Signal0<void> signal_latency_changed;
386 /** route has updated its latency compensation */
387 PBD::Signal0<void> signal_latency_updated;
389 /** Emitted with the process lock held */
390 PBD::Signal0<void> io_changed;
394 XMLNode& get_state();
395 virtual int set_state (const XMLNode&, int version);
396 virtual XMLNode& get_template();
398 XMLNode& get_processor_state ();
399 void set_processor_state (const XMLNode&);
400 virtual bool set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure);
402 boost::weak_ptr<Route> weakroute ();
404 int save_as_template (const std::string& path, const std::string& name, const std::string& description );
406 PBD::Signal1<void,void*> SelectedChanged;
408 int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
409 void remove_aux_or_listen (boost::shared_ptr<Route>);
412 * return true if this route feeds the first argument via at least one
413 * (arbitrarily long) signal pathway.
415 bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
418 * return true if this route feeds the first argument directly, via
419 * either its main outs or a send. This is checked by the actual
420 * connections, rather than by what the graph is currently doing.
422 bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
425 * return true if this route feeds the first argument directly, via
426 * either its main outs or a send, according to the graph that
427 * is currently being processed.
429 bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
431 bool feeds_according_to_graph (boost::shared_ptr<Route>);
434 boost::weak_ptr<Route> r;
437 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
439 , sends_only (sendsonly) {}
442 struct FeedRecordCompare {
443 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
448 typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
450 const FedBy& fed_by() const { return _fed_by; }
451 void clear_fed_by ();
452 bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
454 /* Controls (not all directly owned by the Route) */
456 boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
458 boost::shared_ptr<SoloControl> solo_control() const {
459 return _solo_control;
462 boost::shared_ptr<MuteControl> mute_control() const {
463 return _mute_control;
466 bool can_be_muted_by_others () const { return can_solo(); }
467 bool muted () const { return _mute_control->muted(); }
468 bool muted_by_masters () const { return _mute_control->muted_by_masters(); }
469 bool muted_by_self () const { return _mute_control->muted_by_self(); }
470 bool muted_by_others_soloing () const;
472 boost::shared_ptr<SoloIsolateControl> solo_isolate_control() const {
473 return _solo_isolate_control;
476 boost::shared_ptr<SoloSafeControl> solo_safe_control() const {
477 return _solo_safe_control;
480 /* Route doesn't own these items, but sub-objects that it does own have them
481 and to make UI code a bit simpler, we provide direct access to them
485 boost::shared_ptr<Panner> panner() const; /* may return null */
486 boost::shared_ptr<PannerShell> panner_shell() const;
487 boost::shared_ptr<Pannable> pannable() const;
489 boost::shared_ptr<GainControl> gain_control() const;
490 boost::shared_ptr<GainControl> trim_control() const;
491 boost::shared_ptr<PhaseControl> phase_control() const;
494 Return the first processor that accepts has at least one MIDI input
495 and at least one audio output. In the vast majority of cases, this
496 will be "the instrument". This does not preclude other MIDI->audio
497 processors later in the processing chain, but that would be a
498 special case not covered by this utility function.
500 boost::shared_ptr<Processor> the_instrument() const;
501 InstrumentInfo& instrument_info() { return _instrument_info; }
503 /* "well-known" controls for panning. Any or all of these may return
507 boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
508 boost::shared_ptr<AutomationControl> pan_elevation_control() const;
509 boost::shared_ptr<AutomationControl> pan_width_control() const;
510 boost::shared_ptr<AutomationControl> pan_frontback_control() const;
511 boost::shared_ptr<AutomationControl> pan_lfe_control() const;
513 /* "well-known" controls for an EQ in this route. Any or all may
514 * be null. eq_band_cnt() must return 0 if there is no EQ present.
515 * Passing an @param band value >= eq_band_cnt() will guarantee the
516 * return of a null ptr (or an empty string for eq_band_name()).
518 uint32_t eq_band_cnt () const;
519 std::string eq_band_name (uint32_t) const;
520 boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
521 boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
522 boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
523 boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
524 boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
526 //additional HP/LP filters
527 boost::shared_ptr<AutomationControl> filter_freq_controllable (bool hpf) const;
528 boost::shared_ptr<AutomationControl> filter_slope_controllable (bool) const;
529 boost::shared_ptr<AutomationControl> filter_enable_controllable (bool) const;
532 /* "well-known" controls for a compressor in this route. Any or all may
535 boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
536 boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
537 boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
538 boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
539 boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
540 boost::shared_ptr<ReadOnlyControl> comp_redux_controllable () const;
542 /* @param mode must be supplied by the comp_mode_controllable(). All other values
543 * result in undefined behaviour
545 std::string comp_mode_name (uint32_t mode) const;
546 /* @param mode - as for comp mode name. This returns the name for the
547 * parameter/control accessed via comp_speed_controllable(), which can
550 std::string comp_speed_name (uint32_t mode) const;
552 /* "well-known" controls for sends to well-known busses in this route. Any or all may
555 * In Mixbus, these are the sends that connect to the mixbusses.
556 * In Ardour, these are user-created sends that connect to user-created
559 boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
560 boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
561 /* for the same value of @param n, this returns the name of the send
562 * associated with the pair of controllables returned by the above two methods.
564 std::string send_name (uint32_t n) const;
566 /* well known control that enables/disables sending to the master bus.
568 * In Ardour, this returns null.
569 * In Mixbus, it will return a suitable control, or null depending on
572 boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
574 void protect_automation ();
576 bool has_external_redirects() const;
578 /* can only be executed by a route for which is_monitor() is true
579 * (i.e. the monitor out)
581 void monitor_run (samplepos_t start_sample, samplepos_t end_sample,
582 pframes_t nframes, int declick);
584 bool slaved_to (boost::shared_ptr<VCA>) const;
585 bool slaved () const;
587 virtual void use_captured_sources (SourceList& srcs, CaptureInfos const &) {}
590 friend class Session;
592 void catch_up_on_solo_mute_override ();
593 void set_listen (bool);
595 void curve_reallocate ();
596 virtual void set_block_size (pframes_t nframes);
598 virtual int no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing);
600 virtual void snapshot_out_of_band_data (samplecnt_t /* nframes */) {}
601 virtual void write_out_of_band_data (BufferSet&, samplecnt_t /* nframes */) const {}
602 virtual void update_controls (BufferSet const&) {}
604 void process_output_buffers (BufferSet& bufs,
605 samplepos_t start_sample, samplepos_t end_sample,
606 pframes_t nframes, int declick,
607 bool gain_automation_ok,
608 bool run_disk_processors);
610 void flush_processor_buffers_locked (samplecnt_t nframes);
612 virtual void bounce_process (BufferSet& bufs,
613 samplepos_t start_sample, samplecnt_t nframes,
614 boost::shared_ptr<Processor> endpoint, bool include_endpoint,
615 bool for_export, bool for_freeze);
617 samplecnt_t bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
618 ChanCount bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
621 samplecnt_t _signal_latency;
623 ProcessorList _processors;
624 mutable Glib::Threads::RWLock _processor_lock;
626 boost::shared_ptr<IO> _input;
627 boost::shared_ptr<IO> _output;
629 boost::shared_ptr<Delivery> _main_outs;
630 boost::shared_ptr<InternalSend> _monitor_send;
631 boost::shared_ptr<InternalReturn> _intreturn;
632 boost::shared_ptr<MonitorProcessor> _monitor_control;
633 boost::shared_ptr<Pannable> _pannable;
634 boost::shared_ptr<DiskReader> _disk_reader;
635 boost::shared_ptr<DiskWriter> _disk_writer;
637 boost::shared_ptr<MonitorControl> _monitoring_control;
639 DiskIOPoint _disk_io_point;
643 EmitMeterChanged = 0x01,
644 EmitMeterVisibilityChange = 0x02,
645 EmitRtProcessorChange = 0x04
648 ProcessorList _pending_processor_order;
649 gint _pending_process_reorder; // atomic
650 gint _pending_signals; // atomic
652 int _pending_declick;
653 MeterPoint _meter_point;
654 MeterPoint _pending_meter_point;
655 MeterType _meter_type;
657 bool _denormal_protection;
659 bool _recordable : 1;
660 bool _declickable : 1;
662 boost::shared_ptr<SoloControl> _solo_control;
663 boost::shared_ptr<MuteControl> _mute_control;
664 boost::shared_ptr<PhaseControl> _phase_control;
665 boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
666 boost::shared_ptr<SoloSafeControl> _solo_safe_control;
668 std::string _comment;
669 bool _have_internal_generator;
670 DataType _default_type;
673 InstrumentInfo _instrument_info;
675 virtual ChanCount input_streams () const;
677 virtual XMLNode& state(bool);
679 int configure_processors (ProcessorStreams*);
681 void silence (samplecnt_t);
682 void silence_unlocked (samplecnt_t);
684 ChanCount processor_max_streams;
685 ChanCount processor_out_streams;
687 uint32_t pans_required() const;
688 ChanCount n_process_buffers ();
690 virtual void maybe_declick (BufferSet&, samplecnt_t, int);
692 boost::shared_ptr<GainControl> _gain_control;
693 boost::shared_ptr<Amp> _amp;
694 boost::shared_ptr<GainControl> _trim_control;
695 boost::shared_ptr<Amp> _trim;
696 boost::shared_ptr<PeakMeter> _meter;
698 boost::shared_ptr<DelayLine> _delayline;
700 bool is_internal_processor (boost::shared_ptr<Processor>) const;
702 boost::shared_ptr<Processor> the_instrument_unlocked() const;
704 SlavableControlList slavables () const;
707 /* no copy construction */
708 Route (Route const &);
710 int set_state_2X (const XMLNode&, int);
711 void set_processor_state_2X (XMLNodeList const &, int);
713 void input_change_handler (IOChange, void *src);
714 void output_change_handler (IOChange, void *src);
715 void sidechain_change_handler (IOChange, void *src);
717 void processor_selfdestruct (boost::weak_ptr<Processor>);
718 std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
719 Glib::Threads::Mutex selfdestruct_lock;
721 bool input_port_count_changing (ChanCount);
722 bool output_port_count_changing (ChanCount);
724 int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
725 bool set_meter_point_unlocked ();
726 void apply_processor_order (const ProcessorList& new_order);
728 std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
729 std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
731 bool add_processor_from_xml_2X (const XMLNode&, int);
733 void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
735 void set_self_solo (bool yn);
738 void set_processor_positions ();
739 samplecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, samplecnt_t) const;
741 void setup_invisible_processors ();
743 pframes_t latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_t& end_sample);
745 void run_route (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, int declick, bool gain_automation_ok, bool run_disk_reader);
746 void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
748 void reset_instrument_info ();
749 void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
750 void maybe_note_meter_position ();
752 void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
754 /** A handy class to keep processor state while we attempt a reconfiguration
757 class ProcessorState {
759 ProcessorState (Route* r)
761 , _processors (r->_processors)
762 , _processor_max_streams (r->processor_max_streams)
766 _route->_processors = _processors;
767 _route->processor_max_streams = _processor_max_streams;
771 /* this should perhaps be a shared_ptr, but ProcessorStates will
772 not hang around long enough for it to matter.
775 ProcessorList _processors;
776 ChanCount _processor_max_streams;
779 friend class ProcessorState;
781 boost::shared_ptr<CapturingProcessor> _capturing_processor;
783 int64_t _track_number;
785 bool _in_configure_processors;
786 bool _initial_io_setup;
787 bool _in_sidechain_setup;
789 /** true if we've made a note of a custom meter position in these variables */
790 bool _custom_meter_position_noted;
791 /** the processor that came after the meter when it was last set to a custom position,
794 boost::weak_ptr<Processor> _processor_after_last_custom_meter;
796 RoutePinWindowProxy* _pinmgr_proxy;
797 PatchChangeGridDialog* _patch_selector_dialog;
800 } // namespace ARDOUR
802 #endif /* __ardour_route_h__ */