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