libs/ardour/ardour/route.h

   1 /*
   2     Copyright (C) 2000-2002 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 #ifndef __ardour_route_h__
  21 #define __ardour_route_h__
  22
  23 #include <cmath>
  24 #include <cstring>
  25 #include <list>
  26 #include <map>
  27 #include <set>
  28 #include <string>
  29
  30 #include <boost/shared_ptr.hpp>
  31 #include <boost/weak_ptr.hpp>
  32 #include <boost/dynamic_bitset.hpp>
  33 #include <boost/enable_shared_from_this.hpp>
  34
  35 #include <glibmm/threads.h>
  36 #include "pbd/fastlog.h"
  37 #include "pbd/xml++.h"
  38 #include "pbd/undo.h"
  39 #include "pbd/stateful.h"
  40 #include "pbd/controllable.h"
  41 #include "pbd/destructible.h"
  42
  43 #include "ardour/ardour.h"
  44 #include "ardour/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         uint32_t order_key (RouteSortOrderKey) const;
 105         bool has_order_key (RouteSortOrderKey) const;
 106         void set_order_key (RouteSortOrderKey, uint32_t);
 107         void sync_order_keys (RouteSortOrderKey);
 108
 109         bool is_hidden() const { return _flags & Hidden; }
 110         bool is_master() const { return _flags & MasterOut; }
 111         bool is_monitor() const { return _flags & MonitorOut; }
 112
 113         virtual MonitorState monitoring_state () const;
 114         virtual MeterState metering_state () const;
 115
 116         /* these are the core of the API of a Route. see the protected sections as well */
 117
 118         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 119                           int declick, bool& need_butler);
 120
 121         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 122                              bool state_changing);
 123
 124         virtual int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
 125                                  bool& need_butler);
 126
 127         virtual bool can_record() { return false; }
 128
 129         virtual void set_record_enabled (bool /*yn*/, void * /*src*/) {}
 130         virtual bool record_enabled() const { return false; }
 131         virtual void nonrealtime_handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
 132         virtual void realtime_handle_transport_stopped () {}
 133         virtual void realtime_locate () {}
 134         virtual void non_realtime_locate (framepos_t);
 135         virtual void set_pending_declick (int);
 136
 137         /* end of vfunc-based API */
 138
 139         void shift (framepos_t, framecnt_t);
 140
 141         void set_gain (gain_t val, void *src);
 142         void inc_gain (gain_t delta, void *src);
 143
 144         void set_mute_points (MuteMaster::MutePoint);
 145         MuteMaster::MutePoint mute_points () const;
 146
 147         bool muted () const;
 148         void set_mute (bool yn, void* src);
 149
 150         /* controls use set_solo() to modify this route's solo state
 151          */
 152
 153         void set_solo (bool yn, void *src);
 154         bool soloed () const { return self_soloed () || soloed_by_others (); }
 155         void cancel_solo_after_disconnect (bool upstream);
 156
 157         bool soloed_by_others () const { return _soloed_by_others_upstream||_soloed_by_others_downstream; }
 158         bool soloed_by_others_upstream () const { return _soloed_by_others_upstream; }
 159         bool soloed_by_others_downstream () const { return _soloed_by_others_downstream; }
 160         bool self_soloed () const { return _self_solo; }
 161
 162         void set_solo_isolated (bool yn, void *src);
 163         bool solo_isolated() const;
 164
 165         void set_solo_safe (bool yn, void *src);
 166         bool solo_safe() const;
 167
 168         void set_listen (bool yn, void* src);
 169         bool listening_via_monitor () const;
 170         void enable_monitor_send ();
 171
 172         void set_phase_invert (uint32_t, bool yn);
 173         void set_phase_invert (boost::dynamic_bitset<>);
 174         bool phase_invert (uint32_t) const;
 175         boost::dynamic_bitset<> phase_invert () const;
 176
 177         void set_denormal_protection (bool yn);
 178         bool denormal_protection() const;
 179
 180         void         set_meter_point (MeterPoint, bool force = false);
 181         MeterPoint   meter_point() const { return _meter_point; }
 182         void         meter ();
 183
 184         /* Processors */
 185
 186         boost::shared_ptr<Amp> amp() const  { return _amp; }
 187         PeakMeter&       peak_meter()       { return *_meter.get(); }
 188         const PeakMeter& peak_meter() const { return *_meter.get(); }
 189         boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
 190
 191         void flush_processors ();
 192
 193         void foreach_processor (boost::function<void(boost::weak_ptr<Processor>)> method) {
 194                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 195                 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
 196                         if (boost::dynamic_pointer_cast<UnknownProcessor> (*i)) {
 197                                 break;
 198                         }
 199                         method (boost::weak_ptr<Processor> (*i));
 200                 }
 201         }
 202
 203         boost::shared_ptr<Processor> nth_processor (uint32_t n) {
 204                 Glib::Threads::RWLock::ReaderLock lm (_processor_lock);
 205                 ProcessorList::iterator i;
 206                 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
 207                 if (i == _processors.end()) {
 208                         return boost::shared_ptr<Processor> ();
 209                 } else {
 210                         return *i;
 211                 }
 212         }
 213
 214         boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
 215
 216         boost::shared_ptr<Processor> nth_plugin (uint32_t n);
 217         boost::shared_ptr<Processor> nth_send (uint32_t n);
 218
 219         bool has_io_processor_named (const std::string&);
 220         ChanCount max_processor_streams () const { return processor_max_streams; }
 221
 222         std::list<std::string> unknown_processors () const;
 223
 224         /* special processors */
 225
 226         boost::shared_ptr<InternalSend>     monitor_send() const { return _monitor_send; }
 227         boost::shared_ptr<Delivery>         main_outs() const { return _main_outs; }
 228         boost::shared_ptr<InternalReturn>   internal_return() const { return _intreturn; }
 229         boost::shared_ptr<MonitorProcessor> monitor_control() const { return _monitor_control; }
 230         boost::shared_ptr<Send>             internal_send_for (boost::shared_ptr<const Route> target) const;
 231         void add_internal_return ();
 232         void add_send_to_internal_return (InternalSend *);
 233         void remove_send_from_internal_return (InternalSend *);
 234         void listen_position_changed ();
 235         boost::shared_ptr<CapturingProcessor> add_export_point(/* Add some argument for placement later */);
 236
 237         /** A record of the stream configuration at some point in the processor list.
 238          * Used to return where and why an processor list configuration request failed.
 239          */
 240         struct ProcessorStreams {
 241                 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
 242
 243                 uint32_t  index; ///< Index of processor where configuration failed
 244                 ChanCount count; ///< Input requested of processor
 245         };
 246
 247         int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0, bool activation_allowed = true);
 248         int add_processor_by_index (boost::shared_ptr<Processor>, int, ProcessorStreams* err = 0, bool activation_allowed = true);
 249         int add_processor (boost::shared_ptr<Processor>, boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool activation_allowed = true);
 250         int add_processors (const ProcessorList&, boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
 251         boost::shared_ptr<Processor> before_processor_for_placement (Placement);
 252         boost::shared_ptr<Processor> before_processor_for_index (int);
 253         int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0, bool need_process_lock = true);
 254         int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
 255         int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
 256         void disable_processors (Placement);
 257         void disable_processors ();
 258         void disable_plugins (Placement);
 259         void disable_plugins ();
 260         void ab_plugins (bool forward);
 261         void clear_processors (Placement);
 262         void all_visible_processors_active (bool);
 263
 264         framecnt_t set_private_port_latencies (bool playback) const;
 265         void       set_public_port_latencies (framecnt_t, bool playback) const;
 266
 267         framecnt_t   update_signal_latency();
 268         virtual void set_latency_compensation (framecnt_t);
 269
 270         void set_user_latency (framecnt_t);
 271         framecnt_t initial_delay() const { return _initial_delay; }
 272         framecnt_t signal_latency() const { return _signal_latency; }
 273
 274         PBD::Signal0<void>       active_changed;
 275         PBD::Signal0<void>       phase_invert_changed;
 276         PBD::Signal0<void>       denormal_protection_changed;
 277         PBD::Signal1<void,void*> listen_changed;
 278         PBD::Signal2<void,bool,void*> solo_changed;
 279         PBD::Signal1<void,void*> solo_safe_changed;
 280         PBD::Signal1<void,void*> solo_isolated_changed;
 281         PBD::Signal1<void,void*> comment_changed;
 282         PBD::Signal1<void,void*> mute_changed;
 283         PBD::Signal0<void>       mute_points_changed;
 284
 285         /** the processors have changed; the parameter indicates what changed */
 286         PBD::Signal1<void,RouteProcessorChange> processors_changed;
 287         PBD::Signal1<void,void*> record_enable_changed;
 288         /** the metering point has changed */
 289         PBD::Signal0<void>       meter_change;
 290         PBD::Signal0<void>       signal_latency_changed;
 291         PBD::Signal0<void>       initial_delay_changed;
 292
 293         /** Emitted with the process lock held */
 294         PBD::Signal0<void>       io_changed;
 295
 296         /* gui's call this for their own purposes. */
 297
 298         PBD::Signal2<void,std::string,void*> gui_changed;
 299
 300         /* stateful */
 301
 302         XMLNode& get_state();
 303         virtual int set_state (const XMLNode&, int version);
 304         virtual XMLNode& get_template();
 305
 306         XMLNode& get_processor_state ();
 307         virtual void set_processor_state (const XMLNode&);
 308
 309         int save_as_template (const std::string& path, const std::string& name);
 310
 311         PBD::Signal1<void,void*> SelectedChanged;
 312
 313         int add_aux_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>);
 314         void remove_aux_or_listen (boost::shared_ptr<Route>);
 315
 316         /**
 317          * return true if this route feeds the first argument via at least one
 318          * (arbitrarily long) signal pathway.
 319          */
 320         bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
 321
 322         /**
 323          * return true if this route feeds the first argument directly, via
 324          * either its main outs or a send.  This is checked by the actual
 325          * connections, rather than by what the graph is currently doing.
 326          */
 327         bool direct_feeds_according_to_reality (boost::shared_ptr<Route>, bool* via_send_only = 0);
 328
 329         /**
 330          * return true if this route feeds the first argument directly, via
 331          * either its main outs or a send, according to the graph that
 332          * is currently being processed.
 333          */
 334         bool direct_feeds_according_to_graph (boost::shared_ptr<Route>, bool* via_send_only = 0);
 335
 336         struct FeedRecord {
 337                 boost::weak_ptr<Route> r;
 338                 bool sends_only;
 339
 340                 FeedRecord (boost::shared_ptr<Route> rp, bool sendsonly)
 341                 : r (rp)
 342                 , sends_only (sendsonly) {}
 343         };
 344
 345         struct FeedRecordCompare {
 346                 bool operator() (const FeedRecord& a, const FeedRecord& b) const {
 347                         return a.r < b.r;
 348                 }
 349         };
 350
 351         typedef std::set<FeedRecord,FeedRecordCompare> FedBy;
 352
 353         const FedBy& fed_by() const { return _fed_by; }
 354         void clear_fed_by ();
 355         bool add_fed_by (boost::shared_ptr<Route>, bool sends_only);
 356
 357         /* Controls (not all directly owned by the Route */
 358
 359         boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
 360
 361         class SoloControllable : public AutomationControl {
 362         public:
 363                 SoloControllable (std::string name, boost::shared_ptr<Route>);
 364                 void set_value (double);
 365                 double get_value () const;
 366
 367         private:
 368                 boost::weak_ptr<Route> _route;
 369         };
 370
 371         struct MuteControllable : public AutomationControl {
 372         public:
 373                 MuteControllable (std::string name, boost::shared_ptr<Route>);
 374                 void set_value (double);
 375                 double get_value () const;
 376
 377         private:
 378                 boost::weak_ptr<Route> _route;
 379         };
 380
 381         boost::shared_ptr<AutomationControl> solo_control() const {
 382                 return _solo_control;
 383         }
 384
 385         boost::shared_ptr<AutomationControl> mute_control() const {
 386                 return _mute_control;
 387         }
 388
 389         boost::shared_ptr<MuteMaster> mute_master() const {
 390                 return _mute_master;
 391         }
 392
 393         /* Route doesn't own these items, but sub-objects that it does own have them
 394            and to make UI code a bit simpler, we provide direct access to them
 395            here.
 396         */
 397
 398         boost::shared_ptr<Panner> panner() const;  /* may return null */
 399         boost::shared_ptr<PannerShell> panner_shell() const;
 400         boost::shared_ptr<AutomationControl> gain_control() const;
 401         boost::shared_ptr<Pannable> pannable() const;
 402
 403         /**
 404            Return the first processor that accepts has at least one MIDI input
 405            and at least one audio output. In the vast majority of cases, this
 406            will be "the instrument". This does not preclude other MIDI->audio
 407            processors later in the processing chain, but that would be a
 408            special case not covered by this utility function.
 409         */
 410         boost::shared_ptr<Processor> the_instrument() const;
 411         InstrumentInfo& instrument_info() { return _instrument_info; }
 412
 413         void protect_automation ();
 414
 415         enum {
 416                 /* These numbers are taken from MIDI Machine Control,
 417                    which can only control up to 317 tracks without
 418                    doing sysex segmentation.
 419                 */
 420                 MasterBusRemoteControlID = 318,
 421                 MonitorBusRemoteControlID = 319,
 422         };
 423
 424         void     set_remote_control_id (uint32_t id, bool notify_class_listeners = true);
 425         uint32_t remote_control_id () const;
 426         void     set_remote_control_id_from_order_key (RouteSortOrderKey, uint32_t order_key);
 427
 428         /* for things concerned about *this* route's RID */
 429
 430         PBD::Signal0<void> RemoteControlIDChanged;
 431
 432         /* for things concerned about *any* route's RID changes */
 433
 434         static PBD::Signal0<void> RemoteControlIDChange;
 435         static PBD::Signal1<void,RouteSortOrderKey> 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::Threads::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
 522         uint32_t pans_required() const;
 523         ChanCount n_process_buffers ();
 524
 525         virtual void maybe_declick (BufferSet&, framecnt_t, int);
 526
 527         boost::shared_ptr<Amp>       _amp;
 528         boost::shared_ptr<PeakMeter> _meter;
 529
 530   private:
 531         int set_state_2X (const XMLNode&, int);
 532         void set_processor_state_2X (XMLNodeList const &, int);
 533
 534         typedef std::map<RouteSortOrderKey,uint32_t> OrderKeys;
 535         OrderKeys order_keys;
 536         uint32_t _remote_control_id;
 537
 538         void input_change_handler (IOChange, void *src);
 539         void output_change_handler (IOChange, void *src);
 540
 541         bool input_port_count_changing (ChanCount);
 542
 543         bool _in_configure_processors;
 544
 545         int configure_processors_unlocked (ProcessorStreams*);
 546         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors (ChanCount, ProcessorStreams *);
 547         std::list<std::pair<ChanCount, ChanCount> > try_configure_processors_unlocked (ChanCount, ProcessorStreams *);
 548
 549         bool add_processor_from_xml_2X (const XMLNode&, int);
 550
 551         void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
 552
 553         void set_self_solo (bool yn);
 554         void set_mute_master_solo ();
 555
 556         void set_processor_positions ();
 557         framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
 558
 559         void setup_invisible_processors ();
 560         void unpan ();
 561
 562         boost::shared_ptr<CapturingProcessor> _capturing_processor;
 563
 564         /** A handy class to keep processor state while we attempt a reconfiguration
 565          *  that may fail.
 566          */
 567         class ProcessorState {
 568         public:
 569                 ProcessorState (Route* r)
 570                         : _route (r)
 571                         , _processors (r->_processors)
 572                         , _processor_max_streams (r->processor_max_streams)
 573                 { }
 574
 575                 void restore () {
 576                         _route->_processors = _processors;
 577                         _route->processor_max_streams = _processor_max_streams;
 578                 }
 579
 580         private:
 581                 /* this should perhaps be a shared_ptr, but ProcessorStates will
 582                    not hang around long enough for it to matter.
 583                 */
 584                 Route* _route;
 585                 ProcessorList _processors;
 586                 ChanCount _processor_max_streams;
 587         };
 588
 589         friend class ProcessorState;
 590
 591         /* no copy construction */
 592         Route (Route const &);
 593
 594         void maybe_note_meter_position ();
 595
 596         /** true if we've made a note of a custom meter position in these variables */
 597         bool _custom_meter_position_noted;
 598         /** the processor that came after the meter when it was last set to a custom position,
 599             or 0.
 600         */
 601         boost::weak_ptr<Processor> _processor_after_last_custom_meter;
 602         /** true if the last custom meter position was at the end of the processor list */
 603         bool _last_custom_meter_was_at_end;
 604
 605         void reset_instrument_info ();
 606 };
 607
 608 } // namespace ARDOUR
 609
 610 #endif /* __ardour_route_h__ */