2 Copyright (C) 2000-2002 Paul Davis
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.
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.
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.
20 #ifndef __ardour_route_h__
21 #define __ardour_route_h__
30 #include <boost/shared_ptr.hpp>
31 #include <boost/weak_ptr.hpp>
33 #include <glibmm/thread.h>
34 #include "pbd/fastlog.h"
35 #include "pbd/xml++.h"
37 #include "pbd/stateful.h"
38 #include "pbd/controllable.h"
39 #include "pbd/destructible.h"
41 #include "ardour/ardour.h"
42 #include "ardour/io.h"
43 #include "ardour/types.h"
44 #include "ardour/mute_master.h"
57 class Route : public SessionObject, public AutomatableControls
61 typedef std::list<boost::shared_ptr<Processor> > ProcessorList;
69 Route (Session&, std::string name, Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
70 Route (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
73 boost::shared_ptr<IO> input() const { return _input; }
74 boost::shared_ptr<IO> output() const { return _output; }
76 ChanCount n_inputs() const { return _input->n_ports(); }
77 ChanCount n_outputs() const { return _output->n_ports(); }
79 bool active() const { return _active; }
80 void set_active (bool yn);
83 static std::string ensure_track_or_route_name(std::string, Session &);
85 std::string comment() { return _comment; }
86 void set_comment (std::string str, void *src);
88 bool set_name (const std::string& str);
90 long order_key (std::string const &) const;
91 void set_order_key (std::string const &, long);
93 bool is_hidden() const { return _flags & Hidden; }
94 bool is_master() const { return _flags & MasterOut; }
95 bool is_control() const { return _flags & ControlOut; }
97 /* these are the core of the API of a Route. see the protected sections as well */
99 virtual int roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
100 int declick, bool can_record, bool rec_monitors_input);
102 virtual int no_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
103 bool state_changing, bool can_record, bool rec_monitors_input);
105 virtual int silent_roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame,
106 bool can_record, bool rec_monitors_input);
108 virtual void toggle_monitor_input ();
109 virtual bool can_record() { return false; }
111 virtual void set_record_enable (bool /*yn*/, void * /*src*/) {}
112 virtual bool record_enabled() const { return false; }
113 virtual void handle_transport_stopped (bool abort, bool did_locate, bool flush_processors);
114 virtual void set_pending_declick (int);
116 /* end of vfunc-based API */
118 void shift (nframes64_t, nframes64_t);
120 void set_gain (gain_t val, void *src);
121 void inc_gain (gain_t delta, void *src);
123 void set_mute_points (MuteMaster::MutePoint);
124 MuteMaster::MutePoint mute_points() const { return _mute_points; }
125 void set_mute (bool yn, void* src);
128 /* controls use set_solo() to modify this route's solo state
131 void set_solo (bool yn, void *src);
132 bool soloed () const {return self_soloed () || soloed_by_others (); }
134 bool soloed_by_others () const { return !_solo_isolated && _soloed_by_others; }
135 bool self_soloed () const { return _self_solo; }
137 void set_solo_isolated (bool yn, void *src);
138 bool solo_isolated() const;
140 void set_solo_safe (bool yn, void *src);
141 bool solo_safe() const;
143 void set_listen (bool yn, void* src);
144 bool listening () const;
146 void set_phase_invert (bool yn);
147 bool phase_invert() const;
149 void set_denormal_protection (bool yn);
150 bool denormal_protection() const;
152 void set_route_group (RouteGroup *, void *);
153 void drop_route_group (void *);
154 RouteGroup *route_group () const { return _route_group; }
156 virtual void set_meter_point (MeterPoint, void *src);
157 MeterPoint meter_point() const { return _meter_point; }
162 boost::shared_ptr<Amp> amp() const { return _amp; }
163 PeakMeter& peak_meter() { return *_meter.get(); }
164 const PeakMeter& peak_meter() const { return *_meter.get(); }
165 boost::shared_ptr<PeakMeter> shared_peak_meter() const { return _meter; }
167 void flush_processors ();
169 void foreach_processor (sigc::slot<void, boost::weak_ptr<Processor> > method) {
170 Glib::RWLock::ReaderLock lm (_processor_lock);
171 for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
172 method (boost::weak_ptr<Processor> (*i));
176 boost::shared_ptr<Processor> nth_processor (uint32_t n) {
177 Glib::RWLock::ReaderLock lm (_processor_lock);
178 ProcessorList::iterator i;
179 for (i = _processors.begin(); i != _processors.end() && n; ++i, --n) {}
180 if (i == _processors.end()) {
181 return boost::shared_ptr<Processor> ();
187 bool processor_is_prefader (boost::shared_ptr<Processor> p);
189 ChanCount max_processor_streams () const { return processor_max_streams; }
191 /* special processors */
193 boost::shared_ptr<Delivery> control_outs() const { return _control_outs; }
194 boost::shared_ptr<Delivery> main_outs() const { return _main_outs; }
195 boost::shared_ptr<InternalReturn> internal_return() const { return _intreturn; }
196 boost::shared_ptr<Send> internal_send_for (boost::shared_ptr<const Route> target) const;
197 void add_internal_return ();
198 BufferSet* get_return_buffer () const;
199 void release_return_buffer () const;
200 void put_control_outs_at (Placement);
202 /** A record of the stream configuration at some point in the processor list.
203 * Used to return where and why an processor list configuration request failed.
205 struct ProcessorStreams {
206 ProcessorStreams(size_t i=0, ChanCount c=ChanCount()) : index(i), count(c) {}
208 uint32_t index; ///< Index of processor where configuration failed
209 ChanCount count; ///< Input requested of processor
212 int add_processor (boost::shared_ptr<Processor>, Placement placement, ProcessorStreams* err = 0);
213 int add_processor (boost::shared_ptr<Processor>, ProcessorList::iterator iter, ProcessorStreams* err = 0);
214 int add_processors (const ProcessorList&, boost::shared_ptr<Processor> before, ProcessorStreams* err = 0);
215 int add_processors (const ProcessorList&, ProcessorList::iterator iter, ProcessorStreams* err = 0);
216 int remove_processor (boost::shared_ptr<Processor>, ProcessorStreams* err = 0);
217 int remove_processors (const ProcessorList&, ProcessorStreams* err = 0);
218 int reorder_processors (const ProcessorList& new_order, ProcessorStreams* err = 0);
219 void disable_processors (Placement);
220 void disable_processors ();
221 void disable_plugins (Placement);
222 void disable_plugins ();
223 void ab_plugins (bool forward);
224 void clear_processors (Placement);
225 void all_processors_flip();
226 void all_processors_active (Placement, bool state);
228 virtual nframes_t update_total_latency();
229 void set_latency_delay (nframes_t);
230 void set_user_latency (nframes_t);
231 nframes_t initial_delay() const { return _initial_delay; }
233 sigc::signal<void> active_changed;
234 sigc::signal<void> phase_invert_changed;
235 sigc::signal<void> denormal_protection_changed;
236 sigc::signal<void,void*> listen_changed;
237 sigc::signal<void,void*> solo_changed;
238 sigc::signal<void,void*> solo_safe_changed;
239 sigc::signal<void,void*> solo_isolated_changed;
240 sigc::signal<void,void*> comment_changed;
241 sigc::signal<void,void*> mute_changed;
242 sigc::signal<void> mute_points_changed;
243 sigc::signal<void> processors_changed;
244 sigc::signal<void,void*> record_enable_changed;
245 sigc::signal<void,void*> route_group_changed;
246 sigc::signal<void,void*> meter_change;
247 sigc::signal<void> signal_latency_changed;
248 sigc::signal<void> initial_delay_changed;
250 /* gui's call this for their own purposes. */
252 sigc::signal<void,std::string,void*> gui_changed;
256 XMLNode& get_state();
257 int set_state (const XMLNode&, int version);
258 virtual XMLNode& get_template();
260 XMLNode& get_processor_state ();
261 virtual void set_processor_state (const XMLNode&);
263 int save_as_template (const std::string& path, const std::string& name);
265 sigc::signal<void,void*> SelectedChanged;
267 int listen_via (boost::shared_ptr<Route>, Placement p, bool active, bool aux);
268 void drop_listen (boost::shared_ptr<Route>);
270 bool feeds (boost::shared_ptr<Route>, bool* via_send_only = 0);
271 std::set<boost::shared_ptr<Route> > fed_by;
273 /* Controls (not all directly owned by the Route */
275 boost::shared_ptr<AutomationControl> get_control (const Evoral::Parameter& param);
277 struct SoloControllable : public AutomationControl {
278 SoloControllable (std::string name, Route&);
279 void set_value (float);
280 float get_value (void) const;
285 boost::shared_ptr<AutomationControl> solo_control() const {
286 return _solo_control;
289 boost::shared_ptr<AutomationControl> mute_control() const {
293 boost::shared_ptr<MuteMaster> mute_master() const {
297 /* Route doesn't own these items, but sub-objects that it does own have them
298 and to make UI code a bit simpler, we provide direct access to them
302 boost::shared_ptr<Panner> panner() const;
303 boost::shared_ptr<AutomationControl> gain_control() const;
305 void automation_snapshot (nframes_t now, bool force=false);
306 void protect_automation ();
308 void set_remote_control_id (uint32_t id);
309 uint32_t remote_control_id () const;
310 sigc::signal<void> RemoteControlIDChanged;
312 void sync_order_keys (std::string const &);
313 static sigc::signal<void, std::string const &> SyncOrderKeys;
316 friend class Session;
318 void catch_up_on_solo_mute_override ();
319 void mod_solo_by_others (int32_t);
320 void set_block_size (nframes_t nframes);
321 bool has_external_redirects() const;
322 void curve_reallocate ();
323 void just_meter_input (sframes_t start_frame, sframes_t end_frame, nframes_t nframes);
326 nframes_t check_initial_delay (nframes_t, nframes_t&);
328 void passthru (sframes_t start_frame, sframes_t end_frame,
329 nframes_t nframes, int declick);
331 virtual void write_out_of_band_data (BufferSet& /* bufs */, sframes_t /* start_frame */, sframes_t /* end_frame */,
332 nframes_t /* nframes */) {}
334 virtual void process_output_buffers (BufferSet& bufs,
335 sframes_t start_frame, sframes_t end_frame,
336 nframes_t nframes, bool with_processors, int declick);
338 boost::shared_ptr<IO> _input;
339 boost::shared_ptr<IO> _output;
342 nframes_t _initial_delay;
343 nframes_t _roll_delay;
345 ProcessorList _processors;
346 mutable Glib::RWLock _processor_lock;
347 boost::shared_ptr<Delivery> _main_outs;
348 boost::shared_ptr<Delivery> _control_outs;
349 boost::shared_ptr<InternalReturn> _intreturn;
352 int _pending_declick;
353 MeterPoint _meter_point;
354 uint32_t _phase_invert;
356 uint32_t _soloed_by_others;
359 bool _denormal_protection;
361 bool _recordable : 1;
363 bool _declickable : 1;
365 boost::shared_ptr<SoloControllable> _solo_control;
366 boost::shared_ptr<MuteMaster> _mute_master;
367 MuteMaster::MutePoint _mute_points;
369 RouteGroup* _route_group;
370 std::string _comment;
371 bool _have_internal_generator;
373 DataType _default_type;
377 virtual XMLNode& state(bool);
379 void passthru_silence (sframes_t start_frame, sframes_t end_frame,
380 nframes_t nframes, int declick);
382 void silence (nframes_t nframes);
384 sigc::connection input_signal_connection;
386 ChanCount processor_max_streams;
387 uint32_t _remote_control_id;
389 uint32_t pans_required() const;
390 ChanCount n_process_buffers ();
392 virtual int _set_state (const XMLNode&, int, bool call_base);
394 boost::shared_ptr<Amp> _amp;
395 boost::shared_ptr<PeakMeter> _meter;
396 sigc::connection _meter_connection;
400 int _set_state_2X (const XMLNode&, int);
401 void set_processor_state_2X (XMLNodeList const &, int);
403 static uint32_t order_key_cnt;
405 typedef std::map<std::string, long> OrderKeys;
406 OrderKeys order_keys;
408 void input_change_handler (IOChange, void *src);
409 void output_change_handler (IOChange, void *src);
411 bool _in_configure_processors;
413 int configure_processors (ProcessorStreams*);
414 int configure_processors_unlocked (ProcessorStreams*);
416 bool add_processor_from_xml (const XMLNode&, ProcessorList::iterator iter);
417 bool add_processor_from_xml_2X (const XMLNode&, int, ProcessorList::iterator iter);
419 void placement_range (Placement p, ProcessorList::iterator& start, ProcessorList::iterator& end);
421 void set_self_solo (bool yn);
422 void set_delivery_solo ();
425 } // namespace ARDOUR
427 #endif /* __ardour_route_h__ */