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