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