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