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