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