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