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/thread.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/instrument_info.h"
  45 #include "ardour/io.h"
  46 #include "ardour/types.h"
  47 #include "ardour/mute_master.h"
  48 #include "ardour/route_group_member.h"
  49 #include "ardour/graphnode.h"
  50 #include "ardour/automatable.h"
  51 #include "ardour/unknown_processor.h"
  52
  53 namespace ARDOUR {
  54
  55 class Amp;
  56 class Delivery;
  57 class IOProcessor;
  58 class Panner;
  59 class PannerShell;
  60 class PortSet;
  61 class Processor;
  62 class RouteGroup;
  63 class Send;
  64 class InternalReturn;
  65 class MonitorProcessor;
  66 class Pannable;
  67 class CapturingProcessor;
  68 class InternalSend;
  69
  70 class Route : public SessionObject, public Automatable, public RouteGroupMember, public GraphNode, public boost::enable_shared_from_this<Route>
  71 {
  72   public:
  73
  74         typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
  75
  76         enum Flag {
  77                 Hidden = 0x1,
  78                 MasterOut = 0x2,
  79                 MonitorOut = 0x4
  80         };
  81
  82         Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
  83         virtual ~Route();
  84
  85         virtual int init ();
  86
  87         boost::shared_ptr<IO> input() const { return _input; }
  88         boost::shared_ptr<IO> output() const { return _output; }
  89
  90         ChanCount n_inputs() const { return _input->n_ports(); }
  91         ChanCount n_outputs() const { return _output->n_ports(); }
  92
  93         bool active() const { return _active; }
  94         void set_active (bool yn, void *);
  95
  96         static std::string ensure_track_or_route_name(std::string, Session &);
  97
  98         std::string comment() { return _comment; }
  99         void set_comment (std::string str, void *src);
 100
 101         bool set_name (const std::string& str);
 102         static void set_name_in_state (XMLNode &, const std::string &);
 103
 104         int32_t order_key (std::string const &) const;
 105         void set_order_key (std::string const &, int32_t);
 106
 107         bool is_hidden() const { return _flags & Hidden; }
 108         bool is_master() const { return _flags & MasterOut; }
 109         bool is_monitor() const { return _flags & MonitorOut; }
 110
 111         virtual MonitorState monitoring_state () const;
 112         virtual MeterState metering_state () const;
 113
 114         /* these are the core of the API of a Route. see the protected sections as well */
 115
 116         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 117                           int declick, bool& need_butler);
 118
 119         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 120                              bool state_changing);
 121
 122         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 123                                  bool& need_butler);
 124
 125         virtual bool can_record() { return false; }
 126
 127         virtual void set_record_enabled (bool /*yn*/, void * /*src*/) {}
 128         virtual bool record_enabled() const { return false; }
 129         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 130         virtual void realtime_handle_transport_stopped () {}
 131         virtual void realtime_locate () {}
 132         virtual void set_pending_declick (int);
 133
 134         /* end of vfunc-based API */
 135
 136         void shift (framepos_t, framecnt_t);
 137
 138         void set_gain (gain_t val, void *src);
 139         void inc_gain (gain_t delta, void *src);
 140
 141         void set_mute_points (MuteMaster::MutePoint);
 142         MuteMaster::MutePoint mute_points () const;
 143
 144         bool muted () const;
 145         void set_mute (bool yn, void* src);
 146
 147         /* controls use set_solo() to modify this route's solo state
 148          */
 149
 150         void set_solo (bool yn, void *src);
 151         bool soloed () const { return self_soloed () || soloed_by_others (); }
 152         void cancel_solo_after_disconnect (bool upstream);
 153
 154         bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
 155         bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
 156         bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
 157         bool self_soloed () const { return _self_solo; }
 158
 159         void set_solo_isolated (bool yn, void *src);
 160         bool solo_isolated() const;
 161
 162         void set_solo_safe (bool yn, void *src);
 163         bool solo_safe() const;
 164
 165         void set_listen (bool yn, void* src);
 166         bool listening_via_monitor () const;
 167         void enable_monitor_send ();
 168
 169         void set_phase_invert (uint32_t, bool yn);
 170         void set_phase_invert (boost::dynamic_bitset<>);
 171         bool phase_invert (uint32_t) const;
 172         boost::dynamic_bitset<> phase_invert () const;
 173
 174         void set_denormal_protection (bool yn);
 175         bool denormal_protection() const;
 176
 177         void         set_meter_point (MeterPoint, bool force = false);
 178         MeterPoint   meter_point() const { return _meter_point; }
 179         void         meter ();
 180
 181         /* Processors */
 182
 183         boost::shared_ptr<Amp> amp() const  { return _amp; }
 184         PeakMeter&       peak_meter()       { return *_meter.get(); }
 185         const PeakMeter& peak_meter() const { return *_meter.get(); }
 186         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 187
 188         void flush_processors ();
 189
 190         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 191                 Glib::RWLock::ReaderLock lm (_processor_lock);
 192                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 193                         if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 194                                 break;
 195                         }
 196                         method (boost::weak_ptr<Processor> (*i));
 197                 }
 198         }
 199
 200         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 201                 Glib::RWLock::ReaderLock lm (_processor_lock);
 202                 ProcessorList::iterator i;
 203                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 204                 if (i == _processors.end()) {
 205                         return boost::shared_ptr<Processor> ();
 206                 } else {
 207                         return *i;
 208                 }
 209         }
 210
 211         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 212
 213         boost::shared_ptr<Processor> nth_plugin (uint32_t n);
 214         boost::shared_ptr<Processor> nth_send (uint32_t n);
 215
 216         bool has_io_processor_named (const std::string&);
 217         ChanCount max_processor_streams () const { return processor_max_streams; }
 218
 219         std::list<std::string> unknown_processors () const;
 220
 221         /* special processors */
 222
 223         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 224         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 225         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 226         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 227         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 228         void add_internal_return ();
 229         void add_send_to_internal_return (InternalSend *);
 230         void remove_send_from_internal_return (InternalSend *);
 231         void listen_position_changed ();
 232         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 233
 234         /** A record of the stream configuration at some point in the processor list.
 235          * Used to return where and why an processor list configuration request failed.
 236          */
 237         struct ProcessorStreams {
 238                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 239
 240                 uint32_t  index; ///< Index of processor where configuration failed
 241                 ChanCount count; ///< Input requested of processor
 242         };
 243
 244         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 245         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 246         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 247         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 248         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 249         boost::shared_ptr<Processor> before_processor_for_index (int);
 250         int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool need_process_lock = true);
 251         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 252         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 253         void disable_processors (Placement);
 254         void disable_processors ();
 255         void disable_plugins (Placement);
 256         void disable_plugins ();
 257         void ab_plugins (bool forward);
 258         void clear_processors (Placement);
 259         void all_visible_processors_active (bool);
 260
 261         framecnt_t set_private_port_latencies (bool playback) const;
 262         void       set_public_port_latencies (framecnt_t, bool playback) const;
 263
 264         framecnt_t   update_signal_latency();
 265         virtual void set_latency_compensation (framecnt_t);
 266
 267         void set_user_latency (framecnt_t);
 268         framecnt_t initial_delay() const { return _initial_delay; }
 269         framecnt_t signal_latency() const { return _signal_latency; }
 270
 271         PBD::Signal0<void>       active_changed;
 272         PBD::Signal0<void>       phase_invert_changed;
 273         PBD::Signal0<void>       denormal_protection_changed;
 274         PBD::Signal1<void,void*> listen_changed;
 275         PBD::Signal2<void,bool,void*> solo_changed;
 276         PBD::Signal1<void,void*> solo_safe_changed;
 277         PBD::Signal1<void,void*> solo_isolated_changed;
 278         PBD::Signal1<void,void*> comment_changed;
 279         PBD::Signal1<void,void*> mute_changed;
 280         PBD::Signal0<void>       mute_points_changed;
 281
 282         /** the processors have changed; the parameter indicates what changed */
 283         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 284         PBD::Signal1<void,void*> record_enable_changed;
 285         /** the metering point has changed */
 286         PBD::Signal0<void>       meter_change;
 287         PBD::Signal0<void>       signal_latency_changed;
 288         PBD::Signal0<void>       initial_delay_changed;
 289         PBD::Signal0<void>       order_key_changed;
 290
 291         /** Emitted with the process lock held */
 292         PBD::Signal0<void>       io_changed;
 293
 294         /* gui's call this for their own purposes. */
 295
 296         PBD::Signal2<void,std::string,void*> gui_changed;
 297
 298         /* stateful */
 299
 300         XMLNode& get_state();
 301         virtual int set_state (const XMLNode&, int version);
 302         virtual XMLNode& get_template();
 303
 304         XMLNode& get_processor_state ();
 305         virtual void set_processor_state (const XMLNode&);
 306
 307         int save_as_template (const std::string& path, const std::string& name);
 308
 309         PBD::Signal1<void,void*> SelectedChanged;
 310
 311         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 312         void remove_aux_or_listen (boost::shared_ptr<Route>);
 313
 314         /**
 315          * return true if this route feeds the first argument via at least one
 316          * (arbitrarily long) signal pathway.
 317          */
 318         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 319
 320         /**
 321          * return true if this route feeds the first argument directly, via
 322          * either its main outs or a send.  This is checked by the actual
 323          * connections, rather than by what the graph is currently doing.
 324          */
 325         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 326
 327         /**
 328          * return true if this route feeds the first argument directly, via
 329          * either its main outs or a send, according to the graph that
 330          * is currently being processed.
 331          */
 332         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 333
 334         struct FeedRecord {
 335                 boost::weak_ptr<Route> r;
 336                 bool sends_only;
 337
 338                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 339                 : r (rp)
 340                 , sends_only (sendsonly) {}
 341         };
 342
 343         struct FeedRecordCompare {
 344                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 345                         return a.r < b.r;
 346                 }
 347         };
 348
 349         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 350
 351         const FedBy& fed_by() const { return _fed_by; }
 352         void clear_fed_by ();
 353         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 354
 355         /* Controls (not all directly owned by the Route */
 356
 357         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 358
 359         class SoloControllable : public AutomationControl {
 360         public:
 361                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 362                 void set_value (double);
 363                 double get_value () const;
 364
 365         private:
 366                 boost::weak_ptr<Route> _route;
 367         };
 368
 369         struct MuteControllable : public AutomationControl {
 370         public:
 371                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 372                 void set_value (double);
 373                 double get_value () const;
 374
 375         private:
 376                 boost::weak_ptr<Route> _route;
 377         };
 378
 379         boost::shared_ptr<AutomationControl> solo_control() const {
 380                 return _solo_control;
 381         }
 382
 383         boost::shared_ptr<AutomationControl> mute_control() const {
 384                 return _mute_control;
 385         }
 386
 387         boost::shared_ptr<MuteMaster> mute_master() const {
 388                 return _mute_master;
 389         }
 390
 391         /* Route doesn't own these items, but sub-objects that it does own have them
 392            and to make UI code a bit simpler, we provide direct access to them
 393            here.
 394         */
 395
 396         boost::shared_ptr<Panner> panner() const;  /* may return null */
 397         boost::shared_ptr<PannerShell> panner_shell() const;
 398         boost::shared_ptr<AutomationControl> gain_control() const;
 399         boost::shared_ptr<Pannable> pannable() const;
 400
 401         /**
 402            Return the first processor that accepts has at least one MIDI input
 403            and at least one audio output. In the vast majority of cases, this
 404            will be "the instrument". This does not preclude other MIDI->audio
 405            processors later in the processing chain, but that would be a
 406            special case not covered by this utility function.
 407         */
 408         boost::shared_ptr<Processor> the_instrument() const;
 409         InstrumentInfo& instrument_info() { return _instrument_info; }
 410
 411         void automation_snapshot (framepos_t now, bool force=false);
 412         void protect_automation ();
 413
 414         enum {
 415                 /* These numbers are taken from MIDI Machine Control,
 416                    which can only control up to 317 tracks without
 417                    doing sysex segmentation.
 418                 */
 419                 MasterBusRemoteControlID = 318,
 420                 MonitorBusRemoteControlID = 319,
 421         };
 422
 423         void set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 424         uint32_t remote_control_id () const;
 425
 426         /* for things concerned about *this* route's RID */
 427
 428         PBD::Signal0<void> RemoteControlIDChanged;
 429
 430         /* for things concerned about any route's RID changes */
 431
 432         static PBD::Signal0<void> RemoteControlIDChange;
 433
 434         void sync_order_keys (std::string const &);
 435         static PBD::Signal1<void,std::string const &> SyncOrderKeys;
 436
 437         bool has_external_redirects() const;
 438
 439   protected:
 440         friend class Session;
 441
 442         void catch_up_on_solo_mute_override ();
 443         void mod_solo_by_others_upstream (int32_t);
 444         void mod_solo_by_others_downstream (int32_t);
 445         void curve_reallocate ();
 446         virtual void set_block_size (pframes_t nframes);
 447
 448   protected:
 449         virtual framecnt_t check_initial_delay (framecnt_t nframes, framepos_t&) { return nframes; }
 450
 451         void passthru (framepos_t start_frame, framepos_t end_frame,
 452                         pframes_t nframes, int declick);
 453
 454         virtual void write_out_of_band_data (BufferSet& /* bufs */, framepos_t /* start_frame */, framepos_t /* end_frame */,
 455                         framecnt_t /* nframes */) {}
 456
 457         virtual void process_output_buffers (BufferSet& bufs,
 458                                              framepos_t start_frame, framepos_t end_frame,
 459                                              pframes_t nframes, int declick,
 460                                              bool gain_automation_ok);
 461
 462         boost::shared_ptr<IO> _input;
 463         boost::shared_ptr<IO> _output;
 464
 465         bool           _active;
 466         framecnt_t     _signal_latency;
 467         framecnt_t     _initial_delay;
 468         framecnt_t     _roll_delay;
 469
 470         ProcessorList  _processors;
 471         mutable Glib::RWLock   _processor_lock;
 472         boost::shared_ptr<Delivery> _main_outs;
 473         boost::shared_ptr<InternalSend> _monitor_send;
 474         boost::shared_ptr<InternalReturn> _intreturn;
 475         boost::shared_ptr<MonitorProcessor> _monitor_control;
 476         boost::shared_ptr<Pannable> _pannable;
 477
 478         Flag           _flags;
 479         int            _pending_declick;
 480         MeterPoint     _meter_point;
 481         boost::dynamic_bitset<> _phase_invert;
 482         bool           _self_solo;
 483         uint32_t       _soloed_by_others_upstream;
 484         uint32_t       _soloed_by_others_downstream;
 485         uint32_t       _solo_isolated;
 486
 487         bool           _denormal_protection;
 488
 489         bool _recordable : 1;
 490         bool _silent : 1;
 491         bool _declickable : 1;
 492
 493         boost::shared_ptr<SoloControllable> _solo_control;
 494         boost::shared_ptr<MuteControllable> _mute_control;
 495         boost::shared_ptr<MuteMaster> _mute_master;
 496
 497         virtual void act_on_mute () {}
 498
 499         std::string    _comment;
 500         bool           _have_internal_generator;
 501         bool           _solo_safe;
 502         DataType       _default_type;
 503         FedBy          _fed_by;
 504
 505         InstrumentInfo _instrument_info;
 506
 507         virtual ChanCount input_streams () const;
 508
 509   protected:
 510         virtual XMLNode& state(bool);
 511
 512         int configure_processors (ProcessorStreams*);
 513
 514         void passthru_silence (framepos_t start_frame, framepos_t end_frame,
 515                                pframes_t nframes, int declick);
 516
 517         void silence (framecnt_t);
 518         void silence_unlocked (framecnt_t);
 519
 520         ChanCount processor_max_streams;
 521         uint32_t _remote_control_id;
 522
 523         uint32_t pans_required() const;
 524         ChanCount n_process_buffers ();
 525
 526         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 527
 528         boost::shared_ptr<Amp>       _amp;
 529         boost::shared_ptr<PeakMeter> _meter;
 530
 531   private:
 532         int set_state_2X (const XMLNode&, int);
 533         void set_processor_state_2X (XMLNodeList const &, int);
 534
 535         static uint32_t order_key_cnt;
 536
 537         typedef std::map<std::string, long> OrderKeys;
 538         OrderKeys order_keys;
 539
 540         void input_change_handler (IOChange, void *src);
 541         void output_change_handler (IOChange, void *src);
 542
 543         bool input_port_count_changing (ChanCount);
 544
 545         bool _in_configure_processors;
 546
 547         int configure_processors_unlocked (ProcessorStreams*);
 548         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 549         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 550
 551         bool add_processor_from_xml_2X (const XMLNode&, int);
 552
 553         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 554
 555         void set_self_solo (bool yn);
 556         void set_mute_master_solo ();
 557
 558         void set_processor_positions ();
 559         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 560
 561         void setup_invisible_processors ();
 562         void unpan ();
 563
 564         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 565
 566         /** A handy class to keep processor state while we attempt a reconfiguration
 567          *  that may fail.
 568          */
 569         class ProcessorState {
 570         public:
 571                 ProcessorState (Route* r)
 572                         : _route (r)
 573                         , _processors (r->_processors)
 574                         , _processor_max_streams (r->processor_max_streams)
 575                 { }
 576
 577                 void restore () {
 578                         _route->_processors = _processors;
 579                         _route->processor_max_streams = _processor_max_streams;
 580                 }
 581
 582         private:
 583                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 584                    not hang around long enough for it to matter.
 585                 */
 586                 Route* _route;
 587                 ProcessorList _processors;
 588                 ChanCount _processor_max_streams;
 589         };
 590
 591         friend class ProcessorState;
 592
 593         /* no copy construction */
 594         Route (Route const &);
 595
 596         void maybe_note_meter_position ();
 597
 598         /** true if we've made a note of a custom meter position in these variables */
 599         bool _custom_meter_position_noted;
 600         /** the processor that came after the meter when it was last set to a custom position,
 601             or 0.
 602         */
 603         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 604         /** true if the last custom meter position was at the end of the processor list */
 605         bool _last_custom_meter_was_at_end;
 606 };
 607
 608 } // namespace ARDOUR
 609
 610 #endif /* __ardour_route_h__ */