libs/ardour/ardour/route.h

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