/*
- Copyright (C) 2009 Paul Davis
+ Copyright (C) 2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
*/
-#include <algorithm>
+#include "pbd/error.h"
+#include "pbd/failed_constructor.h"
-#include <pbd/xml++.h>
-
-#include <ardour/internal_send.h>
-#include <ardour/session.h>
-#include <ardour/port.h>
-#include <ardour/audio_port.h>
-#include <ardour/buffer_set.h>
-#include <ardour/meter.h>
-#include <ardour/panner.h>
-#include <ardour/io.h>
+#include "ardour/amp.h"
+#include "ardour/audio_buffer.h"
+#include "ardour/internal_return.h"
+#include "ardour/internal_send.h"
+#include "ardour/meter.h"
+#include "ardour/panner_shell.h"
+#include "ardour/route.h"
+#include "ardour/session.h"
+#include "ardour/audioengine.h"
#include "i18n.h"
-using namespace ARDOUR;
+namespace ARDOUR { class MuteMaster; class Pannable; }
+
using namespace PBD;
+using namespace ARDOUR;
+using namespace std;
-InternalSend::InternalSend (Session& s, Placement p, boost::shared_ptr<IO> dst)
- : IOProcessor (s, string_compose (_(">%1"), dst->name()), p,
- -1, -1, -1, -1,
- DataType::AUDIO, false)
- , destination (dst)
-{
- _metering = false;
+PBD::Signal1<void, pframes_t> InternalSend::CycleStart;
- destination->input_changed.connect (mem_fun (*this, &InternalSend::destination_io_config_changed));
+InternalSend::InternalSend (Session& s, boost::shared_ptr<Pannable> p, boost::shared_ptr<MuteMaster> mm, boost::shared_ptr<Route> sendto, Delivery::Role role)
+ : Send (s, p, mm, role)
+{
+ if (sendto) {
+ if (use_target (sendto)) {
+ throw failed_constructor();
+ }
+ }
- destination_io_config_changed (ConfigurationChanged, this);
+ init_gain ();
- ProcessorCreated (this); /* EMIT SIGNAL */
+ CycleStart.connect_same_thread (*this, boost::bind (&InternalSend::cycle_start, this, _1));
}
InternalSend::~InternalSend ()
{
- GoingAway ();
+ if (_send_to) {
+ _send_to->remove_send_from_internal_return (this);
+ }
}
void
-InternalSend::destination_io_config_changed (IOChange c, void* src)
+InternalSend::init_gain ()
{
- if (!(c & ConfigurationChanged)) {
- return;
+ if (_role == Listen) {
+ /* send to monitor bus is always at unity */
+ _amp->set_gain (1.0, this);
+ } else {
+ /* aux sends start at -inf dB */
+ _amp->set_gain (0, this);
+ }
+}
+
+int
+InternalSend::use_target (boost::shared_ptr<Route> sendto)
+{
+ if (_send_to) {
+ _send_to->remove_send_from_internal_return (this);
}
- _io->disconnect_outputs (this);
+ _send_to = sendto;
- _io->ensure_io (ChanCount::ZERO, destination->n_inputs(), false, this);
+ _send_to->add_send_to_internal_return (this);
- PortSet::const_iterator us (_io->outputs().begin());
- PortSet::const_iterator them (destination->inputs().begin ());
+ mixbufs.ensure_buffers (_send_to->internal_return()->input_streams(), _session.get_block_size());
+ mixbufs.set_count (_send_to->internal_return()->input_streams());
- for (; us != _io->outputs().end() && them != destination->inputs().end(); ++us, ++them) {
- (const_cast<Port*>(&(*us)))->connect (const_cast<Port*>(&(*them)));
- }
+ reset_panner ();
+
+ set_name (sendto->name());
+ _send_to_id = _send_to->id();
+
+ target_connections.drop_connections ();
+
+ _send_to->DropReferences.connect_same_thread (target_connections, boost::bind (&InternalSend::send_to_going_away, this));
+ _send_to->PropertyChanged.connect_same_thread (target_connections, boost::bind (&InternalSend::send_to_property_changed, this, _1));
+ _send_to->io_changed.connect_same_thread (target_connections, boost::bind (&InternalSend::target_io_changed, this));
+
+ return 0;
}
-XMLNode&
-InternalSend::get_state(void)
+void
+InternalSend::target_io_changed ()
{
- fatal << X_("InternalSend::get_state() called - should never happen") << endmsg;
- /*NOTREACHED*/
- return *(new XMLNode ("foo"));
+ assert (_send_to);
+ mixbufs.ensure_buffers (_send_to->internal_return()->input_streams(), _session.get_block_size());
+ mixbufs.set_count (_send_to->internal_return()->input_streams());
+ reset_panner();
}
-int
-InternalSend::set_state(const XMLNode& node)
+void
+InternalSend::send_to_going_away ()
{
- fatal << X_("InternalSend::set_state() called - should never happen") << endmsg;
- /*NOTREACHED*/
- return 0;
+ target_connections.drop_connections ();
+ _send_to.reset ();
+ _send_to_id = "0";
}
void
-InternalSend::run_in_place (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
+InternalSend::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
{
- if (active()) {
+ if ((!_active && !_pending_active) || !_send_to) {
+ _meter->reset ();
+ return;
+ }
- // we have to copy the input, because IO::deliver_output may alter the buffers
- // in-place, which a send must never do. otherwise its gain settings will
- // affect the signal seen later in the parent Route.
+ // we have to copy the input, because we may alter the buffers with the amp
+ // in-place, which a send must never do.
- // BufferSet& sendbufs = _session.get_mix_buffers(bufs.count());
+ if (_panshell && !_panshell->bypassed()) {
+ _panshell->run (bufs, mixbufs, start_frame, end_frame, nframes);
+ } else {
+ if (role() == Listen) {
+ /* We're going to the monitor bus, so discard MIDI data */
+
+ uint32_t const bufs_audio = bufs.count().get (DataType::AUDIO);
+ uint32_t const mixbufs_audio = mixbufs.count().get (DataType::AUDIO);
+
+ /* monitor-section has same number of channels as master-bus (on creation).
+ *
+ * There is no clear answer what should happen when trying to PFL or AFL
+ * a track that has more channels (bufs_audio from source-track is
+ * larger than mixbufs).
+ *
+ * There are two options:
+ * 1: discard additional channels (current)
+ * OR
+ * 2: require the monitor-section to have at least as many channels
+ * as the largest count of any route
+ */
+ //assert (mixbufs.available().get (DataType::AUDIO) >= bufs_audio);
+
+ /* Copy bufs into mixbufs, going round bufs more than once if necessary
+ to ensure that every mixbuf gets some data.
+ */
+
+ uint32_t j = 0;
+ for (uint32_t i = 0; i < mixbufs_audio; ++i) {
+ mixbufs.get_audio(i).read_from (bufs.get_audio(j), nframes);
+ ++j;
+
+ if (j == bufs_audio) {
+ j = 0;
+ }
+ }
- // sendbufs.read_from (bufs, nframes);
- // assert(sendbufs.count() == bufs.count());
+ } else {
+ assert (mixbufs.available() >= bufs.count());
+ mixbufs.read_from (bufs, nframes);
+ }
+ }
- _io->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ /* gain control */
- if (_metering) {
- if (_io->effective_gain() == 0) {
- _io->peak_meter().reset();
- } else {
- _io->peak_meter().run_in_place(_io->output_buffers(), start_frame, end_frame, nframes, offset);
- }
- }
+ gain_t tgain = target_gain ();
- } else {
- _io->silence (nframes, offset);
- if (_metering) {
- _io->peak_meter().reset();
+ if (tgain != _current_gain) {
+
+ /* target gain has changed */
+
+ Amp::apply_gain (mixbufs, nframes, _current_gain, tgain);
+ _current_gain = tgain;
+
+ } else if (tgain == 0.0) {
+
+ /* we were quiet last time, and we're still supposed to be quiet.
+ */
+
+ _meter->reset ();
+ Amp::apply_simple_gain (mixbufs, nframes, 0.0);
+ goto out;
+
+ } else if (tgain != 1.0) {
+
+ /* target gain has not changed, but is not zero or unity */
+ Amp::apply_simple_gain (mixbufs, nframes, tgain);
+ }
+
+ _amp->set_gain_automation_buffer (_session.send_gain_automation_buffer ());
+ _amp->setup_gain_automation (start_frame, end_frame, nframes);
+ _amp->run (mixbufs, start_frame, end_frame, nframes, true);
+
+ /* consider metering */
+
+ if (_metering) {
+ if (_amp->gain_control()->get_value() == 0) {
+ _meter->reset();
+ } else {
+ _meter->run (mixbufs, start_frame, end_frame, nframes, true);
}
}
+
+ /* target will pick up our output when it is ready */
+
+ out:
+ _active = _pending_active;
}
-void
-InternalSend::set_metering (bool yn)
+int
+InternalSend::set_block_size (pframes_t nframes)
{
- _metering = yn;
-
- if (!_metering) {
- /* XXX possible thread hazard here */
- _io->peak_meter().reset();
+ if (_send_to) {
+ mixbufs.ensure_buffers (_send_to->internal_return()->input_streams(), nframes);
}
+
+ return 0;
}
bool
-InternalSend::can_support_io_configuration (const ChanCount& in, ChanCount& out_is_ignored) const
+InternalSend::feeds (boost::shared_ptr<Route> other) const
{
- /* number of outputs is fixed (though mutable by changing the I/O configuration
- of the destination)
- */
+ return _send_to == other;
+}
+
+XMLNode&
+InternalSend::state (bool full)
+{
+ XMLNode& node (Send::state (full));
- cerr << "IS: testing I/O config in=" << in.n_audio() << " out=" << out_is_ignored.n_audio() << endl;
+ /* this replaces any existing "type" property */
- if (in == _io->n_outputs()) {
- return 1;
+ node.add_property ("type", "intsend");
+
+ if (_send_to) {
+ node.add_property ("target", _send_to->id().to_s());
}
- return -1;
+ return node;
}
-bool
-InternalSend::configure_io (ChanCount in, ChanCount out)
+XMLNode&
+InternalSend::get_state()
+{
+ return state (true);
+}
+
+int
+InternalSend::set_state (const XMLNode& node, int version)
{
- cerr << "Configure IS for in " << in.n_audio() << " out = " << out.n_audio() << endl;
+ const XMLProperty* prop;
+
+ init_gain ();
- /* we're transparent no matter what. fight the power. */
+ Send::set_state (node, version);
- if (out != in) {
- return false;
+ if ((prop = node.property ("target")) != 0) {
+
+ _send_to_id = prop->value();
+
+ /* if we're loading a session, the target route may not have been
+ create yet. make sure we defer till we are sure that it should
+ exist.
+ */
+
+ if (!IO::connecting_legal) {
+ IO::ConnectingLegal.connect_same_thread (connect_c, boost::bind (&InternalSend::connect_when_legal, this));
+ } else {
+ connect_when_legal ();
+ }
}
- _io->set_output_maximum (in);
- _io->set_output_minimum (in);
- _io->set_input_maximum (ChanCount::ZERO);
- _io->set_input_minimum (ChanCount::ZERO);
+ return 0;
+}
- out = _io->n_outputs();
+int
+InternalSend::connect_when_legal ()
+{
+ connect_c.disconnect ();
+
+ if (_send_to_id == "0") {
+ /* it vanished before we could connect */
+ return 0;
+ }
- Processor::configure_io(in, out);
+ boost::shared_ptr<Route> sendto;
- _io->reset_panner();
+ if ((sendto = _session.route_by_id (_send_to_id)) == 0) {
+ error << string_compose (_("%1 - cannot find any track/bus with the ID %2 to connect to"), display_name(), _send_to_id) << endmsg;
+ cerr << string_compose (_("%1 - cannot find any track/bus with the ID %2 to connect to"), display_name(), _send_to_id) << endl;
+ return -1;
+ }
+
+ return use_target (sendto);
+}
+bool
+InternalSend::can_support_io_configuration (const ChanCount& in, ChanCount& out)
+{
+ out = in;
return true;
}
-ChanCount
-InternalSend::output_streams() const
+uint32_t
+InternalSend::pan_outs () const
{
- // this method reflects the idea that from the perspective of the Route's ProcessorList,
- // a send is just a passthrough. that doesn't match what the Send actually does with its
- // data, but since what it does is invisible to the Route, it appears to be a passthrough.
-
- return _io->n_outputs ();
+ /* the number of targets for our panner is determined by what we are
+ sending to, if anything.
+ */
+
+ if (_send_to) {
+ return _send_to->internal_return()->input_streams().n_audio();
+ }
+
+ return 1; /* zero is more accurate, but 1 is probably safer as a way to
+ * say "don't pan"
+ */
}
-ChanCount
-InternalSend::input_streams() const
+bool
+InternalSend::configure_io (ChanCount in, ChanCount out)
{
- return _configured_input;
+ bool ret = Send::configure_io (in, out);
+ set_block_size (_session.engine().samples_per_cycle());
+ return ret;
}
+bool
+InternalSend::set_name (const string& str)
+{
+ /* rules for external sends don't apply to us */
+ return IOProcessor::set_name (str);
+}
-void
-InternalSend::expect_inputs (const ChanCount& expected)
+string
+InternalSend::display_name () const
{
- if (expected != expected_inputs) {
- expected_inputs = expected;
- _io->reset_panner ();
+ if (_role == Aux) {
+ return string_compose (X_("%1"), _name);
+ } else {
+ return _name;
}
}
+bool
+InternalSend::visible () const
+{
+ if (_role == Aux) {
+ return true;
+ }
+
+ return false;
+}
+
void
-InternalSend::activate ()
+InternalSend::send_to_property_changed (const PropertyChange& what_changed)
{
- Processor::activate ();
+ if (what_changed.contains (Properties::name)) {
+ set_name (_send_to->name ());
+ }
}
void
-InternalSend::deactivate ()
+InternalSend::set_can_pan (bool yn)
{
- Processor::deactivate ();
+ if (_panshell) {
+ _panshell->set_bypassed (!yn);
+ }
}
+
+void
+InternalSend::cycle_start (pframes_t /*nframes*/)
+{
+ for (BufferSet::audio_iterator b = mixbufs.audio_begin(); b != mixbufs.audio_end(); ++b) {
+ b->prepare ();
+ }
+}
projects / ardour.git / blobdiff