libs/ardour/ardour/route.h

   1 /*
   2     Copyright (C) 2000-2002 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17 */
  18
  19 #ifndef __ardour_route_h__
  20 #define __ardour_route_h__
  21
  22 #include <cmath>
  23 #include <cstring>
  24 #include <list>
  25 #include <map>
  26 #include <set>
  27 #include <string>
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/weak_ptr.hpp>
  31
  32 #include <glibmm/threads.h>
  33 #include "pbd/fastlog.h"
  34 #include "pbd/xml++.h"
  35 #include "pbd/undo.h"
  36 #include "pbd/stateful.h"
  37 #include "pbd/controllable.h"
  38 #include "pbd/destructible.h"
  39
  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"
  60
  61 class RoutePinWindowProxy;
  62 class PatchChangeGridDialog;
  63
  64 namespace ARDOUR {
  65
  66 class Amp;
  67 class DelayLine;
  68 class Delivery;
  69 class DiskReader;
  70 class DiskWriter;
  71 class IOProcessor;
  72 class Panner;
  73 class PannerShell;
  74 class PolarityProcessor;
  75 class PortSet;
  76 class Processor;
  77 class PluginInsert;
  78 class RouteGroup;
  79 class Send;
  80 class InternalReturn;
  81 class Location;
  82 class MonitorControl;
  83 class MonitorProcessor;
  84 class Pannable;
  85 class CapturingProcessor;
  86 class InternalSend;
  87 class VCA;
  88 class SoloIsolateControl;
  89 class PhaseControl;
  90 class MonitorControl;
  91
  92 class LIBARDOUR_API Route : public Stripable,
  93                             public GraphNode,
  94                             public Soloable,
  95                             public Muteable,
  96                             public Monitorable,
  97                             public RouteGroupMember
  98 {
  99 public:
 100
 101         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
 102
 103         Route (Session&, std::string name, PresentationInfo::Flag flags = PresentationInfo::Flag(0), DataType default_type = DataType::AUDIO);
 104         virtual ~Route();
 105
 106         virtual int init ();
 107
 108         DataType data_type () const {
 109                 /* XXX ultimately nice to do away with this concept, but it is
 110                    quite useful for coders and for users too.
 111                 */
 112                 return _default_type;
 113         }
 114
 115         boost::shared_ptr<IO> input() const { return _input; }
 116         boost::shared_ptr<IO> output() const { return _output; }
 117         IOVector all_inputs () const;
 118         IOVector all_outputs () const;
 119
 120         ChanCount n_inputs() const { return _input->n_ports(); }
 121         ChanCount n_outputs() const { return _output->n_ports(); }
 122
 123         bool active() const { return _active; }
 124         void set_active (bool yn, void *);
 125
 126         std::string ensure_track_or_route_name (std::string) const;
 127
 128         std::string comment() { return _comment; }
 129         void set_comment (std::string str, void *src);
 130
 131         bool set_name (const std::string& str);
 132         static void set_name_in_state (XMLNode &, const std::string &);
 133
 134         boost::shared_ptr<MonitorControl> monitoring_control() const { return _monitoring_control; }
 135
 136         MonitorState monitoring_state () const;
 137         virtual MonitorState get_auto_monitoring_state () const { return MonitoringSilence; }
 138
 139         virtual MeterState metering_state () const;
 140
 141         /* these are the core of the API of a Route. see the protected sections as well */
 142
 143         virtual void filter_input (BufferSet &) {}
 144
 145         int roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler);
 146
 147         int no_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool state_changing);
 148
 149         int silent_roll (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool& need_butler);
 150
 151         virtual bool declick_in_progress () const { return false; }
 152         virtual bool can_record() { return false; }
 153
 154         void non_realtime_transport_stop (samplepos_t now, bool flush);
 155         void realtime_handle_transport_stopped ();
 156
 157         virtual void realtime_locate () {}
 158         virtual void non_realtime_locate (samplepos_t);
 159         void set_loop (ARDOUR::Location *);
 160
 161         /* end of vfunc-based API */
 162
 163         void shift (samplepos_t, samplecnt_t);
 164
 165         void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
 166
 167         /* controls use set_solo() to modify this route's solo state
 168          */
 169
 170         void clear_all_solo_state ();
 171
 172         bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
 173         bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
 174         bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
 175         bool self_soloed () const { return _solo_control->self_soloed(); }
 176         bool soloed () const { return self_soloed () || soloed_by_others (); }
 177
 178         void push_solo_upstream (int32_t delta);
 179         void push_solo_isolate_upstream (int32_t delta);
 180         bool can_solo () const {
 181                 return !(is_master() || is_monitor() || is_auditioner());
 182         }
 183         bool is_safe () const {
 184                 return _solo_safe_control->get_value();
 185         }
 186         void enable_monitor_send ();
 187
 188         void set_denormal_protection (bool yn);
 189         bool denormal_protection() const;
 190
 191         void         set_meter_point (MeterPoint, bool force = false);
 192         bool         apply_processor_changes_rt ();
 193         void         emit_pending_signals ();
 194         MeterPoint   meter_point() const { return _pending_meter_point; }
 195
 196         void         set_meter_type (MeterType t) { _meter_type = t; }
 197         MeterType    meter_type() const { return _meter_type; }
 198
 199         void set_disk_io_point (DiskIOPoint);
 200         DiskIOPoint disk_io_point() const { return _disk_io_point; }
 201
 202         /* Processors */
 203
 204         boost::shared_ptr<Amp> amp() const  { return _amp; }
 205         boost::shared_ptr<Amp> trim() const { return _trim; }
 206         boost::shared_ptr<PeakMeter>       peak_meter()       { return _meter; }
 207         boost::shared_ptr<const PeakMeter> peak_meter() const { return _meter; }
 208         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 209
 210         void flush_processors ();
 211
 212         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 213                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 214                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 215                         method (boost::weak_ptr<Processor> (*i));
 216                 }
 217         }
 218
 219         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 220                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 221                 ProcessorList::iterator i;
 222                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 223                 if (i == _processors.end()) {
 224                         return boost::shared_ptr<Processor> ();
 225                 } else {
 226                         return *i;
 227                 }
 228         }
 229
 230         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 231
 232         boost::shared_ptr<Processor> nth_plugin (uint32_t n) const;
 233         boost::shared_ptr<Processor> nth_send (uint32_t n) const;
 234
 235         bool has_io_processor_named (const std::string&);
 236         ChanCount max_processor_streams () const { return processor_max_streams; }
 237
 238         std::list<std::string> unknown_processors () const;
 239
 240         RoutePinWindowProxy * pinmgr_proxy () const { return _pinmgr_proxy; }
 241         void set_pingmgr_proxy (RoutePinWindowProxy* wp) { _pinmgr_proxy = wp ; }
 242
 243         PatchChangeGridDialog* patch_selector_dialog () const { return _patch_selector_dialog; }
 244         void set_patch_selector_dialog  (PatchChangeGridDialog* d) { _patch_selector_dialog = d; }
 245
 246         boost::shared_ptr<AutomationControl> automation_control_recurse (PBD::ID const & id) const;
 247
 248         /* special processors */
 249
 250         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 251         /** the signal processorat at end of the processing chain which produces output */
 252         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 253         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 254         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 255         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 256         void add_internal_return ();
 257         void add_send_to_internal_return (InternalSend *);
 258         void remove_send_from_internal_return (InternalSend *);
 259         void listen_position_changed ();
 260         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 261
 262         /** A record of the stream configuration at some point in the processor list.
 263          * Used to return where and why an processor list configuration request failed.
 264          */
 265         struct ProcessorStreams {
 266                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 267
 268                 uint32_t  index; ///< Index of processor where configuration failed
 269                 ChanCount count; ///< Input requested of processor
 270         };
 271
 272         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 273         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 274         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 275         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 276         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 277         boost::shared_ptr<Processor> before_processor_for_index (int);
 278         bool processors_reorder_needs_configure (const ProcessorList& new_order);
 279         /** remove plugin/processor
 280          *
 281          * @param proc processor to remove
 282          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 283          * @param need_process_lock if locking is required (set to true, unless called from RT context with lock)
 284          * @returns 0 on success
 285          */
 286         int remove_processor (boost::shared_ptr<Processor> proc, ProcessorStreams* err = 0, bool need_process_lock = true);
 287         /** replace plugin/processor with another
 288          *
 289          * @param old processor to remove
 290          * @param sub processor to substitute the old one with
 291          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 292          * @returns 0 on success
 293          */
 294         int replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err = 0);
 295         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 296         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 297         void disable_processors (Placement);
 298         void disable_processors ();
 299         void disable_plugins (Placement);
 300         void disable_plugins ();
 301         void ab_plugins (bool forward);
 302         void clear_processors (Placement);
 303         void all_visible_processors_active (bool);
 304         void move_instrument_down (bool postfader = false);
 305
 306         bool strict_io () const { return _strict_io; }
 307         bool set_strict_io (bool);
 308         /** reset plugin-insert configuration to default, disable customizations.
 309          *
 310          * This is equivalent to calling
 311          * @code
 312          * customize_plugin_insert (proc, 0, unused)
 313          * @endcode
 314          *
 315          * @param proc Processor to reset
 316          * @returns true if successful
 317          */
 318         bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
 319         /** enable custom plugin-insert configuration
 320          * @param proc Processor to customize
 321          * @param count number of plugin instances to use (if zero, reset to default)
 322          * @param outs output port customization
 323          * @param sinks input pins for variable-I/O plugins
 324          * @returns true if successful
 325          */
 326         bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks);
 327         bool add_remove_sidechain (boost::shared_ptr<Processor> proc, bool);
 328         bool plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs);
 329
 330         /* enable sidechain input for a given processor
 331          *
 332          * The sidechain itself is an IO port object with variable number of channels and configured independently.
 333          * Adding/removing the port itself however requires reconfiguring the route and is hence
 334          * not a plugin operation itself.
 335          *
 336          * @param proc the processor to add sidechain inputs to
 337          * @returns true on success
 338          */
 339         bool add_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, true); }
 340         /* remove sidechain input from given processor
 341          * @param proc the processor to remove the sidechain input from
 342          * @returns true on success
 343          */
 344         bool remove_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, false); }
 345
 346         samplecnt_t  update_signal_latency (bool apply_to_delayline = false);
 347         virtual void apply_latency_compensation ();
 348
 349         samplecnt_t  set_private_port_latencies (bool playback) const;
 350         void         set_public_port_latencies (samplecnt_t, bool playback) const;
 351
 352         void set_user_latency (samplecnt_t);
 353         samplecnt_t signal_latency() const { return _signal_latency; }
 354         samplecnt_t playback_latency (bool incl_downstream = false) const;
 355
 356         PBD::Signal0<void> active_changed;
 357         PBD::Signal0<void> denormal_protection_changed;
 358         PBD::Signal0<void> comment_changed;
 359
 360         bool is_track();
 361
 362         /** track numbers - assigned by session
 363          * nubers > 0 indicate tracks (audio+midi)
 364          * nubers < 0 indicate busses
 365          * zero is reserved for unnumbered special busses.
 366          * */
 367         PBD::Signal0<void> track_number_changed;
 368         int64_t track_number() const { return _track_number; }
 369
 370         void set_track_number(int64_t tn) {
 371                 if (tn == _track_number) { return; }
 372                 _track_number = tn;
 373                 track_number_changed();
 374                 PropertyChanged (ARDOUR::Properties::name);
 375         }
 376
 377         enum PluginSetupOptions {
 378                 None = 0x0,
 379                 CanReplace = 0x1,
 380                 MultiOut = 0x2,
 381         };
 382
 383         static PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, PluginSetupOptions > PluginSetup;
 384
 385         /** the processors have changed; the parameter indicates what changed */
 386         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 387         PBD::Signal0<void> fan_out; // used to signal the GUI to fan-out (track-creation)
 388         PBD::Signal1<void,void*> record_enable_changed;
 389         PBD::Signal0<void> processor_latency_changed;
 390         /** the metering point has changed */
 391         PBD::Signal0<void> meter_change;
 392         /** a processor's latency has changed */
 393         PBD::Signal0<void> signal_latency_changed;
 394         /** route has updated its latency compensation */
 395         PBD::Signal0<void> signal_latency_updated;
 396
 397         /** Emitted with the process lock held */
 398         PBD::Signal0<void>       io_changed;
 399
 400         /* stateful */
 401         XMLNode& get_state();
 402         XMLNode& get_template();
 403         virtual int set_state (const XMLNode&, int version);
 404
 405         XMLNode& get_processor_state ();
 406         void set_processor_state (const XMLNode&);
 407         virtual bool set_processor_state (XMLNode const & node, XMLProperty const* prop, ProcessorList& new_order, bool& must_configure);
 408
 409         boost::weak_ptr<Route> weakroute ();
 410
 411         int save_as_template (const std::string& path, const std::string& name, const std::string& description );
 412
 413         PBD::Signal1<void,void*> SelectedChanged;
 414
 415         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 416         int add_foldback_send (boost::shared_ptr<Route>);
 417         void remove_aux_or_listen (boost::shared_ptr<Route>);
 418
 419         /**
 420          * return true if this route feeds the first argument via at least one
 421          * (arbitrarily long) signal pathway.
 422          */
 423         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 424
 425         /**
 426          * return true if this route feeds the first argument directly, via
 427          * either its main outs or a send.  This is checked by the actual
 428          * connections, rather than by what the graph is currently doing.
 429          */
 430         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 431
 432         /**
 433          * return true if this route feeds the first argument directly, via
 434          * either its main outs or a send, according to the graph that
 435          * is currently being processed.
 436          */
 437         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 438
 439         bool feeds_according_to_graph (boost::shared_ptr<Route>);
 440
 441         struct FeedRecord {
 442                 boost::weak_ptr<Route> r;
 443                 bool sends_only;
 444
 445                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 446                 : r (rp)
 447                 , sends_only (sendsonly) {}
 448         };
 449
 450         struct FeedRecordCompare {
 451                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 452                         return a.r < b.r;
 453                 }
 454         };
 455
 456         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 457
 458         const FedBy& fed_by() const { return _fed_by; }
 459         void clear_fed_by ();
 460         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 461
 462         /* Controls (not all directly owned by the Route) */
 463
 464         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 465
 466         boost::shared_ptr<SoloControl> solo_control() const {
 467                 return _solo_control;
 468         }
 469
 470         boost::shared_ptr<MuteControl> mute_control() const {
 471                 return _mute_control;
 472         }
 473
 474         bool can_be_muted_by_others () const { return can_solo(); }
 475         bool muted () const { return _mute_control->muted(); }
 476         bool muted_by_masters () const { return _mute_control->muted_by_masters(); }
 477         bool muted_by_self () const { return _mute_control->muted_by_self(); }
 478         bool muted_by_others_soloing () const;
 479
 480         boost::shared_ptr<SoloIsolateControl> solo_isolate_control() const {
 481                 return _solo_isolate_control;
 482         }
 483
 484         boost::shared_ptr<SoloSafeControl> solo_safe_control() const {
 485                 return _solo_safe_control;
 486         }
 487
 488         /* Route doesn't own these items, but sub-objects that it does own have them
 489            and to make UI code a bit simpler, we provide direct access to them
 490            here.
 491         */
 492
 493         boost::shared_ptr<Panner> panner() const;  /* may return null */
 494         boost::shared_ptr<PannerShell> panner_shell() const;
 495         boost::shared_ptr<Pannable> pannable() const;
 496
 497         boost::shared_ptr<GainControl> gain_control() const;
 498         boost::shared_ptr<GainControl> trim_control() const;
 499         boost::shared_ptr<PhaseControl> phase_control() const;
 500
 501         /**
 502            Return the first processor that accepts has at least one MIDI input
 503            and at least one audio output. In the vast majority of cases, this
 504            will be "the instrument". This does not preclude other MIDI->audio
 505            processors later in the processing chain, but that would be a
 506            special case not covered by this utility function.
 507         */
 508         boost::shared_ptr<Processor> the_instrument() const;
 509         InstrumentInfo& instrument_info() { return _instrument_info; }
 510
 511         /* "well-known" controls for panning. Any or all of these may return
 512          * null.
 513          */
 514
 515         boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
 516         boost::shared_ptr<AutomationControl> pan_elevation_control() const;
 517         boost::shared_ptr<AutomationControl> pan_width_control() const;
 518         boost::shared_ptr<AutomationControl> pan_frontback_control() const;
 519         boost::shared_ptr<AutomationControl> pan_lfe_control() const;
 520
 521         /* "well-known" controls for an EQ in this route. Any or all may
 522          * be null. eq_band_cnt() must return 0 if there is no EQ present.
 523          * Passing an @param band value >= eq_band_cnt() will guarantee the
 524          * return of a null ptr (or an empty string for eq_band_name()).
 525          */
 526         uint32_t eq_band_cnt () const;
 527         std::string eq_band_name (uint32_t) const;
 528         boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
 529         boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
 530         boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
 531         boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
 532         boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
 533
 534         //additional HP/LP filters
 535         boost::shared_ptr<AutomationControl> filter_freq_controllable (bool hpf) const;
 536         boost::shared_ptr<AutomationControl> filter_slope_controllable (bool) const;
 537         boost::shared_ptr<AutomationControl> filter_enable_controllable (bool) const;
 538
 539         boost::shared_ptr<AutomationControl> tape_drive_controllable () const;
 540
 541         /* "well-known" controls for a compressor in this route. Any or all may
 542          * be null.
 543          */
 544         boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
 545         boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
 546         boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
 547         boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
 548         boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
 549         boost::shared_ptr<ReadOnlyControl>   comp_redux_controllable () const;
 550
 551         /* @param mode must be supplied by the comp_mode_controllable(). All other values
 552          * result in undefined behaviour
 553          */
 554         std::string comp_mode_name (uint32_t mode) const;
 555         /* @param mode - as for comp mode name. This returns the name for the
 556          * parameter/control accessed via comp_speed_controllable(), which can
 557          * be mode dependent.
 558          */
 559         std::string comp_speed_name (uint32_t mode) const;
 560
 561         /* "well-known" controls for sends to well-known busses in this route. Any or all may
 562          * be null.
 563          *
 564          * In Mixbus, these are the sends that connect to the mixbusses.
 565          * In Ardour, these are user-created sends that connect to user-created
 566          * Aux busses.
 567          */
 568         boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
 569         boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
 570         boost::shared_ptr<AutomationControl> send_pan_azi_controllable (uint32_t n) const;
 571         /* for the same value of @param n, this returns the name of the send
 572          * associated with the pair of controllables returned by the above two methods.
 573          */
 574         std::string send_name (uint32_t n) const;
 575
 576         /* well known control that enables/disables sending to the master bus.
 577          *
 578          * In Ardour, this returns null.
 579          * In Mixbus, it will return a suitable control, or null depending on
 580          * the route.
 581          */
 582         boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
 583
 584         void protect_automation ();
 585
 586         bool has_external_redirects() const;
 587
 588         /* can only be executed by a route for which is_monitor() is true
 589          * (i.e. the monitor out)
 590          */
 591         void monitor_run (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes);
 592
 593         bool slaved_to (boost::shared_ptr<VCA>) const;
 594         bool slaved () const;
 595
 596         virtual void use_captured_sources (SourceList& srcs, CaptureInfos const &) {}
 597
 598 protected:
 599         friend class Session;
 600
 601         void catch_up_on_solo_mute_override ();
 602         void set_listen (bool);
 603
 604         virtual void set_block_size (pframes_t nframes);
 605
 606         virtual int no_roll_unlocked (pframes_t nframes, samplepos_t start_sample, samplepos_t end_sample, bool session_state_changing);
 607
 608         virtual void snapshot_out_of_band_data (samplecnt_t /* nframes */) {}
 609         virtual void write_out_of_band_data (BufferSet&, samplecnt_t /* nframes */) const {}
 610         virtual void update_controls (BufferSet const&) {}
 611
 612         void process_output_buffers (BufferSet& bufs,
 613                                      samplepos_t start_sample, samplepos_t end_sample,
 614                                      pframes_t nframes,
 615                                      bool gain_automation_ok,
 616                                      bool run_disk_processors);
 617
 618         void flush_processor_buffers_locked (samplecnt_t nframes);
 619
 620         virtual void bounce_process (BufferSet& bufs,
 621                                      samplepos_t start_sample, samplecnt_t nframes,
 622                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 623                                      bool for_export, bool for_freeze);
 624
 625         samplecnt_t  bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 626         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 627
 628         bool           _active;
 629         samplecnt_t    _signal_latency;
 630
 631         ProcessorList  _processors;
 632         mutable Glib::Threads::RWLock _processor_lock;
 633
 634         boost::shared_ptr<IO>               _input;
 635         boost::shared_ptr<IO>               _output;
 636
 637         boost::shared_ptr<Delivery>         _main_outs;
 638         boost::shared_ptr<InternalSend>     _monitor_send;
 639         boost::shared_ptr<InternalReturn>   _intreturn;
 640         boost::shared_ptr<MonitorProcessor> _monitor_control;
 641         boost::shared_ptr<Pannable>         _pannable;
 642         boost::shared_ptr<DiskReader>       _disk_reader;
 643         boost::shared_ptr<DiskWriter>       _disk_writer;
 644
 645         boost::shared_ptr<MonitorControl>   _monitoring_control;
 646
 647         DiskIOPoint _disk_io_point;
 648
 649         enum {
 650                 EmitNone = 0x00,
 651                 EmitMeterChanged = 0x01,
 652                 EmitMeterVisibilityChange = 0x02,
 653                 EmitRtProcessorChange = 0x04
 654         };
 655
 656         ProcessorList  _pending_processor_order;
 657         gint           _pending_process_reorder; // atomic
 658         gint           _pending_signals; // atomic
 659
 660         MeterPoint     _meter_point;
 661         MeterPoint     _pending_meter_point;
 662         MeterType      _meter_type;
 663
 664         bool           _denormal_protection;
 665
 666         bool _recordable : 1;
 667
 668         boost::shared_ptr<SoloControl> _solo_control;
 669         boost::shared_ptr<MuteControl> _mute_control;
 670         boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
 671         boost::shared_ptr<SoloSafeControl> _solo_safe_control;
 672
 673         std::string    _comment;
 674         bool           _have_internal_generator;
 675         DataType       _default_type;
 676         FedBy          _fed_by;
 677
 678         InstrumentInfo _instrument_info;
 679         Location*      _loop_location;
 680
 681         virtual ChanCount input_streams () const;
 682
 683         virtual XMLNode& state (bool save_template);
 684
 685         int configure_processors (ProcessorStreams*);
 686
 687         void silence (samplecnt_t);
 688         void silence_unlocked (samplecnt_t);
 689
 690         ChanCount processor_max_streams;
 691         ChanCount processor_out_streams;
 692
 693         uint32_t pans_required() const;
 694         ChanCount n_process_buffers ();
 695
 696         boost::shared_ptr<GainControl>  _gain_control;
 697         boost::shared_ptr<GainControl>  _trim_control;
 698         boost::shared_ptr<PhaseControl> _phase_control;
 699         boost::shared_ptr<Amp>               _amp;
 700         boost::shared_ptr<Amp>               _trim;
 701         boost::shared_ptr<PeakMeter>         _meter;
 702         boost::shared_ptr<PolarityProcessor> _polarity;
 703
 704         boost::shared_ptr<DelayLine> _delayline;
 705
 706         bool is_internal_processor (boost::shared_ptr<Processor>) const;
 707
 708         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 709
 710         SlavableControlList slavables () const;
 711
 712 private:
 713         /* no copy construction */
 714         Route (Route const &);
 715
 716         int set_state_2X (const XMLNode&, int);
 717         void set_processor_state_2X (XMLNodeList const &, int);
 718
 719         void input_change_handler (IOChange, void *src);
 720         void output_change_handler (IOChange, void *src);
 721         void sidechain_change_handler (IOChange, void *src);
 722
 723         void processor_selfdestruct (boost::weak_ptr<Processor>);
 724         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 725         Glib::Threads::Mutex  selfdestruct_lock;
 726
 727         bool input_port_count_changing (ChanCount);
 728         bool output_port_count_changing (ChanCount);
 729
 730         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 731         bool set_meter_point_unlocked ();
 732         void apply_processor_order (const ProcessorList& new_order);
 733
 734         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 735         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 736
 737         bool add_processor_from_xml_2X (const XMLNode&, int);
 738
 739         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 740
 741         void set_self_solo (bool yn);
 742         void unpan ();
 743
 744         void set_processor_positions ();
 745         samplecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, samplecnt_t) const;
 746
 747         void setup_invisible_processors ();
 748
 749         pframes_t latency_preroll (pframes_t nframes, samplepos_t& start_sample, samplepos_t& end_sample);
 750
 751         void run_route (samplepos_t start_sample, samplepos_t end_sample, pframes_t nframes, bool gain_automation_ok, bool run_disk_reader);
 752         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 753
 754         void reset_instrument_info ();
 755         void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
 756         void maybe_note_meter_position ();
 757
 758         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 759
 760         /** A handy class to keep processor state while we attempt a reconfiguration
 761          *  that may fail.
 762          */
 763         class ProcessorState {
 764         public:
 765                 ProcessorState (Route* r)
 766                         : _route (r)
 767                         , _processors (r->_processors)
 768                         , _processor_max_streams (r->processor_max_streams)
 769                 { }
 770
 771                 void restore () {
 772                         _route->_processors = _processors;
 773                         _route->processor_max_streams = _processor_max_streams;
 774                 }
 775
 776         private:
 777                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 778                    not hang around long enough for it to matter.
 779                 */
 780                 Route* _route;
 781                 ProcessorList _processors;
 782                 ChanCount _processor_max_streams;
 783         };
 784
 785         friend class ProcessorState;
 786
 787         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 788
 789         int64_t _track_number;
 790         bool    _strict_io;
 791         bool    _in_configure_processors;
 792         bool    _initial_io_setup;
 793         bool    _in_sidechain_setup;
 794
 795         /** true if we've made a note of a custom meter position in these variables */
 796         bool _custom_meter_position_noted;
 797         /** the processor that came after the meter when it was last set to a custom position,
 798             or 0.
 799         */
 800         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 801
 802         RoutePinWindowProxy*   _pinmgr_proxy;
 803         PatchChangeGridDialog* _patch_selector_dialog;
 804 };
 805
 806 } // namespace ARDOUR
 807
 808 #endif /* __ardour_route_h__ */