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         bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
 280         bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs);
 281
 282         framecnt_t set_private_port_latencies (bool playback) const;
 283         void       set_public_port_latencies (framecnt_t, bool playback) const;
 284
 285         framecnt_t   update_signal_latency();
 286         virtual void set_latency_compensation (framecnt_t);
 287
 288         void set_user_latency (framecnt_t);
 289         framecnt_t initial_delay() const { return _initial_delay; }
 290         framecnt_t signal_latency() const { return _signal_latency; }
 291
 292         PBD::Signal0<void>       active_changed;
 293         PBD::Signal0<void>       phase_invert_changed;
 294         PBD::Signal0<void>       denormal_protection_changed;
 295         PBD::Signal1<void,PBD::Controllable::GroupControlDisposition>  listen_changed;
 296         PBD::Signal2<void,bool,PBD::Controllable::GroupControlDisposition>  solo_changed;
 297         PBD::Signal0<void>       solo_safe_changed;
 298         PBD::Signal0<void>       solo_isolated_changed;
 299         PBD::Signal0<void>       comment_changed;
 300         PBD::Signal0<void>       mute_changed;
 301         PBD::Signal0<void>       mute_points_changed;
 302
 303         /** track numbers - assigned by session
 304          * nubers > 0 indicate tracks (audio+midi)
 305          * nubers < 0 indicate busses
 306          * zero is reserved for unnumbered special busses.
 307          * */
 308         PBD::Signal0<void> track_number_changed;
 309         int64_t track_number() const { return _track_number; }
 310
 311         void set_track_number(int64_t tn) {
 312                 if (tn == _track_number) { return; }
 313                 _track_number = tn;
 314                 track_number_changed();
 315                 PropertyChanged (ARDOUR::Properties::name);
 316         }
 317
 318         /** the processors have changed; the parameter indicates what changed */
 319         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 320         PBD::Signal1<void,void*> record_enable_changed;
 321         /** the metering point has changed */
 322         PBD::Signal0<void>       meter_change;
 323         PBD::Signal0<void>       signal_latency_changed;
 324         PBD::Signal0<void>       initial_delay_changed;
 325
 326         /** Emitted with the process lock held */
 327         PBD::Signal0<void>       io_changed;
 328
 329         /* gui's call this for their own purposes. */
 330
 331         PBD::Signal2<void,std::string,void*> gui_changed;
 332
 333         /* stateful */
 334
 335         XMLNode& get_state();
 336         virtual int set_state (const XMLNode&, int version);
 337         virtual XMLNode& get_template();
 338
 339         XMLNode& get_processor_state ();
 340         virtual void set_processor_state (const XMLNode&);
 341
 342         int save_as_template (const std::string& path, const std::string& name);
 343
 344         PBD::Signal1<void,void*> SelectedChanged;
 345
 346         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 347         void remove_aux_or_listen (boost::shared_ptr<Route>);
 348
 349         /**
 350          * return true if this route feeds the first argument via at least one
 351          * (arbitrarily long) signal pathway.
 352          */
 353         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 354
 355         /**
 356          * return true if this route feeds the first argument directly, via
 357          * either its main outs or a send.  This is checked by the actual
 358          * connections, rather than by what the graph is currently doing.
 359          */
 360         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 361
 362         /**
 363          * return true if this route feeds the first argument directly, via
 364          * either its main outs or a send, according to the graph that
 365          * is currently being processed.
 366          */
 367         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 368
 369         struct FeedRecord {
 370                 boost::weak_ptr<Route> r;
 371                 bool sends_only;
 372
 373                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 374                 : r (rp)
 375                 , sends_only (sendsonly) {}
 376         };
 377
 378         struct FeedRecordCompare {
 379                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 380                         return a.r < b.r;
 381                 }
 382         };
 383
 384         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 385
 386         const FedBy& fed_by() const { return _fed_by; }
 387         void clear_fed_by ();
 388         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 389
 390         /* Controls (not all directly owned by the Route) */
 391
 392         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 393
 394         class RouteAutomationControl : public AutomationControl {
 395         public:
 396                 RouteAutomationControl (const std::string& name,
 397                                         AutomationType atype,
 398                                         boost::shared_ptr<AutomationList> alist,
 399                                         boost::shared_ptr<Route> route);
 400         protected:
 401                 friend class Route;
 402
 403                 void route_set_value (double val) {
 404                         AutomationControl::set_value (val, Controllable::NoGroup);
 405                 }
 406
 407                 boost::weak_ptr<Route> _route;
 408         };
 409
 410         class GainControllable : public GainControl  {
 411         public:
 412                 GainControllable (Session& session,
 413                                   AutomationType type,
 414                                   boost::shared_ptr<Route> route);
 415
 416                 void set_value (double val, PBD::Controllable::GroupControlDisposition group_override) {
 417                         boost::shared_ptr<Route> r = _route.lock();
 418                         if (r) {
 419                                 /* Route must mediate group control */
 420                                 r->set_control ((AutomationType) parameter().type(), val, group_override);
 421                         }
 422                 }
 423
 424         protected:
 425                 friend class Route;
 426
 427                 void route_set_value (double val) {
 428                         GainControl::set_value (val, Controllable::NoGroup);
 429                 }
 430
 431                 boost::weak_ptr<Route> _route;
 432         };
 433
 434         class SoloControllable : public RouteAutomationControl {
 435         public:
 436                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 437                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 438                 void set_value_unchecked (double);
 439                 double get_value () const;
 440         private:
 441                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 442         };
 443
 444         struct MuteControllable : public RouteAutomationControl {
 445         public:
 446                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 447                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 448                 void set_value_unchecked (double);
 449                 double get_value () const;
 450
 451                 /* Pretend to change value, but do not affect actual route mute. */
 452                 void set_superficial_value(bool muted);
 453
 454         private:
 455                 boost::weak_ptr<Route> _route;
 456                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 457         };
 458
 459         class LIBARDOUR_API PhaseControllable : public RouteAutomationControl {
 460         public:
 461                 PhaseControllable (std::string name, boost::shared_ptr<Route>);
 462                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 463                 /* currently no automation, so no need for set_value_unchecked() */
 464                 void set_channel (uint32_t);
 465                 double get_value () const;
 466                 uint32_t channel() const;
 467         private:
 468                 uint32_t _current_phase;
 469                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 470         };
 471
 472         class LIBARDOUR_API SoloIsolateControllable : public RouteAutomationControl {
 473         public:
 474                 SoloIsolateControllable (std::string name, boost::shared_ptr<Route>);
 475                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 476                 /* currently no automation, so no need for set_value_unchecked() */
 477                 double get_value () const;
 478         private:
 479                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 480         };
 481
 482         class LIBARDOUR_API SoloSafeControllable : public RouteAutomationControl {
 483         public:
 484                 SoloSafeControllable (std::string name, boost::shared_ptr<Route>);
 485                 void set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 486                 /* currently no automation, so no need for set_value_unchecked() */
 487                 double get_value () const;
 488         private:
 489                 void _set_value (double, PBD::Controllable::GroupControlDisposition group_override);
 490         };
 491
 492         void set_control (AutomationType, double val, PBD::Controllable::GroupControlDisposition group_override);
 493
 494         boost::shared_ptr<SoloControllable> solo_control() const {
 495                 return _solo_control;
 496         }
 497
 498         boost::shared_ptr<MuteControllable> mute_control() const {
 499                 return _mute_control;
 500         }
 501
 502         boost::shared_ptr<MuteMaster> mute_master() const {
 503                 return _mute_master;
 504         }
 505
 506         boost::shared_ptr<SoloIsolateControllable> solo_isolate_control() const {
 507                 return _solo_isolate_control;
 508         }
 509
 510         boost::shared_ptr<SoloSafeControllable> solo_safe_control() const {
 511                 return _solo_safe_control;
 512         }
 513
 514         boost::shared_ptr<AutomationControl> monitoring_control() const {
 515                 /* tracks override this to provide actual monitoring control;
 516                    busses have no possible choices except input monitoring.
 517                 */
 518                 return boost::shared_ptr<AutomationControl> ();
 519         }
 520
 521         /* Route doesn't own these items, but sub-objects that it does own have them
 522            and to make UI code a bit simpler, we provide direct access to them
 523            here.
 524         */
 525
 526         boost::shared_ptr<Panner> panner() const;  /* may return null */
 527         boost::shared_ptr<PannerShell> panner_shell() const;
 528         boost::shared_ptr<GainControl> gain_control() const;
 529         boost::shared_ptr<Pannable> pannable() const;
 530         boost::shared_ptr<GainControl> trim_control() const;
 531
 532         boost::shared_ptr<PhaseControllable> phase_control() const;
 533
 534         /**
 535            Return the first processor that accepts has at least one MIDI input
 536            and at least one audio output. In the vast majority of cases, this
 537            will be "the instrument". This does not preclude other MIDI->audio
 538            processors later in the processing chain, but that would be a
 539            special case not covered by this utility function.
 540         */
 541         boost::shared_ptr<Processor> the_instrument() const;
 542         InstrumentInfo& instrument_info() { return _instrument_info; }
 543
 544         /* "well-known" controls for panning. Any or all of these may return
 545          * null.
 546          */
 547
 548         boost::shared_ptr<AutomationControl> pan_azimuth_control() const;
 549         boost::shared_ptr<AutomationControl> pan_elevation_control() const;
 550         boost::shared_ptr<AutomationControl> pan_width_control() const;
 551         boost::shared_ptr<AutomationControl> pan_frontback_control() const;
 552         boost::shared_ptr<AutomationControl> pan_lfe_control() const;
 553
 554         /* "well-known" controls for an EQ in this route. Any or all may
 555          * be null. eq_band_cnt() must return 0 if there is no EQ present.
 556          * Passing an @param band value >= eq_band_cnt() will guarantee the
 557          * return of a null ptr (or an empty string for eq_band_name()).
 558          */
 559         uint32_t eq_band_cnt () const;
 560         std::string eq_band_name (uint32_t) const;
 561         boost::shared_ptr<AutomationControl> eq_gain_controllable (uint32_t band) const;
 562         boost::shared_ptr<AutomationControl> eq_freq_controllable (uint32_t band) const;
 563         boost::shared_ptr<AutomationControl> eq_q_controllable (uint32_t band) const;
 564         boost::shared_ptr<AutomationControl> eq_shape_controllable (uint32_t band) const;
 565         boost::shared_ptr<AutomationControl> eq_enable_controllable () const;
 566         boost::shared_ptr<AutomationControl> eq_hpf_controllable () const;
 567
 568         /* "well-known" controls for a compressor in this route. Any or all may
 569          * be null.
 570          */
 571         boost::shared_ptr<AutomationControl> comp_enable_controllable () const;
 572         boost::shared_ptr<AutomationControl> comp_threshold_controllable () const;
 573         boost::shared_ptr<AutomationControl> comp_speed_controllable () const;
 574         boost::shared_ptr<AutomationControl> comp_mode_controllable () const;
 575         boost::shared_ptr<AutomationControl> comp_makeup_controllable () const;
 576         boost::shared_ptr<AutomationControl> comp_redux_controllable () const;
 577
 578         /* @param mode must be supplied by the comp_mode_controllable(). All other values
 579          * result in undefined behaviour
 580          */
 581         std::string comp_mode_name (uint32_t mode) const;
 582         /* @param mode - as for comp mode name. This returns the name for the
 583          * parameter/control accessed via comp_speed_controllable(), which can
 584          * be mode dependent.
 585          */
 586         std::string comp_speed_name (uint32_t mode) const;
 587
 588         /* "well-known" controls for sends to well-known busses in this route. Any or all may
 589          * be null.
 590          *
 591          * In Mixbus, these are the sends that connect to the mixbusses.
 592          * In Ardour, these are user-created sends that connect to user-created
 593          * Aux busses.
 594          */
 595         boost::shared_ptr<AutomationControl> send_level_controllable (uint32_t n) const;
 596         boost::shared_ptr<AutomationControl> send_enable_controllable (uint32_t n) const;
 597         /* for the same value of @param n, this returns the name of the send
 598          * associated with the pair of controllables returned by the above two methods.
 599          */
 600         std::string send_name (uint32_t n) const;
 601
 602         /* well known control that enables/disables sending to the master bus.
 603          *
 604          * In Ardour, this returns null.
 605          * In Mixbus, it will return a suitable control, or null depending on
 606          * the route.
 607          */
 608         boost::shared_ptr<AutomationControl> master_send_enable_controllable () const;
 609
 610         void protect_automation ();
 611
 612         enum {
 613                 /* These numbers are taken from MIDI Machine Control,
 614                    which can only control up to 317 tracks without
 615                    doing sysex segmentation.
 616                 */
 617                 MasterBusRemoteControlID = 318,
 618                 MonitorBusRemoteControlID = 319,
 619         };
 620
 621         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 622         uint32_t remote_control_id () const;
 623         void     set_remote_control_id_explicit (uint32_t order_key);
 624
 625         /* for things concerned about *this* route's RID */
 626
 627         PBD::Signal0<void> RemoteControlIDChanged;
 628
 629         /* for things concerned about *any* route's RID changes */
 630
 631         static PBD::Signal0<void> RemoteControlIDChange;
 632         static PBD::Signal0<void> SyncOrderKeys;
 633
 634         bool has_external_redirects() const;
 635
 636         /* can only be executed by a route for which is_monitor() is true
 637            (i.e. the monitor out)
 638         */
 639         void monitor_run (framepos_t start_frame, framepos_t end_frame,
 640                           pframes_t nframes, int declick);
 641
 642   protected:
 643         friend class Session;
 644
 645         void catch_up_on_solo_mute_override ();
 646         void mod_solo_by_others_upstream (int32_t);
 647         void mod_solo_by_others_downstream (int32_t);
 648         void curve_reallocate ();
 649         virtual void set_block_size (pframes_t nframes);
 650
 651   protected:
 652         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 653
 654         void fill_buffers_with_input (BufferSet& bufs, boost::shared_ptr<IO> io, pframes_t nframes);
 655
 656         void passthru (BufferSet&, framepos_t start_frame, framepos_t end_frame,
 657                         pframes_t nframes, int declick);
 658
 659         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 660                                              framecnt_t /* nframes */) {}
 661
 662         virtual void process_output_buffers (BufferSet& bufs,
 663                                              framepos_t start_frame, framepos_t end_frame,
 664                                              pframes_t nframes, int declick,
 665                                              bool gain_automation_ok);
 666
 667         virtual void bounce_process (BufferSet& bufs,
 668                                      framepos_t start_frame, framecnt_t nframes,
 669                                                                                                                          boost::shared_ptr<Processor> endpoint, bool include_endpoint,
 670                                      bool for_export, bool for_freeze);
 671
 672         framecnt_t   bounce_get_latency (boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 673         ChanCount    bounce_get_output_streams (ChanCount &cc, boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze) const;
 674
 675         boost::shared_ptr<IO> _input;
 676         boost::shared_ptr<IO> _output;
 677
 678         bool           _active;
 679         framecnt_t     _signal_latency;
 680         framecnt_t     _signal_latency_at_amp_position;
 681         framecnt_t     _signal_latency_at_trim_position;
 682         framecnt_t     _initial_delay;
 683         framecnt_t     _roll_delay;
 684
 685         ProcessorList  _processors;
 686         mutable Glib::Threads::RWLock   _processor_lock;
 687         boost::shared_ptr<Delivery> _main_outs;
 688         boost::shared_ptr<InternalSend> _monitor_send;
 689         boost::shared_ptr<InternalReturn> _intreturn;
 690         boost::shared_ptr<MonitorProcessor> _monitor_control;
 691         boost::shared_ptr<Pannable> _pannable;
 692
 693         enum {
 694                 EmitNone = 0x00,
 695                 EmitMeterChanged = 0x01,
 696                 EmitMeterVisibilityChange = 0x02,
 697                 EmitRtProcessorChange = 0x04
 698         };
 699
 700         ProcessorList  _pending_processor_order;
 701         gint           _pending_process_reorder; // atomic
 702         gint           _pending_signals; // atomic
 703
 704         Flag           _flags;
 705         int            _pending_declick;
 706         MeterPoint     _meter_point;
 707         MeterPoint     _pending_meter_point;
 708         MeterType      _meter_type;
 709         boost::dynamic_bitset<> _phase_invert;
 710         bool           _self_solo;
 711         uint32_t       _soloed_by_others_upstream;
 712         uint32_t       _soloed_by_others_downstream;
 713         bool           _solo_isolated;
 714         uint32_t       _solo_isolated_by_upstream;
 715
 716         void mod_solo_isolated_by_upstream (bool);
 717
 718         bool           _denormal_protection;
 719
 720         bool _recordable : 1;
 721         bool _silent : 1;
 722         bool _declickable : 1;
 723
 724         boost::shared_ptr<SoloControllable> _solo_control;
 725         boost::shared_ptr<MuteControllable> _mute_control;
 726         boost::shared_ptr<MuteMaster> _mute_master;
 727         boost::shared_ptr<PhaseControllable> _phase_control;
 728         boost::shared_ptr<SoloIsolateControllable> _solo_isolate_control;
 729         boost::shared_ptr<SoloSafeControllable> _solo_safe_control;
 730
 731         virtual void act_on_mute () {}
 732
 733         std::string    _comment;
 734         bool           _have_internal_generator;
 735         bool           _solo_safe;
 736         DataType       _default_type;
 737         FedBy          _fed_by;
 738
 739         InstrumentInfo _instrument_info;
 740
 741         virtual ChanCount input_streams () const;
 742
 743   protected:
 744         virtual XMLNode& state(bool);
 745
 746         int configure_processors (ProcessorStreams*);
 747
 748         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 749                                pframes_t nframes, int declick);
 750
 751         void silence (framecnt_t);
 752         void silence_unlocked (framecnt_t);
 753
 754         ChanCount processor_max_streams;
 755         ChanCount processor_out_streams;
 756
 757         uint32_t pans_required() const;
 758         ChanCount n_process_buffers ();
 759
 760         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 761
 762         boost::shared_ptr<GainControllable> _gain_control;
 763         boost::shared_ptr<Amp>       _amp;
 764         boost::shared_ptr<GainControllable> _trim_control;
 765         boost::shared_ptr<Amp>       _trim;
 766         boost::shared_ptr<PeakMeter> _meter;
 767         boost::shared_ptr<DelayLine> _delayline;
 768
 769         boost::shared_ptr<Processor> the_instrument_unlocked() const;
 770
 771   private:
 772         int set_state_2X (const XMLNode&, int);
 773         void set_processor_state_2X (XMLNodeList const &, int);
 774
 775         uint32_t _order_key;
 776         bool _has_order_key;
 777         uint32_t _remote_control_id;
 778
 779         int64_t _track_number;
 780
 781         void input_change_handler (IOChange, void *src);
 782         void output_change_handler (IOChange, void *src);
 783
 784         bool input_port_count_changing (ChanCount);
 785         bool output_port_count_changing (ChanCount);
 786
 787         bool _in_configure_processors;
 788         bool _initial_io_setup;
 789
 790         int configure_processors_unlocked (ProcessorStreams*);
 791         bool set_meter_point_unlocked ();
 792         void apply_processor_order (const ProcessorList& new_order);
 793
 794         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 795         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 796
 797         bool add_processor_from_xml_2X (const XMLNode&, int);
 798
 799         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 800
 801         void set_self_solo (bool yn);
 802         void set_mute_master_solo ();
 803
 804         void set_processor_positions ();
 805         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 806
 807         void setup_invisible_processors ();
 808         void unpan ();
 809
 810         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 811
 812         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 813
 814         /** A handy class to keep processor state while we attempt a reconfiguration
 815          *  that may fail.
 816          */
 817         class ProcessorState {
 818         public:
 819                 ProcessorState (Route* r)
 820                         : _route (r)
 821                         , _processors (r->_processors)
 822                         , _processor_max_streams (r->processor_max_streams)
 823                 { }
 824
 825                 void restore () {
 826                         _route->_processors = _processors;
 827                         _route->processor_max_streams = _processor_max_streams;
 828                 }
 829
 830         private:
 831                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 832                    not hang around long enough for it to matter.
 833                 */
 834                 Route* _route;
 835                 ProcessorList _processors;
 836                 ChanCount _processor_max_streams;
 837         };
 838
 839         friend class ProcessorState;
 840
 841         bool _strict_io;
 842
 843         /* no copy construction */
 844         Route (Route const &);
 845
 846         void maybe_note_meter_position ();
 847
 848         /** true if we've made a note of a custom meter position in these variables */
 849         bool _custom_meter_position_noted;
 850         /** the processor that came after the meter when it was last set to a custom position,
 851             or 0.
 852         */
 853         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 854
 855         void reset_instrument_info ();
 856
 857         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 858 };
 859
 860 } // namespace ARDOUR
 861
 862 #endif /* __ardour_route_h__ */