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_others_soloing () const;
 464         bool muted_by_others () 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         void vca_assign (boost::shared_ptr<VCA>);
 604         void vca_unassign (boost::shared_ptr<VCA>);
 605
 606   protected:
 607         friend class Session;
 608
 609         void catch_up_on_solo_mute_override ();
 610         void set_listen (bool);
 611
 612         void curve_reallocate ();
 613         virtual void set_block_size (pframes_t nframes);
 614
 615 protected:
 616         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 617
 618         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 619
 620         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 621                         pframes_t nframes, int declick);
 622
 623         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 624                                              framecnt_t /* nframes */) {}
 625
 626         virtual void process_output_buffers (BufferSet& bufs,
 627                                              framepos_t start_frame, framepos_t end_frame,
 628                                              pframes_t nframes, int declick,
 629                                              bool gain_automation_ok);
 630
 631         virtual void bounce_process (BufferSet& bufs,
 632                                      framepos_t start_frame, framecnt_t nframes,
 633                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 634                                      bool for_export, bool for_freeze);
 635
 636         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 637         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 638
 639         boost::shared_ptr<IO> _input;
 640         boost::shared_ptr<IO> _output;
 641
 642         bool           _active;
 643         framecnt_t     _signal_latency;
 644         framecnt_t     _signal_latency_at_amp_position;
 645         framecnt_t     _signal_latency_at_trim_position;
 646         framecnt_t     _initial_delay;
 647         framecnt_t     _roll_delay;
 648
 649         ProcessorList  _processors;
 650         mutable Glib::Threads::RWLock   _processor_lock;
 651         boost::shared_ptr<Delivery> _main_outs;
 652         boost::shared_ptr<InternalSend> _monitor_send;
 653         boost::shared_ptr<InternalReturn> _intreturn;
 654         boost::shared_ptr<MonitorProcessor> _monitor_control;
 655         boost::shared_ptr<Pannable> _pannable;
 656
 657         enum {
 658                 EmitNone = 0x00,
 659                 EmitMeterChanged = 0x01,
 660                 EmitMeterVisibilityChange = 0x02,
 661                 EmitRtProcessorChange = 0x04
 662         };
 663
 664         ProcessorList  _pending_processor_order;
 665         gint           _pending_process_reorder; // atomic
 666         gint           _pending_signals; // atomic
 667
 668         Flag           _flags;
 669         int            _pending_declick;
 670         MeterPoint     _meter_point;
 671         MeterPoint     _pending_meter_point;
 672         MeterType      _meter_type;
 673
 674         bool           _denormal_protection;
 675
 676         bool _recordable : 1;
 677         bool _silent : 1;
 678         bool _declickable : 1;
 679
 680         boost::shared_ptr<SoloControl> _solo_control;
 681         boost::shared_ptr<MuteControl> _mute_control;
 682         boost::shared_ptr<PhaseControl> _phase_control;
 683         boost::shared_ptr<SoloIsolateControl> _solo_isolate_control;
 684         boost::shared_ptr<SoloSafeControl> _solo_safe_control;
 685
 686         std::string    _comment;
 687         bool           _have_internal_generator;
 688         DataType       _default_type;
 689         FedBy          _fed_by;
 690
 691         InstrumentInfo _instrument_info;
 692
 693         virtual ChanCount input_streams () const;
 694
 695 protected:
 696         virtual XMLNode& state(bool);
 697
 698         int configure_processors (ProcessorStreams*);
 699
 700         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 701                                pframes_t nframes, int declick);
 702
 703         void silence (framecnt_t);
 704         void silence_unlocked (framecnt_t);
 705
 706         ChanCount processor_max_streams;
 707         ChanCount processor_out_streams;
 708
 709         uint32_t pans_required() const;
 710         ChanCount n_process_buffers ();
 711
 712         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 713
 714         boost::shared_ptr<GainControl> _gain_control;
 715         boost::shared_ptr<Amp>       _amp;
 716         boost::shared_ptr<GainControl> _trim_control;
 717         boost::shared_ptr<Amp>       _trim;
 718         boost::shared_ptr<PeakMeter> _meter;
 719         boost::shared_ptr<DelayLine> _delayline;
 720
 721         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 722
 723 private:
 724         int set_state_2X (const XMLNode&, int);
 725         void set_processor_state_2X (XMLNodeList const &, int);
 726
 727         uint32_t _order_key;
 728         bool _has_order_key;
 729         uint32_t _remote_control_id;
 730
 731         int64_t _track_number;
 732
 733         void input_change_handler (IOChange, void *src);
 734         void output_change_handler (IOChange, void *src);
 735         void sidechain_change_handler (IOChange, void *src);
 736
 737         void processor_selfdestruct (boost::weak_ptr<Processor>);
 738         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 739         Glib::Threads::Mutex  selfdestruct_lock;
 740
 741         bool input_port_count_changing (ChanCount);
 742         bool output_port_count_changing (ChanCount);
 743
 744         bool _in_configure_processors;
 745         bool _initial_io_setup;
 746         bool _in_sidechain_setup;
 747
 748         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 749         bool set_meter_point_unlocked ();
 750         void apply_processor_order (const ProcessorList& new_order);
 751
 752         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 753         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 754
 755         bool add_processor_from_xml_2X (const XMLNode&, int);
 756
 757         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 758
 759         void set_self_solo (bool yn);
 760
 761         void set_processor_positions ();
 762         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 763
 764         void setup_invisible_processors ();
 765         void unpan ();
 766
 767         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 768
 769         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 770
 771         /** A handy class to keep processor state while we attempt a reconfiguration
 772          *  that may fail.
 773          */
 774         class ProcessorState {
 775         public:
 776                 ProcessorState (Route* r)
 777                         : _route (r)
 778                         , _processors (r->_processors)
 779                         , _processor_max_streams (r->processor_max_streams)
 780                 { }
 781
 782                 void restore () {
 783                         _route->_processors = _processors;
 784                         _route->processor_max_streams = _processor_max_streams;
 785                 }
 786
 787         private:
 788                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 789                    not hang around long enough for it to matter.
 790                 */
 791                 Route* _route;
 792                 ProcessorList _processors;
 793                 ChanCount _processor_max_streams;
 794         };
 795
 796         friend class ProcessorState;
 797
 798         bool _strict_io;
 799
 800         /* no copy construction */
 801         Route (Route const &);
 802
 803         void maybe_note_meter_position ();
 804
 805         /** true if we've made a note of a custom meter position in these variables */
 806         bool _custom_meter_position_noted;
 807         /** the processor that came after the meter when it was last set to a custom position,
 808             or 0.
 809         */
 810         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 811         RoutePinWindowProxy *_pinmgr_proxy;
 812
 813         void reset_instrument_info ();
 814
 815         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 816         void solo_control_changed (bool self, PBD::Controllable::GroupControlDisposition);
 817 };
 818
 819 } // namespace ARDOUR
 820
 821 #endif /* __ardour_route_h__ */