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"
45 #include "ardour/route_group_member.h"
57 class MonitorProcessor
;
59 class Route
: public SessionObject
, public AutomatableControls
, public RouteGroupMember
63 typedef std::list
<boost::shared_ptr
<Processor
> > ProcessorList
;
71 Route (Session
&, std::string name
, Flag flags
= Flag(0), DataType default_type
= DataType::AUDIO
);
76 boost::shared_ptr
<IO
> input() const { return _input
; }
77 boost::shared_ptr
<IO
> output() const { return _output
; }
79 ChanCount
n_inputs() const { return _input
->n_ports(); }
80 ChanCount
n_outputs() const { return _output
->n_ports(); }
82 bool active() const { return _active
; }
83 void set_active (bool yn
);
85 static std::string
ensure_track_or_route_name(std::string
, Session
&);
87 std::string
comment() { return _comment
; }
88 void set_comment (std::string str
, void *src
);
90 bool set_name (const std::string
& str
);
92 long order_key (std::string
const &) const;
93 void set_order_key (std::string
const &, long);
95 bool is_hidden() const { return _flags
& Hidden
; }
96 bool is_master() const { return _flags
& MasterOut
; }
97 bool is_monitor() const { return _flags
& MonitorOut
; }
99 /* these are the core of the API of a Route. see the protected sections as well */
101 virtual int roll (nframes_t nframes
, sframes_t start_frame
, sframes_t end_frame
,
102 int declick
, bool can_record
, bool rec_monitors_input
, bool& need_butler
);
104 virtual int no_roll (nframes_t nframes
, sframes_t start_frame
, sframes_t end_frame
,
105 bool state_changing
, bool can_record
, bool rec_monitors_input
);
107 virtual int silent_roll (nframes_t nframes
, sframes_t start_frame
, sframes_t end_frame
,
108 bool can_record
, bool rec_monitors_input
, bool& need_butler
);
110 virtual void toggle_monitor_input ();
111 virtual bool can_record() { return false; }
113 virtual void set_record_enable (bool /*yn*/, void * /*src*/) {}
114 virtual bool record_enabled() const { return false; }
115 virtual void handle_transport_stopped (bool abort
, bool did_locate
, bool flush_processors
);
116 virtual void set_pending_declick (int);
118 /* end of vfunc-based API */
120 void shift (nframes64_t
, nframes64_t
);
122 void set_gain (gain_t val
, void *src
);
123 void inc_gain (gain_t delta
, void *src
);
125 void set_mute_points (MuteMaster::MutePoint
);
126 MuteMaster::MutePoint
mute_points () const;
129 void set_mute (bool yn
, void* src
);
131 /* controls use set_solo() to modify this route's solo state
134 void set_solo (bool yn
, void *src
);
135 bool soloed () const { return self_soloed () || soloed_by_others (); }
137 bool soloed_by_others () const { return _soloed_by_others_upstream
||_soloed_by_others_downstream
; }
138 bool soloed_by_others_upstream () const { return _soloed_by_others_upstream
; }
139 bool soloed_by_others_downstream () const { return _soloed_by_others_downstream
; }
140 bool self_soloed () const { return _self_solo
; }
142 void set_solo_isolated (bool yn
, void *src
);
143 bool solo_isolated() const;
145 void set_solo_safe (bool yn
, void *src
);
146 bool solo_safe() const;
148 void set_listen (bool yn
, void* src
);
149 bool listening () const;
151 void set_phase_invert (bool yn
);
152 bool phase_invert() const;
154 void set_denormal_protection (bool yn
);
155 bool denormal_protection() const;
157 void set_meter_point (MeterPoint
);
158 void infer_meter_point () const;
159 MeterPoint
meter_point() const { return _meter_point
; }
164 boost::shared_ptr
<Amp
> amp() const { return _amp
; }
165 PeakMeter
& peak_meter() { return *_meter
.get(); }
166 const PeakMeter
& peak_meter() const { return *_meter
.get(); }
167 boost::shared_ptr
<PeakMeter
> shared_peak_meter() const { return _meter
; }
169 void flush_processors ();
171 void foreach_processor (boost::function
<void(boost::weak_ptr
<Processor
>)> method
) {
172 Glib::RWLock::ReaderLock
lm (_processor_lock
);
173 for (ProcessorList::iterator i
= _processors
.begin(); i
!= _processors
.end(); ++i
) {
174 method (boost::weak_ptr
<Processor
> (*i
));
178 boost::shared_ptr
<Processor
> nth_processor (uint32_t n
) {
179 Glib::RWLock::ReaderLock
lm (_processor_lock
);
180 ProcessorList::iterator i
;
181 for (i
= _processors
.begin(); i
!= _processors
.end() && n
; ++i
, --n
) {}
182 if (i
== _processors
.end()) {
183 return boost::shared_ptr
<Processor
> ();
189 boost::shared_ptr
<Processor
> nth_plugin (uint32_t n
);
190 boost::shared_ptr
<Processor
> nth_send (uint32_t n
);
192 bool processor_is_prefader (boost::shared_ptr
<Processor
> p
);
194 bool has_io_processor_named (const std::string
&);
195 ChanCount
max_processor_streams () const { return processor_max_streams
; }
197 /* special processors */
199 boost::shared_ptr
<Delivery
> monitor_send() const { return _monitor_send
; }
200 boost::shared_ptr
<Delivery
> main_outs() const { return _main_outs
; }
201 boost::shared_ptr
<InternalReturn
> internal_return() const { return _intreturn
; }
202 boost::shared_ptr
<MonitorProcessor
> monitor_control() const { return _monitor_control
; }
203 boost::shared_ptr
<Send
> internal_send_for (boost::shared_ptr
<const Route
> target
) const;
204 void add_internal_return ();
205 BufferSet
* get_return_buffer () const;
206 void release_return_buffer () const;
207 void put_monitor_send_at (Placement
);
209 /** A record of the stream configuration at some point in the processor list.
210 * Used to return where and why an processor list configuration request failed.
212 struct ProcessorStreams
{
213 ProcessorStreams(size_t i
=0, ChanCount c
=ChanCount()) : index(i
), count(c
) {}
215 uint32_t index
; ///< Index of processor where configuration failed
216 ChanCount count
; ///< Input requested of processor
219 int add_processor (boost::shared_ptr
<Processor
>, Placement placement
, ProcessorStreams
* err
= 0);
220 int add_processor (boost::shared_ptr
<Processor
>, ProcessorList::iterator iter
, ProcessorStreams
* err
= 0, bool activation_allowed
= true);
221 int add_processors (const ProcessorList
&, boost::shared_ptr
<Processor
> before
, ProcessorStreams
* err
= 0);
222 int add_processors (const ProcessorList
&, ProcessorList::iterator iter
, ProcessorStreams
* err
= 0);
223 int remove_processor (boost::shared_ptr
<Processor
>, ProcessorStreams
* err
= 0);
224 int remove_processors (const ProcessorList
&, ProcessorStreams
* err
= 0);
225 int reorder_processors (const ProcessorList
& new_order
, ProcessorStreams
* err
= 0);
226 void disable_processors (Placement
);
227 void disable_processors ();
228 void disable_plugins (Placement
);
229 void disable_plugins ();
230 void ab_plugins (bool forward
);
231 void clear_processors (Placement
);
232 void all_processors_flip();
233 void all_processors_active (Placement
, bool state
);
235 virtual nframes_t
update_total_latency();
236 void set_latency_delay (nframes_t
);
237 void set_user_latency (nframes_t
);
238 nframes_t
initial_delay() const { return _initial_delay
; }
240 PBD::Signal0
<void> active_changed
;
241 PBD::Signal0
<void> phase_invert_changed
;
242 PBD::Signal0
<void> denormal_protection_changed
;
243 PBD::Signal1
<void,void*> listen_changed
;
244 PBD::Signal2
<void,bool,void*> solo_changed
;
245 PBD::Signal1
<void,void*> solo_safe_changed
;
246 PBD::Signal1
<void,void*> solo_isolated_changed
;
247 PBD::Signal1
<void,void*> comment_changed
;
248 PBD::Signal1
<void,void*> mute_changed
;
249 PBD::Signal0
<void> mute_points_changed
;
251 /** the processors have changed; the parameter indicates what changed */
252 PBD::Signal1
<void,RouteProcessorChange
> processors_changed
;
253 PBD::Signal1
<void,void*> record_enable_changed
;
254 /** the metering point has changed */
255 PBD::Signal0
<void> meter_change
;
256 PBD::Signal0
<void> signal_latency_changed
;
257 PBD::Signal0
<void> initial_delay_changed
;
259 /* gui's call this for their own purposes. */
261 PBD::Signal2
<void,std::string
,void*> gui_changed
;
265 XMLNode
& get_state();
266 int set_state (const XMLNode
&, int version
);
267 virtual XMLNode
& get_template();
269 XMLNode
& get_processor_state ();
270 virtual void set_processor_state (const XMLNode
&);
272 int save_as_template (const std::string
& path
, const std::string
& name
);
274 PBD::Signal1
<void,void*> SelectedChanged
;
276 int listen_via (boost::shared_ptr
<Route
>, Placement p
, bool active
, bool aux
);
277 void drop_listen (boost::shared_ptr
<Route
>);
280 * return true if this route feeds the first argument via at least one
281 * (arbitrarily long) signal pathway.
283 bool feeds (boost::shared_ptr
<Route
>, bool* via_send_only
= 0);
286 * return true if this route feeds the first argument directly, via
287 * either its main outs or a send.
289 bool direct_feeds (boost::shared_ptr
<Route
>, bool* via_send_only
= 0);
292 boost::weak_ptr
<Route
> r
;
295 FeedRecord (boost::shared_ptr
<Route
> rp
, bool sendsonly
)
297 , sends_only (sendsonly
) {}
300 struct FeedRecordCompare
{
301 bool operator() (const FeedRecord
& a
, const FeedRecord
& b
) const {
306 typedef std::set
<FeedRecord
,FeedRecordCompare
> FedBy
;
308 const FedBy
& fed_by() const { return _fed_by
; }
309 void clear_fed_by ();
310 bool add_fed_by (boost::shared_ptr
<Route
>, bool sends_only
);
311 bool not_fed() const { return _fed_by
.empty(); }
313 /* Controls (not all directly owned by the Route */
315 boost::shared_ptr
<AutomationControl
> get_control (const Evoral::Parameter
& param
);
317 struct SoloControllable
: public AutomationControl
{
318 SoloControllable (std::string name
, Route
&);
319 void set_value (float);
320 float get_value (void) const;
325 struct MuteControllable
: public AutomationControl
{
326 MuteControllable (std::string name
, Route
&);
327 void set_value (float);
328 float get_value (void) const;
333 boost::shared_ptr
<AutomationControl
> solo_control() const {
334 return _solo_control
;
337 boost::shared_ptr
<AutomationControl
> mute_control() const {
338 return _mute_control
;
341 boost::shared_ptr
<MuteMaster
> mute_master() const {
345 /* Route doesn't own these items, but sub-objects that it does own have them
346 and to make UI code a bit simpler, we provide direct access to them
350 boost::shared_ptr
<Panner
> panner() const;
351 boost::shared_ptr
<AutomationControl
> gain_control() const;
353 void automation_snapshot (nframes_t now
, bool force
=false);
354 void protect_automation ();
356 void set_remote_control_id (uint32_t id
, bool notify_class_listeners
= true);
357 uint32_t remote_control_id () const;
359 /* for things concerned about *this* route's RID */
361 PBD::Signal0
<void> RemoteControlIDChanged
;
363 /* for things concerned about any route's RID changes */
365 static PBD::Signal0
<void> RemoteControlIDChange
;
367 void sync_order_keys (std::string
const &);
368 static PBD::Signal1
<void,std::string
const &> SyncOrderKeys
;
371 friend class Session
;
373 void catch_up_on_solo_mute_override ();
374 void mod_solo_by_others_upstream (int32_t);
375 void mod_solo_by_others_downstream (int32_t);
376 bool has_external_redirects() const;
377 void curve_reallocate ();
378 void just_meter_input (sframes_t start_frame
, sframes_t end_frame
, nframes_t nframes
);
379 virtual void set_block_size (nframes_t nframes
);
382 nframes_t
check_initial_delay (nframes_t
, nframes_t
&);
384 void passthru (sframes_t start_frame
, sframes_t end_frame
,
385 nframes_t nframes
, int declick
);
387 virtual void write_out_of_band_data (BufferSet
& /* bufs */, sframes_t
/* start_frame */, sframes_t
/* end_frame */,
388 nframes_t
/* nframes */) {}
390 virtual void process_output_buffers (BufferSet
& bufs
,
391 sframes_t start_frame
, sframes_t end_frame
,
392 nframes_t nframes
, bool with_processors
, int declick
);
394 boost::shared_ptr
<IO
> _input
;
395 boost::shared_ptr
<IO
> _output
;
398 nframes_t _initial_delay
;
399 nframes_t _roll_delay
;
401 ProcessorList _processors
;
402 mutable Glib::RWLock _processor_lock
;
403 boost::shared_ptr
<Delivery
> _main_outs
;
404 boost::shared_ptr
<Delivery
> _monitor_send
;
405 boost::shared_ptr
<InternalReturn
> _intreturn
;
406 boost::shared_ptr
<MonitorProcessor
> _monitor_control
;
409 int _pending_declick
;
410 MeterPoint _meter_point
;
411 uint32_t _phase_invert
;
413 uint32_t _soloed_by_others_upstream
;
414 uint32_t _soloed_by_others_downstream
;
415 uint32_t _solo_isolated
;
417 bool _denormal_protection
;
419 bool _recordable
: 1;
421 bool _declickable
: 1;
423 boost::shared_ptr
<SoloControllable
> _solo_control
;
424 boost::shared_ptr
<MuteControllable
> _mute_control
;
425 boost::shared_ptr
<MuteMaster
> _mute_master
;
427 std::string _comment
;
428 bool _have_internal_generator
;
430 DataType _default_type
;
433 virtual ChanCount
input_streams () const;
436 virtual XMLNode
& state(bool);
438 int configure_processors (ProcessorStreams
*);
440 void passthru_silence (sframes_t start_frame
, sframes_t end_frame
,
441 nframes_t nframes
, int declick
);
443 void silence (nframes_t nframes
);
445 ChanCount processor_max_streams
;
446 uint32_t _remote_control_id
;
448 uint32_t pans_required() const;
449 ChanCount
n_process_buffers ();
451 virtual int _set_state (const XMLNode
&, int, bool call_base
);
453 boost::shared_ptr
<Amp
> _amp
;
454 boost::shared_ptr
<PeakMeter
> _meter
;
457 int _set_state_2X (const XMLNode
&, int);
458 void set_processor_state_2X (XMLNodeList
const &, int);
460 static uint32_t order_key_cnt
;
462 typedef std::map
<std::string
, long> OrderKeys
;
463 OrderKeys order_keys
;
465 void input_change_handler (IOChange
, void *src
);
466 void output_change_handler (IOChange
, void *src
);
468 bool _in_configure_processors
;
470 int configure_processors_unlocked (ProcessorStreams
*);
472 bool add_processor_from_xml (const XMLNode
&, ProcessorList::iterator iter
);
473 bool add_processor_from_xml_2X (const XMLNode
&, int, ProcessorList::iterator iter
);
475 void placement_range (Placement p
, ProcessorList::iterator
& start
, ProcessorList::iterator
& end
);
477 void set_self_solo (bool yn
);
478 void set_mute_master_solo ();
480 void set_processor_positions ();
483 } // namespace ARDOUR
485 #endif /* __ardour_route_h__ */