libs/ardour/ardour/route.h

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