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