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