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