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