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