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