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