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