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
  61 class RoutePinWindowProxy;
  62
  63 namespace ARDOUR {
  64
  65 class Amp;
  66 class DelayLine;
  67 class Delivery;
  68 class IOProcessor;
  69 class Panner;
  70 class PannerShell;
  71 class PortSet;
  72 class Processor;
  73 class PluginInsert;
  74 class RouteGroup;
  75 class Send;
  76 class InternalReturn;
  77 class MonitorProcessor;
  78 class Pannable;
  79 class CapturingProcessor;
  80 class InternalSend;
  81 class VCA;
  82 class SoloIsolateControl;
  83 class PhaseControl;
  84 class MonitorControl;
  85
  86 class LIBARDOUR_API Route : public Stripable,
  87                             public Soloable,
  88                             public Muteable,
  89                             public Monitorable,
  90                             public Automatable,
  91                             public RouteGroupMember,
  92                             public GraphNode,
  93                             public boost::enable_shared_from_this<Route>
  94 {
  95 public:
  96
  97         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
  98
  99         enum Flag {
 100                 Auditioner = 0x1,
 101                 MasterOut = 0x2,
 102                 MonitorOut = 0x4
 103         };
 104
 105         Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
 106         virtual ~Route();
 107
 108         virtual int init ();
 109
 110         boost::shared_ptr<IO> input() const { return _input; }
 111         boost::shared_ptr<IO> output() const { return _output; }
 112         IOVector all_inputs () const;
 113         IOVector all_outputs () const;
 114
 115         ChanCount n_inputs() const { return _input->n_ports(); }
 116         ChanCount n_outputs() const { return _output->n_ports(); }
 117
 118         bool active() const { return _active; }
 119         void set_active (bool yn, void *);
 120
 121         static std::string ensure_track_or_route_name(std::string, Session &);
 122
 123         std::string comment() { return _comment; }
 124         void set_comment (std::string str, void *src);
 125
 126         bool set_name (const std::string& str);
 127         static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true);
 128
 129         uint32_t order_key () const;
 130         bool has_order_key () const;
 131         void set_order_key (uint32_t);
 132
 133         bool is_auditioner() const { return _flags & Auditioner; }
 134         bool is_master() const { return _flags & MasterOut; }
 135         bool is_monitor() const { return _flags & MonitorOut; }
 136
 137         MonitorState monitoring_state () const;
 138         virtual MeterState metering_state () const;
 139
 140         /* these are the core of the API of a Route. see the protected sections as well */
 141
 142         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 143                           int declick, bool& need_butler);
 144
 145         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 146                              bool state_changing);
 147
 148         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 149                                  bool& need_butler);
 150
 151         virtual bool can_record() { return false; }
 152
 153         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 154         virtual void realtime_handle_transport_stopped () {}
 155         virtual void realtime_locate () {}
 156         virtual void non_realtime_locate (framepos_t);
 157         virtual void set_pending_declick (int);
 158
 159         /* end of vfunc-based API */
 160
 161         void shift (framepos_t, framecnt_t);
 162
 163         void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
 164
 165         /* controls use set_solo() to modify this route's solo state
 166          */
 167
 168         void clear_all_solo_state ();
 169
 170         bool soloed_by_others () const { return _solo_control->soloed_by_others(); }
 171         bool soloed_by_others_upstream () const { return _solo_control->soloed_by_others_upstream(); }
 172         bool soloed_by_others_downstream () const { return _solo_control->soloed_by_others_downstream(); }
 173         bool self_soloed () const { return _solo_control->self_soloed(); }
 174         bool soloed () const { return self_soloed () || soloed_by_others (); }
 175
 176         void push_solo_upstream (int32_t delta);
 177         void push_solo_isolate_upstream (int32_t delta);
 178         bool can_solo () const {
 179                 return !(is_master() || is_monitor() || is_auditioner());
 180         }
 181         bool is_safe () const {
 182                 return _solo_safe_control->get_value();
 183         }
 184
 185         bool listening_via_monitor () const;
 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         void vca_assign (boost::shared_ptr<VCA>);
 605         void vca_unassign (boost::shared_ptr<VCA>);
 606
 607   protected:
 608         friend class Session;
 609
 610         void catch_up_on_solo_mute_override ();
 611         void set_listen (bool);
 612
 613         void curve_reallocate ();
 614         virtual void set_block_size (pframes_t nframes);
 615
 616 protected:
 617         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 618
 619         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 620
 621         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 622                         pframes_t nframes, int declick);
 623
 624         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 625                                              framecnt_t /* nframes */) {}
 626
 627         virtual void process_output_buffers (BufferSet& bufs,
 628                                              framepos_t start_frame, framepos_t end_frame,
 629                                              pframes_t nframes, int declick,
 630                                              bool gain_automation_ok);
 631
 632         virtual void bounce_process (BufferSet& bufs,
 633                                      framepos_t start_frame, framecnt_t nframes,
 634                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 635                                      bool for_export, bool for_freeze);
 636
 637         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 638         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 639
 640         boost::shared_ptr<IO> _input;
 641         boost::shared_ptr<IO> _output;
 642
 643         bool           _active;
 644         framecnt_t     _signal_latency;
 645         framecnt_t     _signal_latency_at_amp_position;
 646         framecnt_t     _signal_latency_at_trim_position;
 647         framecnt_t     _initial_delay;
 648         framecnt_t     _roll_delay;
 649
 650         ProcessorList  _processors;
 651         mutable Glib::Threads::RWLock   _processor_lock;
 652         boost::shared_ptr<Delivery> _main_outs;
 653         boost::shared_ptr<InternalSend> _monitor_send;
 654         boost::shared_ptr<InternalReturn> _intreturn;
 655         boost::shared_ptr<MonitorProcessor> _monitor_control;
 656         boost::shared_ptr<Pannable> _pannable;
 657
 658         enum {
 659                 EmitNone = 0x00,
 660                 EmitMeterChanged = 0x01,
 661                 EmitMeterVisibilityChange = 0x02,
 662                 EmitRtProcessorChange = 0x04
 663         };
 664
 665         ProcessorList  _pending_processor_order;
 666         gint           _pending_process_reorder; // atomic
 667         gint           _pending_signals; // atomic
 668
 669         Flag           _flags;
 670         int            _pending_declick;
 671         MeterPoint     _meter_point;
 672         MeterPoint     _pending_meter_point;
 673         MeterType      _meter_type;
 674
 675         bool           _denormal_protection;
 676
 677         bool _recordable : 1;
 678         bool _silent : 1;
 679         bool _declickable : 1;
 680
 681         boost::shared_ptr<SoloControl> _solo_control;
 682         boost::shared_ptr<MuteControl> _mute_control;
 683         boost::shared_ptr<PhaseControl> _phase_control;
 684         boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
 685         boost::shared_ptr<SoloSafeControl> _solo_safe_control;
 686
 687         std::string    _comment;
 688         bool           _have_internal_generator;
 689         DataType       _default_type;
 690         FedBy          _fed_by;
 691
 692         InstrumentInfo _instrument_info;
 693
 694         virtual ChanCount input_streams () const;
 695
 696 protected:
 697         virtual XMLNode& state(bool);
 698
 699         int configure_processors (ProcessorStreams*);
 700
 701         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 702                                pframes_t nframes, int declick);
 703
 704         void silence (framecnt_t);
 705         void silence_unlocked (framecnt_t);
 706
 707         ChanCount processor_max_streams;
 708         ChanCount processor_out_streams;
 709
 710         uint32_t pans_required() const;
 711         ChanCount n_process_buffers ();
 712
 713         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 714
 715         boost::shared_ptr<GainControl> _gain_control;
 716         boost::shared_ptr<Amp>       _amp;
 717         boost::shared_ptr<GainControl> _trim_control;
 718         boost::shared_ptr<Amp>       _trim;
 719         boost::shared_ptr<PeakMeter> _meter;
 720         boost::shared_ptr<DelayLine> _delayline;
 721
 722         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 723
 724 private:
 725         int set_state_2X (const XMLNode&, int);
 726         void set_processor_state_2X (XMLNodeList const &, int);
 727
 728         uint32_t _order_key;
 729         bool _has_order_key;
 730         uint32_t _remote_control_id;
 731
 732         int64_t _track_number;
 733
 734         void input_change_handler (IOChange, void *src);
 735         void output_change_handler (IOChange, void *src);
 736         void sidechain_change_handler (IOChange, void *src);
 737
 738         void processor_selfdestruct (boost::weak_ptr<Processor>);
 739         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 740         Glib::Threads::Mutex  selfdestruct_lock;
 741
 742         bool input_port_count_changing (ChanCount);
 743         bool output_port_count_changing (ChanCount);
 744
 745         bool _in_configure_processors;
 746         bool _initial_io_setup;
 747         bool _in_sidechain_setup;
 748
 749         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 750         bool set_meter_point_unlocked ();
 751         void apply_processor_order (const ProcessorList& new_order);
 752
 753         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 754         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 755
 756         bool add_processor_from_xml_2X (const XMLNode&, int);
 757
 758         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 759
 760         void set_self_solo (bool yn);
 761
 762         void set_processor_positions ();
 763         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 764
 765         void setup_invisible_processors ();
 766         void unpan ();
 767
 768         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 769
 770         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 771
 772         /** A handy class to keep processor state while we attempt a reconfiguration
 773          *  that may fail.
 774          */
 775         class ProcessorState {
 776         public:
 777                 ProcessorState (Route* r)
 778                         : _route (r)
 779                         , _processors (r->_processors)
 780                         , _processor_max_streams (r->processor_max_streams)
 781                 { }
 782
 783                 void restore () {
 784                         _route->_processors = _processors;
 785                         _route->processor_max_streams = _processor_max_streams;
 786                 }
 787
 788         private:
 789                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 790                    not hang around long enough for it to matter.
 791                 */
 792                 Route* _route;
 793                 ProcessorList _processors;
 794                 ChanCount _processor_max_streams;
 795         };
 796
 797         friend class ProcessorState;
 798
 799         bool _strict_io;
 800
 801         /* no copy construction */
 802         Route (Route const &);
 803
 804         void maybe_note_meter_position ();
 805
 806         /** true if we've made a note of a custom meter position in these variables */
 807         bool _custom_meter_position_noted;
 808         /** the processor that came after the meter when it was last set to a custom position,
 809             or 0.
 810         */
 811         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 812         RoutePinWindowProxy *_pinmgr_proxy;
 813
 814         void reset_instrument_info ();
 815
 816         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 817         void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
 818 };
 819
 820 } // namespace ARDOUR
 821
 822 #endif /* __ardour_route_h__ */