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