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