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 #ifndef __ardour_route_h__
  20 #define __ardour_route_h__
  21
  22 #include <cmath>
  23 #include <cstring>
  24 #include <list>
  25 #include <map>
  26 #include <set>
  27 #include <string>
  28
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/weak_ptr.hpp>
  31 #include <boost/dynamic_bitset.hpp>
  32 #include <boost/enable_shared_from_this.hpp>
  33
  34 #include <glibmm/threads.h>
  35 #include "pbd/fastlog.h"
  36 #include "pbd/xml++.h"
  37 #include "pbd/undo.h"
  38 #include "pbd/stateful.h"
  39 #include "pbd/controllable.h"
  40 #include "pbd/destructible.h"
  41
  42 #include "ardour/ardour.h"
  43 #include "ardour/gain_control.h"
  44 #include "ardour/instrument_info.h"
  45 #include "ardour/io.h"
  46 #include "ardour/io_vector.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         IOVector all_inputs () const;
  93         IOVector all_outputs () const;
  94
  95         ChanCount n_inputs() const { return _input->n_ports(); }
  96         ChanCount n_outputs() const { return _output->n_ports(); }
  97
  98         bool active() const { return _active; }
  99         void set_active (bool yn, void *);
 100
 101         static std::string ensure_track_or_route_name(std::string, Session &);
 102
 103         std::string comment() { return _comment; }
 104         void set_comment (std::string str, void *src);
 105
 106         bool set_name (const std::string& str);
 107         static void set_name_in_state (XMLNode &, const std::string &, bool rename_playlist = true);
 108
 109         uint32_t order_key () const;
 110         bool has_order_key () const;
 111         void set_order_key (uint32_t);
 112
 113         bool is_auditioner() const { return _flags & Auditioner; }
 114         bool is_master() const { return _flags & MasterOut; }
 115         bool is_monitor() const { return _flags & MonitorOut; }
 116
 117         virtual MonitorState monitoring_state () const;
 118         virtual MeterState metering_state () const;
 119
 120         /* these are the core of the API of a Route. see the protected sections as well */
 121
 122         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 123                           int declick, bool& need_butler);
 124
 125         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 126                              bool state_changing);
 127
 128         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 129                                  bool& need_butler);
 130
 131         virtual bool can_record() { return false; }
 132
 133         virtual void set_record_enabled (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {}
 134         virtual bool record_enabled() const { return false; }
 135         virtual void set_record_safe (bool /*yn*/, PBD::Controllable::GroupControlDisposition) {}
 136         virtual bool record_safe () const {return false; }
 137         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 138         virtual void realtime_handle_transport_stopped () {}
 139         virtual void realtime_locate () {}
 140         virtual void non_realtime_locate (framepos_t);
 141         virtual void set_pending_declick (int);
 142
 143         /* end of vfunc-based API */
 144
 145         void shift (framepos_t, framecnt_t);
 146
 147         void set_gain (gain_t val, PBD::Controllable::GroupControlDisposition);
 148         void inc_gain (gain_t delta);
 149
 150         void set_trim (gain_t val, PBD::Controllable::GroupControlDisposition);
 151
 152         void set_mute_points (MuteMaster::MutePoint);
 153         MuteMaster::MutePoint mute_points () const;
 154
 155         bool muted () const;
 156         void set_mute (bool yn, PBD::Controllable::GroupControlDisposition);
 157
 158         bool muted_by_others() const;
 159
 160         /* controls use set_solo() to modify this route's solo state
 161          */
 162
 163         void set_solo (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 164         bool soloed () const { return self_soloed () || soloed_by_others (); }
 165         void clear_all_solo_state ();
 166
 167         bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
 168         bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
 169         bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
 170         bool self_soloed () const { return _self_solo; }
 171
 172         void set_solo_isolated (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 173         bool solo_isolated() const;
 174
 175         void set_solo_safe (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 176         bool solo_safe() const;
 177
 178         void set_listen (bool yn, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
 179         bool listening_via_monitor () const;
 180         void enable_monitor_send ();
 181
 182         void set_phase_invert (uint32_t, bool yn);
 183         void set_phase_invert (boost::dynamic_bitset<>);
 184         bool phase_invert (uint32_t) const;
 185         boost::dynamic_bitset<> phase_invert () const;
 186
 187         void set_denormal_protection (bool yn);
 188         bool denormal_protection() const;
 189
 190         void         set_meter_point (MeterPoint, bool force = false);
 191         bool         apply_processor_changes_rt ();
 192         void         emit_pending_signals ();
 193         MeterPoint   meter_point() const { return _pending_meter_point; }
 194
 195         void         set_meter_type (MeterType t) { _meter_type = t; }
 196         MeterType    meter_type() const { return _meter_type; }
 197
 198         /* Processors */
 199
 200         boost::shared_ptr<Amp> amp() const  { return _amp; }
 201         boost::shared_ptr<Amp> trim() const { return _trim; }
 202         PeakMeter&       peak_meter()       { return *_meter.get(); }
 203         const PeakMeter& peak_meter() const { return *_meter.get(); }
 204         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 205         boost::shared_ptr<DelayLine> delay_line() const  { return _delayline; }
 206
 207         void flush_processors ();
 208
 209         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 210                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 211                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 212                         method (boost::weak_ptr<Processor> (*i));
 213                 }
 214         }
 215
 216         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 217                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 218                 ProcessorList::iterator i;
 219                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 220                 if (i == _processors.end()) {
 221                         return boost::shared_ptr<Processor> ();
 222                 } else {
 223                         return *i;
 224                 }
 225         }
 226
 227         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 228
 229         boost::shared_ptr<Processor> nth_plugin (uint32_t n) const;
 230         boost::shared_ptr<Processor> nth_send (uint32_t n) const;
 231
 232         bool has_io_processor_named (const std::string&);
 233         ChanCount max_processor_streams () const { return processor_max_streams; }
 234
 235         std::list<std::string> unknown_processors () const;
 236
 237         /* special processors */
 238
 239         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 240         /** the signal processorat at end of the processing chain which produces output */
 241         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 242         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 243         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 244         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 245         void add_internal_return ();
 246         void add_send_to_internal_return (InternalSend *);
 247         void remove_send_from_internal_return (InternalSend *);
 248         void listen_position_changed ();
 249         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 250
 251         /** A record of the stream configuration at some point in the processor list.
 252          * Used to return where and why an processor list configuration request failed.
 253          */
 254         struct ProcessorStreams {
 255                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 256
 257                 uint32_t  index; ///< Index of processor where configuration failed
 258                 ChanCount count; ///< Input requested of processor
 259         };
 260
 261         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 262         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 263         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 264         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 265         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 266         boost::shared_ptr<Processor> before_processor_for_index (int);
 267         bool processors_reorder_needs_configure (const ProcessorList& new_order);
 268         /** remove plugin/processor
 269          *
 270          * @param proc processor to remove
 271          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 272          * @param need_process_lock if locking is required (set to true, unless called from RT context with lock)
 273          * @returns 0 on success
 274          */
 275         int remove_processor (boost::shared_ptr<Processor> proc, ProcessorStreams* err = 0, bool need_process_lock = true);
 276         /** replace plugin/processor with another
 277          *
 278          * @param old processor to remove
 279          * @param sub processor to substitute the old one with
 280          * @param err error report (index where removal vailed, channel-count why it failed) may be nil
 281          * @returns 0 on success
 282          */
 283         int replace_processor (boost::shared_ptr<Processor> old, boost::shared_ptr<Processor> sub, ProcessorStreams* err = 0);
 284         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 285         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 286         void disable_processors (Placement);
 287         void disable_processors ();
 288         void disable_plugins (Placement);
 289         void disable_plugins ();
 290         void ab_plugins (bool forward);
 291         void clear_processors (Placement);
 292         void all_visible_processors_active (bool);
 293
 294         bool strict_io () const { return _strict_io; }
 295         bool set_strict_io (bool);
 296         /** reset plugin-insert configuration to default, disable customizations.
 297          *
 298          * This is equivalent to calling
 299          * @code
 300          * customize_plugin_insert (proc, 0, unused)
 301          * @endcode
 302          *
 303          * @param proc Processor to reset
 304          * @returns true if successful
 305          */
 306         bool reset_plugin_insert (boost::shared_ptr<Processor> proc);
 307         /** enable custom plugin-insert configuration
 308          * @param proc Processor to customize
 309          * @param count number of plugin instances to use (if zero, reset to default)
 310          * @param outs output port customization
 311          * @param sinks input pins for variable-I/O plugins
 312          * @returns true if successful
 313          */
 314         bool customize_plugin_insert (boost::shared_ptr<Processor> proc, uint32_t count, ChanCount outs, ChanCount sinks);
 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         void processor_selfdestruct (boost::weak_ptr<Processor>);
 840         std::vector<boost::weak_ptr<Processor> > selfdestruct_sequence;
 841         Glib::Threads::Mutex  selfdestruct_lock;
 842
 843         bool input_port_count_changing (ChanCount);
 844         bool output_port_count_changing (ChanCount);
 845
 846         bool _in_configure_processors;
 847         bool _initial_io_setup;
 848         bool _in_sidechain_setup;
 849
 850         int configure_processors_unlocked (ProcessorStreams*, Glib::Threads::RWLock::WriterLock*);
 851         bool set_meter_point_unlocked ();
 852         void apply_processor_order (const ProcessorList& new_order);
 853
 854         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 855         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 856
 857         bool add_processor_from_xml_2X (const XMLNode&, int);
 858
 859         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 860
 861         void set_self_solo (bool yn);
 862         void set_mute_master_solo ();
 863
 864         void set_processor_positions ();
 865         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 866
 867         void setup_invisible_processors ();
 868         void unpan ();
 869
 870         void set_plugin_state_dir (boost::weak_ptr<Processor>, const std::string&);
 871
 872         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 873
 874         /** A handy class to keep processor state while we attempt a reconfiguration
 875          *  that may fail.
 876          */
 877         class ProcessorState {
 878         public:
 879                 ProcessorState (Route* r)
 880                         : _route (r)
 881                         , _processors (r->_processors)
 882                         , _processor_max_streams (r->processor_max_streams)
 883                 { }
 884
 885                 void restore () {
 886                         _route->_processors = _processors;
 887                         _route->processor_max_streams = _processor_max_streams;
 888                 }
 889
 890         private:
 891                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 892                    not hang around long enough for it to matter.
 893                 */
 894                 Route* _route;
 895                 ProcessorList _processors;
 896                 ChanCount _processor_max_streams;
 897         };
 898
 899         friend class ProcessorState;
 900
 901         bool _strict_io;
 902
 903         /* no copy construction */
 904         Route (Route const &);
 905
 906         void maybe_note_meter_position ();
 907
 908         /** true if we've made a note of a custom meter position in these variables */
 909         bool _custom_meter_position_noted;
 910         /** the processor that came after the meter when it was last set to a custom position,
 911             or 0.
 912         */
 913         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 914
 915         void reset_instrument_info ();
 916
 917         void set_remote_control_id_internal (uint32_t id, bool notify_class_listeners = true);
 918 };
 919
 920 } // namespace ARDOUR
 921
 922 #endif /* __ardour_route_h__ */