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