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
  20 #ifndef __ardour_route_h__
  21 #define __ardour_route_h__
  22
  23 #include <cmath>
  24 #include <cstring>
  25 #include <list>
  26 #include <map>
  27 #include <set>
  28 #include <string>
  29
  30 #include <boost/shared_ptr.hpp>
  31 #include <boost/weak_ptr.hpp>
  32 #include <boost/dynamic_bitset.hpp>
  33 #include <boost/enable_shared_from_this.hpp>
  34
  35 #include <glibmm/threads.h>
  36 #include "pbd/fastlog.h"
  37 #include "pbd/xml++.h"
  38 #include "pbd/undo.h"
  39 #include "pbd/stateful.h"
  40 #include "pbd/controllable.h"
  41 #include "pbd/destructible.h"
  42
  43 #include "ardour/ardour.h"
  44 #include "ardour/instrument_info.h"
  45 #include "ardour/io.h"
  46 #include "ardour/libardour_visibility.h"
  47 #include "ardour/types.h"
  48 #include "ardour/mute_master.h"
  49 #include "ardour/route_group_member.h"
  50 #include "ardour/graphnode.h"
  51 #include "ardour/automatable.h"
  52 #include "ardour/unknown_processor.h"
  53
  54 namespace ARDOUR {
  55
  56 class Amp;
  57 class DelayLine;
  58 class Delivery;
  59 class IOProcessor;
  60 class Panner;
  61 class PannerShell;
  62 class PortSet;
  63 class Processor;
  64 class RouteGroup;
  65 class Send;
  66 class InternalReturn;
  67 class MonitorProcessor;
  68 class Pannable;
  69 class CapturingProcessor;
  70 class InternalSend;
  71
  72 class LIBARDOUR_API Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
  73 {
  74   public:
  75
  76         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
  77
  78         enum Flag {
  79                 Auditioner = 0x1,
  80                 MasterOut = 0x2,
  81                 MonitorOut = 0x4
  82         };
  83
  84         Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
  85         virtual ~Route();
  86
  87         virtual int init ();
  88
  89         boost::shared_ptr<IO> input() const { return _input; }
  90         boost::shared_ptr<IO> output() const { return _output; }
  91
  92         ChanCount n_inputs() const { return _input->n_ports(); }
  93         ChanCount n_outputs() const { return _output->n_ports(); }
  94
  95         bool active() const { return _active; }
  96         void set_active (bool yn, void *);
  97
  98         static std::string ensure_track_or_route_name(std::string, Session &);
  99
 100         std::string comment() { return _comment; }
 101         void set_comment (std::string str, void *src);
 102
 103         bool set_name (const std::string& str);
 104         static void set_name_in_state (XMLNode &, const std::string &);
 105
 106         uint32_t order_key () const;
 107         bool has_order_key () const;
 108         void set_order_key (uint32_t);
 109
 110         bool is_auditioner() const { return _flags & Auditioner; }
 111         bool is_master() const { return _flags & MasterOut; }
 112         bool is_monitor() const { return _flags & MonitorOut; }
 113
 114         virtual MonitorState monitoring_state () const;
 115         virtual MeterState metering_state () const;
 116
 117         /* these are the core of the API of a Route. see the protected sections as well */
 118
 119         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 120                           int declick, bool& need_butler);
 121
 122         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 123                              bool state_changing);
 124
 125         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 126                                  bool& need_butler);
 127
 128         virtual bool can_record() { return false; }
 129
 130         virtual void set_record_enabled (bool /*yn*/, void * /*src*/) {}
 131         virtual bool record_enabled() const { return false; }
 132         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 133         virtual void realtime_handle_transport_stopped () {}
 134         virtual void realtime_locate () {}
 135         virtual void non_realtime_locate (framepos_t);
 136         virtual void set_pending_declick (int);
 137
 138         /* end of vfunc-based API */
 139
 140         void shift (framepos_t, framecnt_t);
 141
 142         void set_gain (gain_t val, void *src);
 143         void inc_gain (gain_t delta, void *src);
 144
 145         void set_mute_points (MuteMaster::MutePoint);
 146         MuteMaster::MutePoint mute_points () const;
 147
 148         bool muted () const;
 149         void set_mute (bool yn, void* src);
 150
 151         /* controls use set_solo() to modify this route's solo state
 152          */
 153
 154         void set_solo (bool yn, void *src);
 155         bool soloed () const { return self_soloed () || soloed_by_others (); }
 156         void cancel_solo_after_disconnect (bool upstream);
 157
 158         bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
 159         bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
 160         bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
 161         bool self_soloed () const { return _self_solo; }
 162
 163         void set_solo_isolated (bool yn, void *src);
 164         bool solo_isolated() const;
 165
 166         void set_solo_safe (bool yn, void *src);
 167         bool solo_safe() const;
 168
 169         void set_listen (bool yn, void* src);
 170         bool listening_via_monitor () const;
 171         void enable_monitor_send ();
 172
 173         void set_phase_invert (uint32_t, bool yn);
 174         void set_phase_invert (boost::dynamic_bitset<>);
 175         bool phase_invert (uint32_t) const;
 176         boost::dynamic_bitset<> phase_invert () const;
 177
 178         void set_denormal_protection (bool yn);
 179         bool denormal_protection() const;
 180
 181         void         set_meter_point (MeterPoint, bool force = false);
 182         MeterPoint   meter_point() const { return _meter_point; }
 183         void         meter ();
 184
 185         void         set_meter_type (MeterType t) { _meter_type = t; }
 186         MeterType    meter_type() const { return _meter_type; }
 187
 188         /* Processors */
 189
 190         boost::shared_ptr<Amp> amp() const  { return _amp; }
 191         PeakMeter&       peak_meter()       { return *_meter.get(); }
 192         const PeakMeter& peak_meter() const { return *_meter.get(); }
 193         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 194         boost::shared_ptr<DelayLine> delay_line() const  { return _delayline; }
 195
 196         void flush_processors ();
 197
 198         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 199                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 200                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 201                         if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 202                                 break;
 203                         }
 204                         method (boost::weak_ptr<Processor> (*i));
 205                 }
 206         }
 207
 208         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 209                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 210                 ProcessorList::iterator i;
 211                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 212                 if (i == _processors.end()) {
 213                         return boost::shared_ptr<Processor> ();
 214                 } else {
 215                         return *i;
 216                 }
 217         }
 218
 219         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 220
 221         boost::shared_ptr<Processor> nth_plugin (uint32_t n);
 222         boost::shared_ptr<Processor> nth_send (uint32_t n);
 223
 224         bool has_io_processor_named (const std::string&);
 225         ChanCount max_processor_streams () const { return processor_max_streams; }
 226
 227         std::list<std::string> unknown_processors () const;
 228
 229         /* special processors */
 230
 231         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 232         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 233         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 234         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 235         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 236         void add_internal_return ();
 237         void add_send_to_internal_return (InternalSend *);
 238         void remove_send_from_internal_return (InternalSend *);
 239         void listen_position_changed ();
 240         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 241
 242         /** A record of the stream configuration at some point in the processor list.
 243          * Used to return where and why an processor list configuration request failed.
 244          */
 245         struct ProcessorStreams {
 246                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 247
 248                 uint32_t  index; ///< Index of processor where configuration failed
 249                 ChanCount count; ///< Input requested of processor
 250         };
 251
 252         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 253         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 254         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 255         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 256         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 257         boost::shared_ptr<Processor> before_processor_for_index (int);
 258         int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool need_process_lock = true);
 259         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 260         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 261         void disable_processors (Placement);
 262         void disable_processors ();
 263         void disable_plugins (Placement);
 264         void disable_plugins ();
 265         void ab_plugins (bool forward);
 266         void clear_processors (Placement);
 267         void all_visible_processors_active (bool);
 268
 269         framecnt_t set_private_port_latencies (bool playback) const;
 270         void       set_public_port_latencies (framecnt_t, bool playback) const;
 271
 272         framecnt_t   update_signal_latency();
 273         virtual void set_latency_compensation (framecnt_t);
 274
 275         void set_user_latency (framecnt_t);
 276         framecnt_t initial_delay() const { return _initial_delay; }
 277         framecnt_t signal_latency() const { return _signal_latency; }
 278
 279         PBD::Signal0<void>       active_changed;
 280         PBD::Signal0<void>       phase_invert_changed;
 281         PBD::Signal0<void>       denormal_protection_changed;
 282         PBD::Signal1<void,void*> listen_changed;
 283         PBD::Signal2<void,bool,void*> solo_changed;
 284         PBD::Signal1<void,void*> solo_safe_changed;
 285         PBD::Signal1<void,void*> solo_isolated_changed;
 286         PBD::Signal1<void,void*> comment_changed;
 287         PBD::Signal1<void,void*> mute_changed;
 288         PBD::Signal0<void>       mute_points_changed;
 289
 290         /** track numbers - assigned by session
 291          * nubers > 0 indicate tracks (audio+midi)
 292          * nubers < 0 indicate busses
 293          * zero is reserved for unnumbered special busses.
 294          * */
 295         PBD::Signal0<void> track_number_changed;
 296         int64_t track_number() const { return _track_number; }
 297
 298         void set_track_number(int64_t tn) {
 299                 if (tn == _track_number) { return; }
 300                 _track_number = tn;
 301                 track_number_changed();
 302                 PropertyChanged (ARDOUR::Properties::name);
 303         }
 304
 305         /** the processors have changed; the parameter indicates what changed */
 306         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 307         PBD::Signal1<void,void*> record_enable_changed;
 308         /** the metering point has changed */
 309         PBD::Signal0<void>       meter_change;
 310         PBD::Signal0<void>       signal_latency_changed;
 311         PBD::Signal0<void>       initial_delay_changed;
 312
 313         /** Emitted with the process lock held */
 314         PBD::Signal0<void>       io_changed;
 315
 316         /* gui's call this for their own purposes. */
 317
 318         PBD::Signal2<void,std::string,void*> gui_changed;
 319
 320         /* stateful */
 321
 322         XMLNode& get_state();
 323         virtual int set_state (const XMLNode&, int version);
 324         virtual XMLNode& get_template();
 325
 326         XMLNode& get_processor_state ();
 327         virtual void set_processor_state (const XMLNode&);
 328
 329         int save_as_template (const std::string& path, const std::string& name);
 330
 331         PBD::Signal1<void,void*> SelectedChanged;
 332
 333         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 334         void remove_aux_or_listen (boost::shared_ptr<Route>);
 335
 336         /**
 337          * return true if this route feeds the first argument via at least one
 338          * (arbitrarily long) signal pathway.
 339          */
 340         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 341
 342         /**
 343          * return true if this route feeds the first argument directly, via
 344          * either its main outs or a send.  This is checked by the actual
 345          * connections, rather than by what the graph is currently doing.
 346          */
 347         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 348
 349         /**
 350          * return true if this route feeds the first argument directly, via
 351          * either its main outs or a send, according to the graph that
 352          * is currently being processed.
 353          */
 354         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 355
 356         struct FeedRecord {
 357                 boost::weak_ptr<Route> r;
 358                 bool sends_only;
 359
 360                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 361                 : r (rp)
 362                 , sends_only (sendsonly) {}
 363         };
 364
 365         struct FeedRecordCompare {
 366                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 367                         return a.r < b.r;
 368                 }
 369         };
 370
 371         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 372
 373         const FedBy& fed_by() const { return _fed_by; }
 374         void clear_fed_by ();
 375         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 376
 377         /* Controls (not all directly owned by the Route */
 378
 379         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 380
 381         class SoloControllable : public AutomationControl {
 382         public:
 383                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 384                 void set_value (double);
 385                 double get_value () const;
 386
 387         private:
 388                 boost::weak_ptr<Route> _route;
 389         };
 390
 391         struct MuteControllable : public AutomationControl {
 392         public:
 393                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 394                 void set_value (double);
 395                 double get_value () const;
 396
 397                 /* Pretend to change value, but do not affect actual route mute. */
 398                 void set_superficial_value(bool muted);
 399
 400         private:
 401                 boost::weak_ptr<Route> _route;
 402         };
 403
 404         boost::shared_ptr<SoloControllable> solo_control() const {
 405                 return _solo_control;
 406         }
 407
 408         boost::shared_ptr<MuteControllable> mute_control() const {
 409                 return _mute_control;
 410         }
 411
 412         boost::shared_ptr<MuteMaster> mute_master() const {
 413                 return _mute_master;
 414         }
 415
 416         /* Route doesn't own these items, but sub-objects that it does own have them
 417            and to make UI code a bit simpler, we provide direct access to them
 418            here.
 419         */
 420
 421         boost::shared_ptr<Panner> panner() const;  /* may return null */
 422         boost::shared_ptr<PannerShell> panner_shell() const;
 423         boost::shared_ptr<AutomationControl> gain_control() const;
 424         boost::shared_ptr<Pannable> pannable() const;
 425
 426         /**
 427            Return the first processor that accepts has at least one MIDI input
 428            and at least one audio output. In the vast majority of cases, this
 429            will be "the instrument". This does not preclude other MIDI->audio
 430            processors later in the processing chain, but that would be a
 431            special case not covered by this utility function.
 432         */
 433         boost::shared_ptr<Processor> the_instrument() const;
 434         InstrumentInfo& instrument_info() { return _instrument_info; }
 435
 436         void protect_automation ();
 437
 438         enum {
 439                 /* These numbers are taken from MIDI Machine Control,
 440                    which can only control up to 317 tracks without
 441                    doing sysex segmentation.
 442                 */
 443                 MasterBusRemoteControlID = 318,
 444                 MonitorBusRemoteControlID = 319,
 445         };
 446
 447         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 448         uint32_t remote_control_id () const;
 449         void     set_remote_control_id_explicit (uint32_t order_key);
 450
 451         /* for things concerned about *this* route's RID */
 452
 453         PBD::Signal0<void> RemoteControlIDChanged;
 454
 455         /* for things concerned about *any* route's RID changes */
 456
 457         static PBD::Signal0<void> RemoteControlIDChange;
 458         static PBD::Signal0<void> SyncOrderKeys;
 459
 460         bool has_external_redirects() const;
 461
 462         /* can only be executed by a route for which is_monitor() is true
 463            (i.e. the monitor out)
 464         */
 465         void monitor_run (framepos_t start_frame, framepos_t end_frame,
 466                           pframes_t nframes, int declick);
 467
 468   protected:
 469         friend class Session;
 470
 471         void catch_up_on_solo_mute_override ();
 472         void mod_solo_by_others_upstream (int32_t);
 473         void mod_solo_by_others_downstream (int32_t);
 474         void curve_reallocate ();
 475         virtual void set_block_size (pframes_t nframes);
 476
 477   protected:
 478         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 479
 480         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 481
 482         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 483                         pframes_t nframes, int declick);
 484
 485         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 486                                              framecnt_t /* nframes */) {}
 487
 488         virtual void process_output_buffers (BufferSet& bufs,
 489                                              framepos_t start_frame, framepos_t end_frame,
 490                                              pframes_t nframes, int declick,
 491                                              bool gain_automation_ok);
 492
 493         virtual void bounce_process (BufferSet& bufs,
 494                                      framepos_t start_frame, framecnt_t nframes,
 495                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 496                                      bool for_export, bool for_freeze);
 497
 498         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 499         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 500
 501         boost::shared_ptr<IO> _input;
 502         boost::shared_ptr<IO> _output;
 503
 504         bool           _active;
 505         framecnt_t     _signal_latency;
 506         framecnt_t     _signal_latency_at_amp_position;
 507         framecnt_t     _initial_delay;
 508         framecnt_t     _roll_delay;
 509
 510         ProcessorList  _processors;
 511         mutable Glib::Threads::RWLock   _processor_lock;
 512         boost::shared_ptr<Delivery> _main_outs;
 513         boost::shared_ptr<InternalSend> _monitor_send;
 514         boost::shared_ptr<InternalReturn> _intreturn;
 515         boost::shared_ptr<MonitorProcessor> _monitor_control;
 516         boost::shared_ptr<Pannable> _pannable;
 517
 518         Flag           _flags;
 519         int            _pending_declick;
 520         MeterPoint     _meter_point;
 521         MeterType      _meter_type;
 522         boost::dynamic_bitset<> _phase_invert;
 523         bool           _self_solo;
 524         uint32_t       _soloed_by_others_upstream;
 525         uint32_t       _soloed_by_others_downstream;
 526         uint32_t       _solo_isolated;
 527
 528         bool           _denormal_protection;
 529
 530         bool _recordable : 1;
 531         bool _silent : 1;
 532         bool _declickable : 1;
 533
 534         boost::shared_ptr<SoloControllable> _solo_control;
 535         boost::shared_ptr<MuteControllable> _mute_control;
 536         boost::shared_ptr<MuteMaster> _mute_master;
 537
 538         virtual void act_on_mute () {}
 539
 540         std::string    _comment;
 541         bool           _have_internal_generator;
 542         bool           _solo_safe;
 543         DataType       _default_type;
 544         FedBy          _fed_by;
 545
 546         InstrumentInfo _instrument_info;
 547
 548         virtual ChanCount input_streams () const;
 549
 550   protected:
 551         virtual XMLNode& state(bool);
 552
 553         int configure_processors (ProcessorStreams*);
 554
 555         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 556                                pframes_t nframes, int declick);
 557
 558         void silence (framecnt_t);
 559         void silence_unlocked (framecnt_t);
 560
 561         ChanCount processor_max_streams;
 562         ChanCount processor_out_streams;
 563
 564         uint32_t pans_required() const;
 565         ChanCount n_process_buffers ();
 566
 567         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 568
 569         boost::shared_ptr<Amp>       _amp;
 570         boost::shared_ptr<PeakMeter> _meter;
 571         boost::shared_ptr<DelayLine> _delayline;
 572
 573         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 574
 575   private:
 576         int set_state_2X (const XMLNode&, int);
 577         void set_processor_state_2X (XMLNodeList const &, int);
 578
 579         uint32_t _order_key;
 580         bool _has_order_key;
 581         uint32_t _remote_control_id;
 582
 583         int64_t _track_number;
 584
 585         void input_change_handler (IOChange, void *src);
 586         void output_change_handler (IOChange, void *src);
 587
 588         bool input_port_count_changing (ChanCount);
 589         bool output_port_count_changing (ChanCount);
 590
 591         bool _in_configure_processors;
 592         bool _initial_io_setup;
 593
 594         int configure_processors_unlocked (ProcessorStreams*);
 595         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 596         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 597
 598         bool add_processor_from_xml_2X (const XMLNode&, int);
 599
 600         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 601
 602         void set_self_solo (bool yn);
 603         void set_mute_master_solo ();
 604
 605         void set_processor_positions ();
 606         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 607
 608         void setup_invisible_processors ();
 609         void unpan ();
 610
 611         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 612
 613         /** A handy class to keep processor state while we attempt a reconfiguration
 614          *  that may fail.
 615          */
 616         class ProcessorState {
 617         public:
 618                 ProcessorState (Route* r)
 619                         : _route (r)
 620                         , _processors (r->_processors)
 621                         , _processor_max_streams (r->processor_max_streams)
 622                 { }
 623
 624                 void restore () {
 625                         _route->_processors = _processors;
 626                         _route->processor_max_streams = _processor_max_streams;
 627                 }
 628
 629         private:
 630                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 631                    not hang around long enough for it to matter.
 632                 */
 633                 Route* _route;
 634                 ProcessorList _processors;
 635                 ChanCount _processor_max_streams;
 636         };
 637
 638         friend class ProcessorState;
 639
 640         /* no copy construction */
 641         Route (Route const &);
 642
 643         void maybe_note_meter_position ();
 644
 645         /** true if we've made a note of a custom meter position in these variables */
 646         bool _custom_meter_position_noted;
 647         /** the processor that came after the meter when it was last set to a custom position,
 648             or 0.
 649         */
 650         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 651         /** true if the last custom meter position was at the end of the processor list */
 652         bool _last_custom_meter_was_at_end;
 653
 654         void reset_instrument_info ();
 655
 656         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 657 };
 658
 659 } // namespace ARDOUR
 660
 661 #endif /* __ardour_route_h__ */