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