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