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 BooleanRouteAutomationControl : public RouteAutomationControl {
 481         public:
 482                 BooleanRouteAutomationControl (const std::string& name,
 483                                                AutomationType atype,
 484                                                boost::shared_ptr<AutomationList> alist,
 485                                                boost::shared_ptr<Route> route)
 486                         : RouteAutomationControl (name, atype, alist, route) {}
 487         protected:
 488                 double get_masters_value_locked() const;
 489
 490         };
 491
 492         class GainControllable : public GainControl  {
 493         public:
 494                 GainControllable (Session& session,
 495                                   AutomationType type,
 496                                   boost::shared_ptr<Route> route);
 497
 498                 void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) {
 499                         boost::shared_ptr<Route> r = _route.lock();
 500                         if (r) {
 501                                 /* Route must mediate group control */
 502                                 r->set_control ((AutomationType) parameter().type(), val, group_override);
 503                         }
 504                 }
 505
 506         protected:
 507                 friend class Route;
 508
 509                 void route_set_value (double val) {
 510                         GainControl::set_value (val, Controllable::NoGroup);
 511                 }
 512
 513                 boost::weak_ptr<Route> _route;
 514         };
 515
 516         class SoloControllable : public BooleanRouteAutomationControl {
 517         public:
 518                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 519                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 520                 void set_value_unchecked (double);
 521                 double get_value () const;
 522         private:
 523                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 524         };
 525
 526         struct MuteControllable : public BooleanRouteAutomationControl {
 527         public:
 528                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 529                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 530                 void set_value_unchecked (double);
 531                 double get_value () const;
 532
 533                 /* Pretend to change value, but do not affect actual route mute. */
 534                 void set_superficial_value(bool muted);
 535
 536         private:
 537                 boost::weak_ptr<Route> _route;
 538                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 539         };
 540
 541         class LIBARDOUR_API PhaseControllable : public BooleanRouteAutomationControl {
 542         public:
 543                 PhaseControllable (std::string name, boost::shared_ptr<Route>);
 544                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 545                 /* currently no automation, so no need for set_value_unchecked() */
 546                 void set_channel (uint32_t);
 547                 double get_value () const;
 548                 uint32_t channel() const;
 549         private:
 550                 uint32_t _current_phase;
 551                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 552         };
 553
 554         class LIBARDOUR_API SoloIsolateControllable : public BooleanRouteAutomationControl {
 555         public:
 556                 SoloIsolateControllable (std::string name, boost::shared_ptr<Route>);
 557                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 558                 /* currently no automation, so no need for set_value_unchecked() */
 559                 double get_value () const;
 560         private:
 561                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 562         };
 563
 564         class LIBARDOUR_API SoloSafeControllable : public BooleanRouteAutomationControl {
 565         public:
 566                 SoloSafeControllable (std::string name, boost::shared_ptr<Route>);
 567                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 568                 /* currently no automation, so no need for set_value_unchecked() */
 569                 double get_value () const;
 570         private:
 571                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 572         };
 573
 574         void set_control (AutomationType, double val, PBD::Controllable::GroupControlDisposition group_override);
 575
 576         boost::shared_ptr<AutomationControl> solo_control() const {
 577                 return _solo_control;
 578         }
 579
 580         boost::shared_ptr<AutomationControl> mute_control() const {
 581                 return _mute_control;
 582         }
 583
 584         boost::shared_ptr<MuteMaster> mute_master() const {
 585                 return _mute_master;
 586         }
 587
 588         boost::shared_ptr<AutomationControl> solo_isolate_control() const {
 589                 return _solo_isolate_control;
 590         }
 591
 592         boost::shared_ptr<AutomationControl> solo_safe_control() const {
 593                 return _solo_safe_control;
 594         }
 595
 596         boost::shared_ptr<AutomationControl> monitoring_control() const {
 597                 /* tracks override this to provide actual monitoring control;
 598                    busses have no possible choices except input monitoring.
 599                 */
 600                 return boost::shared_ptr<AutomationControl> ();
 601         }
 602
 603         /* Route doesn't own these items, but sub-objects that it does own have them
 604            and to make UI code a bit simpler, we provide direct access to them
 605            here.
 606         */
 607
 608         boost::shared_ptr<Panner> panner() const;  /* may return null */
 609         boost::shared_ptr<PannerShell> panner_shell() const;
 610         boost::shared_ptr<Pannable> pannable() const;
 611
 612         boost::shared_ptr<GainControl> gain_control() const;
 613         boost::shared_ptr<AutomationControl> trim_control() const;
 614         boost::shared_ptr<AutomationControl> phase_control() const;
 615
 616         /**
 617            Return the first processor that accepts has at least one MIDI input
 618            and at least one audio output. In the vast majority of cases, this
 619            will be "the instrument". This does not preclude other MIDI->audio
 620            processors later in the processing chain, but that would be a
 621            special case not covered by this utility function.
 622         */
 623         boost::shared_ptr<Processor> the_instrument() const;
 624         InstrumentInfo& instrument_info() { return _instrument_info; }
 625
 626         /* "well-known" controls for panning. Any or all of these may return
 627          * null.
 628          */
 629
 630         boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
 631         boost::shared_ptr<AutomationControl> pan_elevation_control() const;
 632         boost::shared_ptr<AutomationControl> pan_width_control() const;
 633         boost::shared_ptr<AutomationControl> pan_frontback_control() const;
 634         boost::shared_ptr<AutomationControl> pan_lfe_control() const;
 635
 636         /* "well-known" controls for an EQ in this route. Any or all may
 637          * be null. eq_band_cnt() must return 0 if there is no EQ present.
 638          * Passing an @param band value >= eq_band_cnt() will guarantee the
 639          * return of a null ptr (or an empty string for eq_band_name()).
 640          */
 641         uint32_t eq_band_cnt () const;
 642         std::string eq_band_name (uint32_t) const;
 643         boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
 644         boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
 645         boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
 646         boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
 647         boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
 648         boost::shared_ptr<AutomationControl> eq_hpf_controllable () const;
 649
 650         /* "well-known" controls for a compressor in this route. Any or all may
 651          * be null.
 652          */
 653         boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
 654         boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
 655         boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
 656         boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
 657         boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
 658         boost::shared_ptr<AutomationControl> comp_redux_controllable () const;
 659
 660         /* @param mode must be supplied by the comp_mode_controllable(). All other values
 661          * result in undefined behaviour
 662          */
 663         std::string comp_mode_name (uint32_t mode) const;
 664         /* @param mode - as for comp mode name. This returns the name for the
 665          * parameter/control accessed via comp_speed_controllable(), which can
 666          * be mode dependent.
 667          */
 668         std::string comp_speed_name (uint32_t mode) const;
 669
 670         /* "well-known" controls for sends to well-known busses in this route. Any or all may
 671          * be null.
 672          *
 673          * In Mixbus, these are the sends that connect to the mixbusses.
 674          * In Ardour, these are user-created sends that connect to user-created
 675          * Aux busses.
 676          */
 677         boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
 678         boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
 679         /* for the same value of @param n, this returns the name of the send
 680          * associated with the pair of controllables returned by the above two methods.
 681          */
 682         std::string send_name (uint32_t n) const;
 683
 684         /* well known control that enables/disables sending to the master bus.
 685          *
 686          * In Ardour, this returns null.
 687          * In Mixbus, it will return a suitable control, or null depending on
 688          * the route.
 689          */
 690         boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
 691
 692         void protect_automation ();
 693
 694         enum {
 695                 /* These numbers are taken from MIDI Machine Control,
 696                    which can only control up to 317 tracks without
 697                    doing sysex segmentation.
 698                 */
 699                 MasterBusRemoteControlID = 318,
 700                 MonitorBusRemoteControlID = 319,
 701         };
 702
 703         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 704         uint32_t remote_control_id () const;
 705         void     set_remote_control_id_explicit (uint32_t order_key);
 706
 707         /* for things concerned about *this* route's RID */
 708
 709         PBD::Signal0<void> RemoteControlIDChanged;
 710
 711         /* for things concerned about *any* route's RID changes */
 712
 713         static PBD::Signal0<void> RemoteControlIDChange;
 714         static PBD::Signal0<void> SyncOrderKeys;
 715
 716         bool has_external_redirects() const;
 717
 718         /* can only be executed by a route for which is_monitor() is true
 719          *       (i.e. the monitor out)
 720          */
 721         void monitor_run (framepos_t start_frame, framepos_t end_frame,
 722                         pframes_t nframes, int declick);
 723
 724         bool slaved_to (boost::shared_ptr<VCA>) const;
 725         void vca_assign (boost::shared_ptr<VCA>);
 726         void vca_unassign (boost::shared_ptr<VCA>);
 727
 728   protected:
 729         friend class Session;
 730
 731         void catch_up_on_solo_mute_override ();
 732         void mod_solo_by_others_upstream (int32_t);
 733         void mod_solo_by_others_downstream (int32_t);
 734         void curve_reallocate ();
 735         virtual void set_block_size (pframes_t nframes);
 736
 737 protected:
 738         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 739
 740         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 741
 742         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 743                         pframes_t nframes, int declick);
 744
 745         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 746                                              framecnt_t /* nframes */) {}
 747
 748         virtual void process_output_buffers (BufferSet& bufs,
 749                                              framepos_t start_frame, framepos_t end_frame,
 750                                              pframes_t nframes, int declick,
 751                                              bool gain_automation_ok);
 752
 753         virtual void bounce_process (BufferSet& bufs,
 754                                      framepos_t start_frame, framecnt_t nframes,
 755                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 756                                      bool for_export, bool for_freeze);
 757
 758         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 759         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 760
 761         boost::shared_ptr<IO> _input;
 762         boost::shared_ptr<IO> _output;
 763
 764         bool           _active;
 765         framecnt_t     _signal_latency;
 766         framecnt_t     _signal_latency_at_amp_position;
 767         framecnt_t     _signal_latency_at_trim_position;
 768         framecnt_t     _initial_delay;
 769         framecnt_t     _roll_delay;
 770
 771         ProcessorList  _processors;
 772         mutable Glib::Threads::RWLock   _processor_lock;
 773         boost::shared_ptr<Delivery> _main_outs;
 774         boost::shared_ptr<InternalSend> _monitor_send;
 775         boost::shared_ptr<InternalReturn> _intreturn;
 776         boost::shared_ptr<MonitorProcessor> _monitor_control;
 777         boost::shared_ptr<Pannable> _pannable;
 778
 779         enum {
 780                 EmitNone = 0x00,
 781                 EmitMeterChanged = 0x01,
 782                 EmitMeterVisibilityChange = 0x02,
 783                 EmitRtProcessorChange = 0x04
 784         };
 785
 786         ProcessorList  _pending_processor_order;
 787         gint           _pending_process_reorder; // atomic
 788         gint           _pending_signals; // atomic
 789
 790         Flag           _flags;
 791         int            _pending_declick;
 792         MeterPoint     _meter_point;
 793         MeterPoint     _pending_meter_point;
 794         MeterType      _meter_type;
 795         boost::dynamic_bitset<> _phase_invert;
 796         bool           _self_solo;
 797         uint32_t       _soloed_by_others_upstream;
 798         uint32_t       _soloed_by_others_downstream;
 799         bool           _solo_isolated;
 800         uint32_t       _solo_isolated_by_upstream;
 801
 802         void mod_solo_isolated_by_upstream (bool);
 803
 804         bool           _denormal_protection;
 805
 806         bool _recordable : 1;
 807         bool _silent : 1;
 808         bool _declickable : 1;
 809
 810         boost::shared_ptr<SoloControllable> _solo_control;
 811         boost::shared_ptr<MuteControllable> _mute_control;
 812         boost::shared_ptr<MuteMaster> _mute_master;
 813         boost::shared_ptr<PhaseControllable> _phase_control;
 814         boost::shared_ptr<SoloIsolateControllable> _solo_isolate_control;
 815         boost::shared_ptr<SoloSafeControllable> _solo_safe_control;
 816
 817         virtual void act_on_mute () {}
 818
 819         std::string    _comment;
 820         bool           _have_internal_generator;
 821         bool           _solo_safe;
 822         DataType       _default_type;
 823         FedBy          _fed_by;
 824
 825         InstrumentInfo _instrument_info;
 826
 827         virtual ChanCount input_streams () const;
 828
 829 protected:
 830         virtual XMLNode& state(bool);
 831
 832         int configure_processors (ProcessorStreams*);
 833
 834         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 835                                pframes_t nframes, int declick);
 836
 837         void silence (framecnt_t);
 838         void silence_unlocked (framecnt_t);
 839
 840         ChanCount processor_max_streams;
 841         ChanCount processor_out_streams;
 842
 843         uint32_t pans_required() const;
 844         ChanCount n_process_buffers ();
 845
 846         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 847
 848         boost::shared_ptr<GainControllable> _gain_control;
 849         boost::shared_ptr<Amp>       _amp;
 850         boost::shared_ptr<GainControllable> _trim_control;
 851         boost::shared_ptr<Amp>       _trim;
 852         boost::shared_ptr<PeakMeter> _meter;
 853         boost::shared_ptr<DelayLine> _delayline;
 854
 855         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 856
 857 private:
 858         int set_state_2X (const XMLNode&, int);
 859         void set_processor_state_2X (XMLNodeList const &, int);
 860
 861         uint32_t _order_key;
 862         bool _has_order_key;
 863         uint32_t _remote_control_id;
 864
 865         int64_t _track_number;
 866
 867         void input_change_handler (IOChange, void *src);
 868         void output_change_handler (IOChange, void *src);
 869         void sidechain_change_handler (IOChange, void *src);
 870
 871         void processor_selfdestruct (boost::weak_ptr<Processor>);
 872         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 873         Glib::Threads::Mutex  selfdestruct_lock;
 874
 875         bool input_port_count_changing (ChanCount);
 876         bool output_port_count_changing (ChanCount);
 877
 878         bool _in_configure_processors;
 879         bool _initial_io_setup;
 880         bool _in_sidechain_setup;
 881
 882         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 883         bool set_meter_point_unlocked ();
 884         void apply_processor_order (const ProcessorList& new_order);
 885
 886         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 887         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 888
 889         bool add_processor_from_xml_2X (const XMLNode&, int);
 890
 891         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 892
 893         void set_self_solo (bool yn);
 894         void set_mute_master_solo ();
 895
 896         void set_processor_positions ();
 897         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 898
 899         void setup_invisible_processors ();
 900         void unpan ();
 901
 902         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 903
 904         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 905
 906         /** A handy class to keep processor state while we attempt a reconfiguration
 907          *  that may fail.
 908          */
 909         class ProcessorState {
 910         public:
 911                 ProcessorState (Route* r)
 912                         : _route (r)
 913                         , _processors (r->_processors)
 914                         , _processor_max_streams (r->processor_max_streams)
 915                 { }
 916
 917                 void restore () {
 918                         _route->_processors = _processors;
 919                         _route->processor_max_streams = _processor_max_streams;
 920                 }
 921
 922         private:
 923                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 924                    not hang around long enough for it to matter.
 925                 */
 926                 Route* _route;
 927                 ProcessorList _processors;
 928                 ChanCount _processor_max_streams;
 929         };
 930
 931         friend class ProcessorState;
 932
 933         bool _strict_io;
 934
 935         /* no copy construction */
 936         Route (Route const &);
 937
 938         void maybe_note_meter_position ();
 939
 940         /** true if we've made a note of a custom meter position in these variables */
 941         bool _custom_meter_position_noted;
 942         /** the processor that came after the meter when it was last set to a custom position,
 943             or 0.
 944         */
 945         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 946         RoutePinWindowProxy *_pinmgr_proxy;
 947
 948         void reset_instrument_info ();
 949
 950         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 951 };
 952
 953 } // namespace ARDOUR
 954
 955 #endif /* __ardour_route_h__ */