2 Copyright (C) 2009 Paul Davis
4 This program is free software; you can redistribute it and/or modify it
5 under the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2 of the License, or (at your option)
9 This program is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 You should have received a copy of the GNU General Public License along
15 with this program; if not, write to the Free Software Foundation, Inc.,
16 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include "pbd/enumwriter.h"
23 #include "pbd/convert.h"
25 #include "ardour/amp.h"
26 #include "ardour/audioengine.h"
27 #include "ardour/buffer_set.h"
28 #include "ardour/debug.h"
29 #include "ardour/delivery.h"
30 #include "ardour/io.h"
31 #include "ardour/mute_master.h"
32 #include "ardour/pannable.h"
33 #include "ardour/panner_shell.h"
34 #include "ardour/port.h"
35 #include "ardour/session.h"
39 namespace ARDOUR { class Panner; }
43 using namespace ARDOUR;
45 PBD::Signal0<void> Delivery::PannersLegal;
46 bool Delivery::panners_legal = false;
48 /* deliver to an existing IO object */
50 Delivery::Delivery (Session& s, boost::shared_ptr<IO> io, boost::shared_ptr<Pannable> pannable,
51 boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
52 : IOProcessor(s, boost::shared_ptr<IO>(), (role_requires_output_ports (r) ? io : boost::shared_ptr<IO>()), name)
54 , _output_buffers (new BufferSet())
56 , _no_outs_cuz_we_no_monitor (false)
58 , _no_panner_reset (false)
61 _panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable));
64 _display_to_user = false;
67 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
71 /* deliver to a new IO object */
73 Delivery::Delivery (Session& s, boost::shared_ptr<Pannable> pannable, boost::shared_ptr<MuteMaster> mm, const string& name, Role r)
74 : IOProcessor(s, false, (role_requires_output_ports (r) ? true : false), name)
76 , _output_buffers (new BufferSet())
78 , _no_outs_cuz_we_no_monitor (false)
80 , _no_panner_reset (false)
83 _panshell = boost::shared_ptr<PannerShell>(new PannerShell (_name, _session, pannable));
86 _display_to_user = false;
89 _output->changed.connect_same_thread (*this, boost::bind (&Delivery::output_changed, this, _1, _2));
96 DEBUG_TRACE (DEBUG::Destruction, string_compose ("delivery %1 destructor\n", _name));
98 /* this object should vanish from any signal callback lists
99 that it is on before we get any further. The full qualification
100 of the method name is not necessary, but is here to make it
101 clear that this call is about signals, not data flow connections.
104 ScopedConnectionList::drop_connections ();
106 delete _output_buffers;
110 Delivery::display_name () const
114 return _("main outs");
127 Delivery::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
131 /* the out buffers will be set to point to the port output buffers
132 of our output object.
136 if (_output->n_ports() != ChanCount::ZERO) {
137 /* increase number of output ports if the processor chain requires it */
138 out = ChanCount::max (_output->n_ports(), in);
141 /* not configured yet - we will passthru */
146 fatal << "programming error: this should never be reached" << endmsg;
151 } else if (_role == Insert) {
153 /* the output buffers will be filled with data from the *input* ports
158 if (_input->n_ports() != ChanCount::ZERO) {
159 out = _input->n_ports();
162 /* not configured yet - we will passthru */
167 fatal << "programming error: this should never be reached" << endmsg;
172 fatal << "programming error: this should never be reached" << endmsg;
178 /** Caller must hold process lock */
180 Delivery::configure_io (ChanCount in, ChanCount out)
182 assert (!AudioEngine::instance()->process_lock().trylock());
184 /* check configuration by comparison with our I/O port configuration, if appropriate.
185 see ::can_support_io_configuration() for comments
191 if (_output->n_ports() != out) {
192 if (_output->n_ports() != ChanCount::ZERO) {
193 _output->ensure_io (out, false, this);
195 /* I/O not yet configured */
200 } else if (_role == Insert) {
203 if (_input->n_ports() != in) {
204 if (_input->n_ports() != ChanCount::ZERO) {
205 fatal << _name << " programming error: configure_io called with " << in << " and " << out << " with " << _input->n_ports() << " input ports" << endmsg;
208 /* I/O not yet configured */
215 if (!Processor::configure_io (in, out)) {
225 Delivery::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool result_required)
229 PortSet& ports (_output->ports());
232 if (_output->n_ports ().get (_output->default_type()) == 0) {
236 if (!_active && !_pending_active) {
237 _output->silence (nframes);
241 /* this setup is not just for our purposes, but for anything that comes after us in the
242 processing pathway that wants to use this->output_buffers() for some reason.
245 output_buffers().get_jack_port_addresses (ports, nframes);
247 // this Delivery processor is not a derived type, and thus we assume
248 // we really can modify the buffers passed in (it is almost certainly
249 // the main output stage of a Route). Contrast with Send::run()
250 // which cannot do this.
252 tgain = target_gain ();
254 if (tgain != _current_gain) {
255 /* target gain has changed */
257 Amp::apply_gain (bufs, nframes, _current_gain, tgain);
258 _current_gain = tgain;
260 } else if (tgain == 0.0) {
262 /* we were quiet last time, and we're still supposed to be quiet.
263 Silence the outputs, and make sure the buffers are quiet too,
266 _output->silence (nframes);
267 if (result_required) {
268 bufs.set_count (output_buffers().count ());
269 Amp::apply_simple_gain (bufs, nframes, 0.0);
273 } else if (tgain != 1.0) {
275 /* target gain has not changed, but is not unity */
276 Amp::apply_simple_gain (bufs, nframes, tgain);
279 if (_panshell && !_panshell->bypassed() && _panshell->panner()) {
281 // Use the panner to distribute audio to output port buffers
283 _panshell->run (bufs, output_buffers(), start_frame, end_frame, nframes);
285 // MIDI data will not have been delivered by the panner
287 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
288 _output->copy_to_outputs (bufs, DataType::MIDI, nframes, 0);
293 // Do a 1:1 copy of data to output ports
295 if (bufs.count().n_audio() > 0 && ports.count().n_audio () > 0) {
296 _output->copy_to_outputs (bufs, DataType::AUDIO, nframes, 0);
299 if (bufs.count().n_midi() > 0 && ports.count().n_midi () > 0) {
300 _output->copy_to_outputs (bufs, DataType::MIDI, nframes, 0);
304 if (result_required) {
305 bufs.read_from (output_buffers (), nframes);
309 _active = _pending_active;
313 Delivery::state (bool full_state)
315 XMLNode& node (IOProcessor::state (full_state));
318 node.add_property("type", "main-outs");
319 } else if (_role & Listen) {
320 node.add_property("type", "listen");
322 node.add_property("type", "delivery");
325 node.add_property("role", enum_2_string(_role));
328 node.add_child_nocopy (_panshell->get_state ());
335 Delivery::set_state (const XMLNode& node, int version)
337 const XMLProperty* prop;
339 if (IOProcessor::set_state (node, version)) {
343 if ((prop = node.property ("role")) != 0) {
344 _role = Role (string_2_enum (prop->value(), _role));
345 // std::cerr << this << ' ' << _name << " set role to " << enum_2_string (_role) << std::endl;
347 // std::cerr << this << ' ' << _name << " NO ROLE INFO\n";
350 XMLNode* pan_node = node.child (X_("PannerShell"));
352 if (pan_node && _panshell) {
353 _panshell->set_state (*pan_node, version);
364 /* caller must hold process lock */
370 Delivery::pan_outs () const
373 return _output->n_ports().n_audio();
376 return _configured_output.n_audio();
380 Delivery::reset_panner ()
383 if (!_no_panner_reset) {
386 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
389 _panshell->pannable()->set_panner (_panshell->panner());
395 panner_legal_c.disconnect ();
396 PannersLegal.connect_same_thread (panner_legal_c, boost::bind (&Delivery::panners_became_legal, this));
401 Delivery::panners_became_legal ()
404 _panshell->configure_io (ChanCount (DataType::AUDIO, pans_required()), ChanCount (DataType::AUDIO, pan_outs()));
407 _panshell->pannable()->set_panner (_panshell->panner());
411 panner_legal_c.disconnect ();
415 Delivery::defer_pan_reset ()
417 _no_panner_reset = true;
421 Delivery::allow_pan_reset ()
423 _no_panner_reset = false;
429 Delivery::disable_panners ()
431 panners_legal = false;
436 Delivery::reset_panners ()
438 panners_legal = true;
443 Delivery::flush_buffers (framecnt_t nframes)
445 /* io_lock, not taken: function must be called from Session::process() calltree */
451 PortSet& ports (_output->ports());
453 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
454 i->flush_buffers (nframes);
459 Delivery::transport_stopped (framepos_t now)
461 Processor::transport_stopped (now);
464 _panshell->pannable()->transport_stopped (now);
468 PortSet& ports (_output->ports());
470 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
471 i->transport_stopped ();
477 Delivery::realtime_locate ()
480 PortSet& ports (_output->ports());
482 for (PortSet::iterator i = ports.begin(); i != ports.end(); ++i) {
483 i->realtime_locate ();
489 Delivery::target_gain ()
491 /* if we've been requested to deactivate, our target gain is zero */
493 if (!_pending_active) {
497 /* if we've been told not to output because its a monitoring situation and
498 we're not monitoring, then be quiet.
501 if (_no_outs_cuz_we_no_monitor) {
505 MuteMaster::MutePoint mp = MuteMaster::Main; // stupid gcc uninit warning
509 mp = MuteMaster::Main;
512 mp = MuteMaster::Listen;
518 mp = MuteMaster::PreFader;
520 mp = MuteMaster::PostFader;
525 gain_t desired_gain = _mute_master->mute_gain_at (mp);
527 if (_role == Listen && _session.monitor_out() && !_session.listening()) {
529 /* nobody is soloed, and this delivery is a listen-send to the
530 control/monitor/listen bus, we should be silent since
531 it gets its signal from the master out.
542 Delivery::no_outs_cuz_we_no_monitor (bool yn)
544 _no_outs_cuz_we_no_monitor = yn;
548 Delivery::set_name (const std::string& name)
550 bool ret = IOProcessor::set_name (name);
553 ret = _panshell->set_name (name);
559 bool ignore_output_change = false;
562 Delivery::output_changed (IOChange change, void* /*src*/)
564 if (change.type & IOChange::ConfigurationChanged) {
566 _output_buffers->attach_buffers (_output->ports ());
570 boost::shared_ptr<Panner>
571 Delivery::panner () const
574 return _panshell->panner();
576 return boost::shared_ptr<Panner>();