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