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