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