libs/ardour/ardour/route.h

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