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