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/types.h"
  47 #include "ardour/mute_master.h"
  48 #include "ardour/route_group_member.h"
  49 #include "ardour/graphnode.h"
  50 #include "ardour/automatable.h"
  51 #include "ardour/unknown_processor.h"
  52
  53 namespace ARDOUR {
  54
  55 class Amp;
  56 class Delivery;
  57 class IOProcessor;
  58 class Panner;
  59 class PannerShell;
  60 class PortSet;
  61 class Processor;
  62 class RouteGroup;
  63 class Send;
  64 class InternalReturn;
  65 class MonitorProcessor;
  66 class Pannable;
  67 class CapturingProcessor;
  68 class InternalSend;
  69
  70 class Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
  71 {
  72   public:
  73
  74         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
  75
  76         enum Flag {
  77                 Auditioner = 0x1,
  78                 MasterOut = 0x2,
  79                 MonitorOut = 0x4
  80         };
  81
  82         Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
  83         virtual ~Route();
  84
  85         virtual int init ();
  86
  87         boost::shared_ptr<IO> input() const { return _input; }
  88         boost::shared_ptr<IO> output() const { return _output; }
  89
  90         ChanCount n_inputs() const { return _input->n_ports(); }
  91         ChanCount n_outputs() const { return _output->n_ports(); }
  92
  93         bool active() const { return _active; }
  94         void set_active (bool yn, void *);
  95
  96         static std::string ensure_track_or_route_name(std::string, Session &);
  97
  98         std::string comment() { return _comment; }
  99         void set_comment (std::string str, void *src);
 100
 101         bool set_name (const std::string& str);
 102         static void set_name_in_state (XMLNode &, const std::string &);
 103
 104         uint32_t order_key (RouteSortOrderKey) const;
 105         bool has_order_key (RouteSortOrderKey) const;
 106         void set_order_key (RouteSortOrderKey, uint32_t);
 107         void sync_order_keys (RouteSortOrderKey);
 108
 109         bool is_auditioner() const { return _flags & Auditioner; }
 110         bool is_master() const { return _flags & MasterOut; }
 111         bool is_monitor() const { return _flags & MonitorOut; }
 112
 113         virtual MonitorState monitoring_state () const;
 114         virtual MeterState metering_state () const;
 115
 116         /* these are the core of the API of a Route. see the protected sections as well */
 117
 118         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 119                           int declick, bool& need_butler);
 120
 121         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 122                              bool state_changing);
 123
 124         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 125                                  bool& need_butler);
 126
 127         virtual bool can_record() { return false; }
 128
 129         virtual void set_record_enabled (bool /*yn*/, void * /*src*/) {}
 130         virtual bool record_enabled() const { return false; }
 131         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 132         virtual void realtime_handle_transport_stopped () {}
 133         virtual void realtime_locate () {}
 134         virtual void non_realtime_locate (framepos_t);
 135         virtual void set_pending_declick (int);
 136
 137         /* end of vfunc-based API */
 138
 139         void shift (framepos_t, framecnt_t);
 140
 141         void set_gain (gain_t val, void *src);
 142         void inc_gain (gain_t delta, void *src);
 143
 144         void set_mute_points (MuteMaster::MutePoint);
 145         MuteMaster::MutePoint mute_points () const;
 146
 147         bool muted () const;
 148         void set_mute (bool yn, void* src);
 149
 150         /* controls use set_solo() to modify this route's solo state
 151          */
 152
 153         void set_solo (bool yn, void *src);
 154         bool soloed () const { return self_soloed () || soloed_by_others (); }
 155         void cancel_solo_after_disconnect (bool upstream);
 156
 157         bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
 158         bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
 159         bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
 160         bool self_soloed () const { return _self_solo; }
 161
 162         void set_solo_isolated (bool yn, void *src);
 163         bool solo_isolated() const;
 164
 165         void set_solo_safe (bool yn, void *src);
 166         bool solo_safe() const;
 167
 168         void set_listen (bool yn, void* src);
 169         bool listening_via_monitor () const;
 170         void enable_monitor_send ();
 171
 172         void set_phase_invert (uint32_t, bool yn);
 173         void set_phase_invert (boost::dynamic_bitset<>);
 174         bool phase_invert (uint32_t) const;
 175         boost::dynamic_bitset<> phase_invert () const;
 176
 177         void set_denormal_protection (bool yn);
 178         bool denormal_protection() const;
 179
 180         void         set_meter_point (MeterPoint, bool force = false);
 181         MeterPoint   meter_point() const { return _meter_point; }
 182         void         meter ();
 183
 184         void         set_meter_type_mixer (MeterType t) { _meter_type_mixer = t; }
 185         void         set_meter_type_meterbridge (MeterType t) { _meter_type_meterbridge = t; }
 186         MeterType    meter_type_mixer() const { return _meter_type_mixer; }
 187         MeterType    meter_type_meterbridge() const { return _meter_type_meterbridge; }
 188
 189         /* Processors */
 190
 191         boost::shared_ptr<Amp> amp() const  { return _amp; }
 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
 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         /** the processors have changed; the parameter indicates what changed */
 291         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 292         PBD::Signal1<void,void*> record_enable_changed;
 293         /** the metering point has changed */
 294         PBD::Signal0<void>       meter_change;
 295         PBD::Signal0<void>       signal_latency_changed;
 296         PBD::Signal0<void>       initial_delay_changed;
 297
 298         /** Emitted with the process lock held */
 299         PBD::Signal0<void>       io_changed;
 300
 301         /* gui's call this for their own purposes. */
 302
 303         PBD::Signal2<void,std::string,void*> gui_changed;
 304
 305         /* stateful */
 306
 307         XMLNode& get_state();
 308         virtual int set_state (const XMLNode&, int version);
 309         virtual XMLNode& get_template();
 310
 311         XMLNode& get_processor_state ();
 312         virtual void set_processor_state (const XMLNode&);
 313
 314         int save_as_template (const std::string& path, const std::string& name);
 315
 316         PBD::Signal1<void,void*> SelectedChanged;
 317
 318         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 319         void remove_aux_or_listen (boost::shared_ptr<Route>);
 320
 321         /**
 322          * return true if this route feeds the first argument via at least one
 323          * (arbitrarily long) signal pathway.
 324          */
 325         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 326
 327         /**
 328          * return true if this route feeds the first argument directly, via
 329          * either its main outs or a send.  This is checked by the actual
 330          * connections, rather than by what the graph is currently doing.
 331          */
 332         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 333
 334         /**
 335          * return true if this route feeds the first argument directly, via
 336          * either its main outs or a send, according to the graph that
 337          * is currently being processed.
 338          */
 339         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 340
 341         struct FeedRecord {
 342                 boost::weak_ptr<Route> r;
 343                 bool sends_only;
 344
 345                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 346                 : r (rp)
 347                 , sends_only (sendsonly) {}
 348         };
 349
 350         struct FeedRecordCompare {
 351                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 352                         return a.r < b.r;
 353                 }
 354         };
 355
 356         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 357
 358         const FedBy& fed_by() const { return _fed_by; }
 359         void clear_fed_by ();
 360         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 361
 362         /* Controls (not all directly owned by the Route */
 363
 364         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 365
 366         class SoloControllable : public AutomationControl {
 367         public:
 368                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 369                 void set_value (double);
 370                 double get_value () const;
 371
 372         private:
 373                 boost::weak_ptr<Route> _route;
 374         };
 375
 376         struct MuteControllable : public AutomationControl {
 377         public:
 378                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 379                 void set_value (double);
 380                 double get_value () const;
 381
 382         private:
 383                 boost::weak_ptr<Route> _route;
 384         };
 385
 386         boost::shared_ptr<AutomationControl> solo_control() const {
 387                 return _solo_control;
 388         }
 389
 390         boost::shared_ptr<AutomationControl> mute_control() const {
 391                 return _mute_control;
 392         }
 393
 394         boost::shared_ptr<MuteMaster> mute_master() const {
 395                 return _mute_master;
 396         }
 397
 398         /* Route doesn't own these items, but sub-objects that it does own have them
 399            and to make UI code a bit simpler, we provide direct access to them
 400            here.
 401         */
 402
 403         boost::shared_ptr<Panner> panner() const;  /* may return null */
 404         boost::shared_ptr<PannerShell> panner_shell() const;
 405         boost::shared_ptr<AutomationControl> gain_control() const;
 406         boost::shared_ptr<Pannable> pannable() const;
 407
 408         /**
 409            Return the first processor that accepts has at least one MIDI input
 410            and at least one audio output. In the vast majority of cases, this
 411            will be "the instrument". This does not preclude other MIDI->audio
 412            processors later in the processing chain, but that would be a
 413            special case not covered by this utility function.
 414         */
 415         boost::shared_ptr<Processor> the_instrument() const;
 416         InstrumentInfo& instrument_info() { return _instrument_info; }
 417
 418         void protect_automation ();
 419
 420         enum {
 421                 /* These numbers are taken from MIDI Machine Control,
 422                    which can only control up to 317 tracks without
 423                    doing sysex segmentation.
 424                 */
 425                 MasterBusRemoteControlID = 318,
 426                 MonitorBusRemoteControlID = 319,
 427         };
 428
 429         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 430         uint32_t remote_control_id () const;
 431         void     set_remote_control_id_from_order_key (RouteSortOrderKey, uint32_t order_key);
 432
 433         /* for things concerned about *this* route's RID */
 434
 435         PBD::Signal0<void> RemoteControlIDChanged;
 436
 437         /* for things concerned about *any* route's RID changes */
 438
 439         static PBD::Signal0<void> RemoteControlIDChange;
 440         static PBD::Signal1<void,RouteSortOrderKey> SyncOrderKeys;
 441
 442         bool has_external_redirects() const;
 443
 444         /* can only be executed by a route for which is_monitor() is true
 445            (i.e. the monitor out)
 446         */
 447         void monitor_run (framepos_t start_frame, framepos_t end_frame,
 448                           pframes_t nframes, int declick);
 449
 450   protected:
 451         friend class Session;
 452
 453         void catch_up_on_solo_mute_override ();
 454         void mod_solo_by_others_upstream (int32_t);
 455         void mod_solo_by_others_downstream (int32_t);
 456         void curve_reallocate ();
 457         virtual void set_block_size (pframes_t nframes);
 458
 459   protected:
 460         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 461
 462         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 463
 464         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 465                         pframes_t nframes, int declick);
 466
 467         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 468                                              framecnt_t /* nframes */) {}
 469
 470         virtual void process_output_buffers (BufferSet& bufs,
 471                                              framepos_t start_frame, framepos_t end_frame,
 472                                              pframes_t nframes, int declick,
 473                                              bool gain_automation_ok);
 474
 475         boost::shared_ptr<IO> _input;
 476         boost::shared_ptr<IO> _output;
 477
 478         bool           _active;
 479         framecnt_t     _signal_latency;
 480         framecnt_t     _initial_delay;
 481         framecnt_t     _roll_delay;
 482
 483         ProcessorList  _processors;
 484         mutable Glib::Threads::RWLock   _processor_lock;
 485         boost::shared_ptr<Delivery> _main_outs;
 486         boost::shared_ptr<InternalSend> _monitor_send;
 487         boost::shared_ptr<InternalReturn> _intreturn;
 488         boost::shared_ptr<MonitorProcessor> _monitor_control;
 489         boost::shared_ptr<Pannable> _pannable;
 490
 491         Flag           _flags;
 492         int            _pending_declick;
 493         MeterPoint     _meter_point;
 494         MeterType      _meter_type_mixer;
 495         MeterType      _meter_type_meterbridge;
 496         boost::dynamic_bitset<> _phase_invert;
 497         bool           _self_solo;
 498         uint32_t       _soloed_by_others_upstream;
 499         uint32_t       _soloed_by_others_downstream;
 500         uint32_t       _solo_isolated;
 501
 502         bool           _denormal_protection;
 503
 504         bool _recordable : 1;
 505         bool _silent : 1;
 506         bool _declickable : 1;
 507
 508         boost::shared_ptr<SoloControllable> _solo_control;
 509         boost::shared_ptr<MuteControllable> _mute_control;
 510         boost::shared_ptr<MuteMaster> _mute_master;
 511
 512         virtual void act_on_mute () {}
 513
 514         std::string    _comment;
 515         bool           _have_internal_generator;
 516         bool           _solo_safe;
 517         DataType       _default_type;
 518         FedBy          _fed_by;
 519
 520         InstrumentInfo _instrument_info;
 521
 522         virtual ChanCount input_streams () const;
 523
 524   protected:
 525         virtual XMLNode& state(bool);
 526
 527         int configure_processors (ProcessorStreams*);
 528
 529         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 530                                pframes_t nframes, int declick);
 531
 532         void silence (framecnt_t);
 533         void silence_unlocked (framecnt_t);
 534
 535         ChanCount processor_max_streams;
 536
 537         uint32_t pans_required() const;
 538         ChanCount n_process_buffers ();
 539
 540         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 541
 542         boost::shared_ptr<Amp>       _amp;
 543         boost::shared_ptr<PeakMeter> _meter;
 544
 545         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 546
 547   private:
 548         int set_state_2X (const XMLNode&, int);
 549         void set_processor_state_2X (XMLNodeList const &, int);
 550
 551         typedef std::map<RouteSortOrderKey,uint32_t> OrderKeys;
 552         OrderKeys order_keys;
 553         uint32_t _remote_control_id;
 554
 555         void input_change_handler (IOChange, void *src);
 556         void output_change_handler (IOChange, void *src);
 557
 558         bool input_port_count_changing (ChanCount);
 559
 560         bool _in_configure_processors;
 561
 562         int configure_processors_unlocked (ProcessorStreams*);
 563         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 564         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 565
 566         bool add_processor_from_xml_2X (const XMLNode&, int);
 567
 568         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 569
 570         void set_self_solo (bool yn);
 571         void set_mute_master_solo ();
 572
 573         void set_processor_positions ();
 574         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 575
 576         void setup_invisible_processors ();
 577         void unpan ();
 578
 579         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 580
 581         /** A handy class to keep processor state while we attempt a reconfiguration
 582          *  that may fail.
 583          */
 584         class ProcessorState {
 585         public:
 586                 ProcessorState (Route* r)
 587                         : _route (r)
 588                         , _processors (r->_processors)
 589                         , _processor_max_streams (r->processor_max_streams)
 590                 { }
 591
 592                 void restore () {
 593                         _route->_processors = _processors;
 594                         _route->processor_max_streams = _processor_max_streams;
 595                 }
 596
 597         private:
 598                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 599                    not hang around long enough for it to matter.
 600                 */
 601                 Route* _route;
 602                 ProcessorList _processors;
 603                 ChanCount _processor_max_streams;
 604         };
 605
 606         friend class ProcessorState;
 607
 608         /* no copy construction */
 609         Route (Route const &);
 610
 611         void maybe_note_meter_position ();
 612
 613         /** true if we've made a note of a custom meter position in these variables */
 614         bool _custom_meter_position_noted;
 615         /** the processor that came after the meter when it was last set to a custom position,
 616             or 0.
 617         */
 618         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 619         /** true if the last custom meter position was at the end of the processor list */
 620         bool _last_custom_meter_was_at_end;
 621
 622         void reset_instrument_info ();
 623
 624         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 625 };
 626
 627 } // namespace ARDOUR
 628
 629 #endif /* __ardour_route_h__ */