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