libs/ardour/ardour/route.h

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