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 #ifndef __ardour_route_h__
  20 #define __ardour_route_h__
  21
  22 #include <cmath>
  23 #include <cstring>
  24 #include <list>
  25 #include <map>
  26 #include <set>
  27 #include <string>
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/weak_ptr.hpp>
  31 #include <boost/enable_shared_from_this.hpp>
  32
  33 #include <glibmm/threads.h>
  34 #include "pbd/fastlog.h"
  35 #include "pbd/xml++.h"
  36 #include "pbd/undo.h"
  37 #include "pbd/stateful.h"
  38 #include "pbd/controllable.h"
  39 #include "pbd/destructible.h"
  40
  41 #include "ardour/ardour.h"
  42 #include "ardour/gain_control.h"
  43 #include "ardour/instrument_info.h"
  44 #include "ardour/io.h"
  45 #include "ardour/io_vector.h"
  46 #include "ardour/libardour_visibility.h"
  47 #include "ardour/types.h"
  48 #include "ardour/monitorable.h"
  49 #include "ardour/muteable.h"
  50 #include "ardour/mute_master.h"
  51 #include "ardour/mute_control.h"
  52 #include "ardour/route_group_member.h"
  53 #include "ardour/stripable.h"
  54 #include "ardour/graphnode.h"
  55 #include "ardour/automatable.h"
  56 #include "ardour/unknown_processor.h"
  57 #include "ardour/soloable.h"
  58 #include "ardour/solo_control.h"
  59 #include "ardour/solo_safe_control.h"
  60 #include "ardour/slavable.h"
  61
  62 class RoutePinWindowProxy;
  63
  64 namespace ARDOUR {
  65
  66 class Amp;
  67 class DelayLine;
  68 class Delivery;
  69 class IOProcessor;
  70 class Panner;
  71 class PannerShell;
  72 class PortSet;
  73 class Processor;
  74 class PluginInsert;
  75 class RouteGroup;
  76 class Send;
  77 class InternalReturn;
  78 class MonitorProcessor;
  79 class Pannable;
  80 class CapturingProcessor;
  81 class InternalSend;
  82 class VCA;
  83 class SoloIsolateControl;
  84 class PhaseControl;
  85 class MonitorControl;
  86
  87 class LIBARDOUR_API Route : public GraphNode,
  88                             public Stripable,
  89                             public Soloable,
  90                             public Muteable,
  91                             public Monitorable,
  92                             public Automatable,
  93                             public RouteGroupMember,
  94                             public boost::enable_shared_from_this<Route>
  95 {
  96 public:
  97
  98         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
  99
 100         enum Flag {
 101                 Auditioner = 0x1,
 102                 MasterOut = 0x2,
 103                 MonitorOut = 0x4
 104         };
 105
 106         Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
 107         virtual ~Route();
 108
 109         virtual int init ();
 110
 111         boost::shared_ptr<IO> input() const { return _input; }
 112         boost::shared_ptr<IO> output() const { return _output; }
 113         IOVector all_inputs () const;
 114         IOVector all_outputs () const;
 115
 116         ChanCount n_inputs() const { return _input->n_ports(); }
 117         ChanCount n_outputs() const { return _output->n_ports(); }
 118
 119         bool active() const { return _active; }
 120         void set_active (bool yn, void *);
 121
 122         static std::string ensure_track_or_route_name(std::string, Session &);
 123
 124         std::string comment() { return _comment; }
 125         void set_comment (std::string str, void *src);
 126
 127         bool set_name (const std::string& str);
 128         static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true);
 129
 130         uint32_t order_key () const;
 131         bool has_order_key () const;
 132         void set_order_key (uint32_t);
 133
 134         bool is_auditioner() const { return _flags & Auditioner; }
 135         bool is_master() const { return _flags & MasterOut; }
 136         bool is_monitor() const { return _flags & MonitorOut; }
 137
 138         MonitorState monitoring_state () const;
 139         virtual MeterState metering_state () const;
 140
 141         /* these are the core of the API of a Route. see the protected sections as well */
 142
 143         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 144                           int declick, bool& need_butler);
 145
 146         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 147                              bool state_changing);
 148
 149         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 150                                  bool& need_butler);
 151
 152         virtual bool can_record() { return false; }
 153
 154         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 155         virtual void realtime_handle_transport_stopped () {}
 156         virtual void realtime_locate () {}
 157         virtual void non_realtime_locate (framepos_t);
 158         virtual void set_pending_declick (int);
 159
 160         /* end of vfunc-based API */
 161
 162         void shift (framepos_t, framecnt_t);
 163
 164         void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
 165
 166         /* controls use set_solo() to modify this route's solo state
 167          */
 168
 169         void clear_all_solo_state ();
 170
 171         bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
 172         bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
 173         bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
 174         bool self_soloed () const { return _solo_control->self_soloed(); }
 175         bool soloed () const { return self_soloed () || soloed_by_others (); }
 176
 177         void push_solo_upstream (int32_t delta);
 178         void push_solo_isolate_upstream (int32_t delta);
 179         bool can_solo () const {
 180                 return !(is_master() || is_monitor() || is_auditioner());
 181         }
 182         bool is_safe () const {
 183                 return _solo_safe_control->get_value();
 184         }
 185         void enable_monitor_send ();
 186
 187         void set_denormal_protection (bool yn);
 188         bool denormal_protection() const;
 189
 190         void         set_meter_point (MeterPoint, bool force = false);
 191         bool         apply_processor_changes_rt ();
 192         void         emit_pending_signals ();
 193         MeterPoint   meter_point() const { return _pending_meter_point; }
 194
 195         void         set_meter_type (MeterType t) { _meter_type = t; }
 196         MeterType    meter_type() const { return _meter_type; }
 197
 198         /* Processors */
 199
 200         boost::shared_ptr<Amp> amp() const  { return _amp; }
 201         boost::shared_ptr<Amp> trim() const { return _trim; }
 202         boost::shared_ptr<PeakMeter>       peak_meter()       { return _meter; }
 203         boost::shared_ptr<const PeakMeter> peak_meter() const { return _meter; }
 204         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 205         boost::shared_ptr<DelayLine> delay_line() const  { return _delayline; }
 206
 207         void flush_processors ();
 208
 209         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 210                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 211                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 212                         method (boost::weak_ptr<Processor> (*i));
 213                 }
 214         }
 215
 216         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 217                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 218                 ProcessorList::iterator i;
 219                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 220                 if (i == _processors.end()) {
 221                         return boost::shared_ptr<Processor> ();
 222                 } else {
 223                         return *i;
 224                 }
 225         }
 226
 227         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 228
 229         boost::shared_ptr<Processor> nth_plugin (uint32_t n) const;
 230         boost::shared_ptr<Processor> nth_send (uint32_t n) const;
 231
 232         bool has_io_processor_named (const std::string&);
 233         ChanCount max_processor_streams () const { return processor_max_streams; }
 234
 235         std::list<std::string> unknown_processors () const;
 236
 237         RoutePinWindowProxy * pinmgr_proxy () const { return _pinmgr_proxy; }
 238         void set_pingmgr_proxy (RoutePinWindowProxy* wp) { _pinmgr_proxy = wp ; }
 239
 240         /* special processors */
 241
 242         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 243         /** the signal processorat at end of the processing chain which produces output */
 244         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 245         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 246         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 247         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 248         void add_internal_return ();
 249         void add_send_to_internal_return (InternalSend *);
 250         void remove_send_from_internal_return (InternalSend *);
 251         void listen_position_changed ();
 252         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 253
 254         /** A record of the stream configuration at some point in the processor list.
 255          * Used to return where and why an processor list configuration request failed.
 256          */
 257         struct ProcessorStreams {
 258                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 259
 260                 uint32_t  index; ///< Index of processor where configuration failed
 261                 ChanCount count; ///< Input requested of processor
 262         };
 263
 264         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 265         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 266         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 267         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 268         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 269         boost::shared_ptr<Processor> before_processor_for_index (int);
 270         bool processors_reorder_needs_configure (const ProcessorList& new_order);
 271         /** remove plugin/processor
 272          *
 273          * @param proc processor to remove
 274          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 275          * @param need_process_lock if locking is required (set to true, unless called from RT context with lock)
 276          * @returns 0 on success
 277          */
 278         int remove_processor (boost::shared_ptr<Processor> proc, ProcessorStreams* err = 0, bool need_process_lock = true);
 279         /** replace plugin/processor with another
 280          *
 281          * @param old processor to remove
 282          * @param sub processor to substitute the old one with
 283          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 284          * @returns 0 on success
 285          */
 286         int replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err = 0);
 287         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 288         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 289         void disable_processors (Placement);
 290         void disable_processors ();
 291         void disable_plugins (Placement);
 292         void disable_plugins ();
 293         void ab_plugins (bool forward);
 294         void clear_processors (Placement);
 295         void all_visible_processors_active (bool);
 296
 297         bool strict_io () const { return _strict_io; }
 298         bool set_strict_io (bool);
 299         /** reset plugin-insert configuration to default, disable customizations.
 300          *
 301          * This is equivalent to calling
 302          * @code
 303          * customize_plugin_insert (proc, 0, unused)
 304          * @endcode
 305          *
 306          * @param proc Processor to reset
 307          * @returns true if successful
 308          */
 309         bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
 310         /** enable custom plugin-insert configuration
 311          * @param proc Processor to customize
 312          * @param count number of plugin instances to use (if zero, reset to default)
 313          * @param outs output port customization
 314          * @param sinks input pins for variable-I/O plugins
 315          * @returns true if successful
 316          */
 317         bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks);
 318         bool add_remove_sidechain (boost::shared_ptr<Processor> proc, bool);
 319         bool plugin_preset_output (boost::shared_ptr<Processor> proc, ChanCount outs);
 320
 321         /* enable sidechain input for a given processor
 322          *
 323          * The sidechain itself is an IO port object with variable number of channels and configured independently.
 324          * Adding/removing the port itself however requires reconfiguring the route and is hence
 325          * not a plugin operation itself.
 326          *
 327          * @param proc the processor to add sidechain inputs to
 328          * @returns true on success
 329          */
 330         bool add_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, true); }
 331         /* remove sidechain input from given processor
 332          * @param proc the processor to remove the sidechain input from
 333          * @returns true on success
 334          */
 335         bool remove_sidechain (boost::shared_ptr<Processor> proc) { return add_remove_sidechain (proc, false); }
 336
 337         framecnt_t set_private_port_latencies (bool playback) const;
 338         void       set_public_port_latencies (framecnt_t, bool playback) const;
 339
 340         framecnt_t   update_signal_latency();
 341         virtual void set_latency_compensation (framecnt_t);
 342
 343         void set_user_latency (framecnt_t);
 344         framecnt_t initial_delay() const { return _initial_delay; }
 345         framecnt_t signal_latency() const { return _signal_latency; }
 346
 347         PBD::Signal0<void>       active_changed;
 348         PBD::Signal0<void>       denormal_protection_changed;
 349         PBD::Signal0<void>       comment_changed;
 350
 351         /** track numbers - assigned by session
 352          * nubers > 0 indicate tracks (audio+midi)
 353          * nubers < 0 indicate busses
 354          * zero is reserved for unnumbered special busses.
 355          * */
 356         PBD::Signal0<void> track_number_changed;
 357         int64_t track_number() const { return _track_number; }
 358
 359         void set_track_number(int64_t tn) {
 360                 if (tn == _track_number) { return; }
 361                 _track_number = tn;
 362                 track_number_changed();
 363                 PropertyChanged (ARDOUR::Properties::name);
 364         }
 365
 366         enum PluginSetupOptions {
 367                 None = 0x0,
 368                 CanReplace = 0x1,
 369                 MultiOut = 0x2,
 370         };
 371
 372         static PBD::Signal3<int,boost::shared_ptr<Route>, boost::shared_ptr<PluginInsert>, PluginSetupOptions > PluginSetup;
 373
 374         /** the processors have changed; the parameter indicates what changed */
 375         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 376         PBD::Signal1<void,void*> record_enable_changed;
 377         /** the metering point has changed */
 378         PBD::Signal0<void>       meter_change;
 379         PBD::Signal0<void>       signal_latency_changed;
 380         PBD::Signal0<void>       initial_delay_changed;
 381
 382         /** Emitted with the process lock held */
 383         PBD::Signal0<void>       io_changed;
 384
 385         /* gui's call this for their own purposes. */
 386
 387         PBD::Signal2<void,std::string,void*> gui_changed;
 388
 389         /* stateful */
 390
 391         XMLNode& get_state();
 392         virtual int set_state (const XMLNode&, int version);
 393         virtual XMLNode& get_template();
 394
 395         XMLNode& get_processor_state ();
 396         virtual void set_processor_state (const XMLNode&);
 397
 398         int save_as_template (const std::string& path, const std::string& name);
 399
 400         PBD::Signal1<void,void*> SelectedChanged;
 401
 402         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 403         void remove_aux_or_listen (boost::shared_ptr<Route>);
 404
 405         /**
 406          * return true if this route feeds the first argument via at least one
 407          * (arbitrarily long) signal pathway.
 408          */
 409         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 410
 411         /**
 412          * return true if this route feeds the first argument directly, via
 413          * either its main outs or a send.  This is checked by the actual
 414          * connections, rather than by what the graph is currently doing.
 415          */
 416         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 417
 418         /**
 419          * return true if this route feeds the first argument directly, via
 420          * either its main outs or a send, according to the graph that
 421          * is currently being processed.
 422          */
 423         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 424
 425         bool feeds_according_to_graph (boost::shared_ptr<Route>);
 426
 427         struct FeedRecord {
 428                 boost::weak_ptr<Route> r;
 429                 bool sends_only;
 430
 431                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 432                 : r (rp)
 433                 , sends_only (sendsonly) {}
 434         };
 435
 436         struct FeedRecordCompare {
 437                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 438                         return a.r < b.r;
 439                 }
 440         };
 441
 442         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 443
 444         const FedBy& fed_by() const { return _fed_by; }
 445         void clear_fed_by ();
 446         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 447
 448         /* Controls (not all directly owned by the Route) */
 449
 450         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 451
 452         boost::shared_ptr<SoloControl> solo_control() const {
 453                 return _solo_control;
 454         }
 455
 456         boost::shared_ptr<MuteControl> mute_control() const {
 457                 return _mute_control;
 458         }
 459
 460         bool can_be_muted_by_others () const { return !is_master(); }
 461         bool muted () const { return _mute_control->muted(); }
 462         bool muted_by_masters () const { return _mute_control->muted_by_masters(); }
 463         bool muted_by_self () const { return _mute_control->muted_by_self(); }
 464         bool muted_by_others_soloing () const;
 465
 466         boost::shared_ptr<SoloIsolateControl> solo_isolate_control() const {
 467                 return _solo_isolate_control;
 468         }
 469
 470         boost::shared_ptr<SoloSafeControl> solo_safe_control() const {
 471                 return _solo_safe_control;
 472         }
 473
 474         boost::shared_ptr<MonitorControl> monitoring_control() const {
 475                 /* tracks override this to provide actual monitoring control;
 476                    busses have no possible choices except input monitoring.
 477                 */
 478                 return boost::shared_ptr<MonitorControl> ();
 479         }
 480
 481         /* Route doesn't own these items, but sub-objects that it does own have them
 482            and to make UI code a bit simpler, we provide direct access to them
 483            here.
 484         */
 485
 486         boost::shared_ptr<Panner> panner() const;  /* may return null */
 487         boost::shared_ptr<PannerShell> panner_shell() const;
 488         boost::shared_ptr<Pannable> pannable() const;
 489
 490         boost::shared_ptr<GainControl> gain_control() const;
 491         boost::shared_ptr<GainControl> trim_control() const;
 492         boost::shared_ptr<PhaseControl> phase_control() const;
 493
 494         /**
 495            Return the first processor that accepts has at least one MIDI input
 496            and at least one audio output. In the vast majority of cases, this
 497            will be "the instrument". This does not preclude other MIDI->audio
 498            processors later in the processing chain, but that would be a
 499            special case not covered by this utility function.
 500         */
 501         boost::shared_ptr<Processor> the_instrument() const;
 502         InstrumentInfo& instrument_info() { return _instrument_info; }
 503
 504         /* "well-known" controls for panning. Any or all of these may return
 505          * null.
 506          */
 507
 508         boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
 509         boost::shared_ptr<AutomationControl> pan_elevation_control() const;
 510         boost::shared_ptr<AutomationControl> pan_width_control() const;
 511         boost::shared_ptr<AutomationControl> pan_frontback_control() const;
 512         boost::shared_ptr<AutomationControl> pan_lfe_control() const;
 513
 514         /* "well-known" controls for an EQ in this route. Any or all may
 515          * be null. eq_band_cnt() must return 0 if there is no EQ present.
 516          * Passing an @param band value >= eq_band_cnt() will guarantee the
 517          * return of a null ptr (or an empty string for eq_band_name()).
 518          */
 519         uint32_t eq_band_cnt () const;
 520         std::string eq_band_name (uint32_t) const;
 521         boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
 522         boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
 523         boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
 524         boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
 525         boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
 526         boost::shared_ptr<AutomationControl> eq_hpf_controllable () const;
 527
 528         /* "well-known" controls for a compressor in this route. Any or all may
 529          * be null.
 530          */
 531         boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
 532         boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
 533         boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
 534         boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
 535         boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
 536         boost::shared_ptr<AutomationControl> comp_redux_controllable () const;
 537
 538         /* @param mode must be supplied by the comp_mode_controllable(). All other values
 539          * result in undefined behaviour
 540          */
 541         std::string comp_mode_name (uint32_t mode) const;
 542         /* @param mode - as for comp mode name. This returns the name for the
 543          * parameter/control accessed via comp_speed_controllable(), which can
 544          * be mode dependent.
 545          */
 546         std::string comp_speed_name (uint32_t mode) const;
 547
 548         /* "well-known" controls for sends to well-known busses in this route. Any or all may
 549          * be null.
 550          *
 551          * In Mixbus, these are the sends that connect to the mixbusses.
 552          * In Ardour, these are user-created sends that connect to user-created
 553          * Aux busses.
 554          */
 555         boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
 556         boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
 557         /* for the same value of @param n, this returns the name of the send
 558          * associated with the pair of controllables returned by the above two methods.
 559          */
 560         std::string send_name (uint32_t n) const;
 561
 562         /* well known control that enables/disables sending to the master bus.
 563          *
 564          * In Ardour, this returns null.
 565          * In Mixbus, it will return a suitable control, or null depending on
 566          * the route.
 567          */
 568         boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
 569
 570         void protect_automation ();
 571
 572         enum {
 573                 /* These numbers are taken from MIDI Machine Control,
 574                    which can only control up to 317 tracks without
 575                    doing sysex segmentation.
 576                 */
 577                 MasterBusRemoteControlID = 318,
 578                 MonitorBusRemoteControlID = 319,
 579         };
 580
 581         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 582         uint32_t remote_control_id () const;
 583         void     set_remote_control_id_explicit (uint32_t order_key);
 584
 585         /* for things concerned about *this* route's RID */
 586
 587         PBD::Signal0<void> RemoteControlIDChanged;
 588
 589         /* for things concerned about *any* route's RID changes */
 590
 591         static PBD::Signal0<void> RemoteControlIDChange;
 592         static PBD::Signal0<void> SyncOrderKeys;
 593
 594         bool has_external_redirects() const;
 595
 596         /* can only be executed by a route for which is_monitor() is true
 597          *       (i.e. the monitor out)
 598          */
 599         void monitor_run (framepos_t start_frame, framepos_t end_frame,
 600                         pframes_t nframes, int declick);
 601
 602         bool slaved_to (boost::shared_ptr<VCA>) const;
 603
 604   protected:
 605         friend class Session;
 606
 607         void catch_up_on_solo_mute_override ();
 608         void set_listen (bool);
 609
 610         void curve_reallocate ();
 611         virtual void set_block_size (pframes_t nframes);
 612
 613   protected:
 614         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 615
 616         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 617
 618         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 619                         pframes_t nframes, int declick);
 620
 621         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 622                                              framecnt_t /* nframes */) {}
 623
 624         virtual void process_output_buffers (BufferSet& bufs,
 625                                              framepos_t start_frame, framepos_t end_frame,
 626                                              pframes_t nframes, int declick,
 627                                              bool gain_automation_ok);
 628
 629         virtual void bounce_process (BufferSet& bufs,
 630                                      framepos_t start_frame, framecnt_t nframes,
 631                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 632                                      bool for_export, bool for_freeze);
 633
 634         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 635         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 636
 637         boost::shared_ptr<IO> _input;
 638         boost::shared_ptr<IO> _output;
 639
 640         bool           _active;
 641         framecnt_t     _signal_latency;
 642         framecnt_t     _signal_latency_at_amp_position;
 643         framecnt_t     _signal_latency_at_trim_position;
 644         framecnt_t     _initial_delay;
 645         framecnt_t     _roll_delay;
 646
 647         ProcessorList  _processors;
 648         mutable Glib::Threads::RWLock   _processor_lock;
 649         boost::shared_ptr<Delivery> _main_outs;
 650         boost::shared_ptr<InternalSend> _monitor_send;
 651         boost::shared_ptr<InternalReturn> _intreturn;
 652         boost::shared_ptr<MonitorProcessor> _monitor_control;
 653         boost::shared_ptr<Pannable> _pannable;
 654
 655         enum {
 656                 EmitNone = 0x00,
 657                 EmitMeterChanged = 0x01,
 658                 EmitMeterVisibilityChange = 0x02,
 659                 EmitRtProcessorChange = 0x04
 660         };
 661
 662         ProcessorList  _pending_processor_order;
 663         gint           _pending_process_reorder; // atomic
 664         gint           _pending_signals; // atomic
 665
 666         Flag           _flags;
 667         int            _pending_declick;
 668         MeterPoint     _meter_point;
 669         MeterPoint     _pending_meter_point;
 670         MeterType      _meter_type;
 671
 672         bool           _denormal_protection;
 673
 674         bool _recordable : 1;
 675         bool _silent : 1;
 676         bool _declickable : 1;
 677
 678         boost::shared_ptr<SoloControl> _solo_control;
 679         boost::shared_ptr<MuteControl> _mute_control;
 680         boost::shared_ptr<PhaseControl> _phase_control;
 681         boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
 682         boost::shared_ptr<SoloSafeControl> _solo_safe_control;
 683
 684         std::string    _comment;
 685         bool           _have_internal_generator;
 686         DataType       _default_type;
 687         FedBy          _fed_by;
 688
 689         InstrumentInfo _instrument_info;
 690
 691         virtual ChanCount input_streams () const;
 692
 693 protected:
 694         virtual XMLNode& state(bool);
 695
 696         int configure_processors (ProcessorStreams*);
 697
 698         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 699                                pframes_t nframes, int declick);
 700
 701         void silence (framecnt_t);
 702         void silence_unlocked (framecnt_t);
 703
 704         ChanCount processor_max_streams;
 705         ChanCount processor_out_streams;
 706
 707         uint32_t pans_required() const;
 708         ChanCount n_process_buffers ();
 709
 710         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 711
 712         boost::shared_ptr<GainControl> _gain_control;
 713         boost::shared_ptr<Amp>       _amp;
 714         boost::shared_ptr<GainControl> _trim_control;
 715         boost::shared_ptr<Amp>       _trim;
 716         boost::shared_ptr<PeakMeter> _meter;
 717         boost::shared_ptr<DelayLine> _delayline;
 718
 719         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 720
 721 private:
 722         int set_state_2X (const XMLNode&, int);
 723         void set_processor_state_2X (XMLNodeList const &, int);
 724
 725         uint32_t _order_key;
 726         bool _has_order_key;
 727         uint32_t _remote_control_id;
 728
 729         int64_t _track_number;
 730
 731         void input_change_handler (IOChange, void *src);
 732         void output_change_handler (IOChange, void *src);
 733         void sidechain_change_handler (IOChange, void *src);
 734
 735         void processor_selfdestruct (boost::weak_ptr<Processor>);
 736         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 737         Glib::Threads::Mutex  selfdestruct_lock;
 738
 739         bool input_port_count_changing (ChanCount);
 740         bool output_port_count_changing (ChanCount);
 741
 742         bool _in_configure_processors;
 743         bool _initial_io_setup;
 744         bool _in_sidechain_setup;
 745
 746         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 747         bool set_meter_point_unlocked ();
 748         void apply_processor_order (const ProcessorList& new_order);
 749
 750         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 751         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 752
 753         bool add_processor_from_xml_2X (const XMLNode&, int);
 754
 755         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 756
 757         void set_self_solo (bool yn);
 758
 759         void set_processor_positions ();
 760         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 761
 762         void setup_invisible_processors ();
 763         void unpan ();
 764
 765         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 766
 767         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 768
 769         /** A handy class to keep processor state while we attempt a reconfiguration
 770          *  that may fail.
 771          */
 772         class ProcessorState {
 773         public:
 774                 ProcessorState (Route* r)
 775                         : _route (r)
 776                         , _processors (r->_processors)
 777                         , _processor_max_streams (r->processor_max_streams)
 778                 { }
 779
 780                 void restore () {
 781                         _route->_processors = _processors;
 782                         _route->processor_max_streams = _processor_max_streams;
 783                 }
 784
 785         private:
 786                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 787                    not hang around long enough for it to matter.
 788                 */
 789                 Route* _route;
 790                 ProcessorList _processors;
 791                 ChanCount _processor_max_streams;
 792         };
 793
 794         friend class ProcessorState;
 795
 796         bool _strict_io;
 797
 798         /* no copy construction */
 799         Route (Route const &);
 800
 801         void maybe_note_meter_position ();
 802
 803         /** true if we've made a note of a custom meter position in these variables */
 804         bool _custom_meter_position_noted;
 805         /** the processor that came after the meter when it was last set to a custom position,
 806             or 0.
 807         */
 808         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 809         RoutePinWindowProxy *_pinmgr_proxy;
 810
 811         void reset_instrument_info ();
 812
 813         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 814         void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
 815 };
 816
 817 } // namespace ARDOUR
 818
 819 #endif /* __ardour_route_h__ */