along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
#include <algorithm>
-#include <pbd/xml++.h>
+#include "pbd/xml++.h"
-#include <ardour/send.h>
-#include <ardour/session.h>
-#include <ardour/port.h>
-#include <ardour/audio_port.h>
+#include "ardour/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 "i18n.h"
using namespace PBD;
Send::Send (Session& s, Placement p)
- : Redirect (s, s.next_send_name(), p)
+ : IOProcessor (s, string_compose (_("send %1"), (bitslot = s.next_send_id()) + 1), p)
{
_metering = false;
- expected_inputs = 0;
- save_state (_("initial state"));
- RedirectCreated (this); /* EMIT SIGNAL */
+ ProcessorCreated (this); /* EMIT SIGNAL */
}
Send::Send (Session& s, const XMLNode& node)
- : Redirect (s, "send", PreFader)
+ : IOProcessor (s, "send", PreFader)
{
_metering = false;
- expected_inputs = 0;
if (set_state (node)) {
throw failed_constructor();
}
- save_state (_("initial state"));
- RedirectCreated (this); /* EMIT SIGNAL */
-}
-
-Send::Send (const Send& other)
- : Redirect (other._session, other._session.next_send_name(), other.placement())
-{
- _metering = false;
- expected_inputs = 0;
- save_state (_("initial state"));
- RedirectCreated (this); /* EMIT SIGNAL */
+ ProcessorCreated (this); /* EMIT SIGNAL */
}
Send::~Send ()
{
- GoingAway (this);
+ GoingAway ();
}
XMLNode&
XMLNode&
Send::state(bool full)
{
- XMLNode *node = new XMLNode("Send");
- node->add_child_nocopy (Redirect::state(full));
- return *node;
+ XMLNode& node = IOProcessor::state(full);
+ char buf[32];
+ node.add_property ("type", "send");
+ snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
+ node.add_property ("bitslot", buf);
+
+ return node;
}
int
{
XMLNodeList nlist = node.children();
XMLNodeIterator niter;
-
- for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
- if ((*niter)->name() == Redirect::state_node_name) {
- Redirect::set_state (**niter);
- break;
- }
+ const XMLProperty* prop;
+
+ if ((prop = node.property ("bitslot")) == 0) {
+ bitslot = _session.next_send_id();
+ } else {
+ sscanf (prop->value().c_str(), "%" PRIu32, &bitslot);
+ _session.mark_send_id (bitslot);
}
- if (niter == nlist.end()) {
- error << _("XML node describing a send is missing a Redirect node") << endmsg;
- return -1;
+ const XMLNode* insert_node = &node;
+
+ /* Send has regular IO automation (gain, pan) */
+
+ for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
+ if ((*niter)->name() == "IOProcessor") {
+ insert_node = *niter;
+ } else if ((*niter)->name() == X_("Automation")) {
+ // _io->set_automation_state (*(*niter), Evoral::Parameter(GainAutomation));
+ }
}
+
+ IOProcessor::set_state (*insert_node);
return 0;
}
void
-Send::run (vector<Sample *>& bufs, uint32_t nbufs, jack_nframes_t nframes, jack_nframes_t offset)
+Send::run_in_place (BufferSet& bufs, nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset)
{
if (active()) {
// we have to copy the input, because IO::deliver_output may alter the buffers
// in-place, which a send must never do.
- vector<Sample*>& sendbufs = _session.get_send_buffers();
+ BufferSet& sendbufs = _session.get_mix_buffers(bufs.count());
- for (size_t i=0; i < nbufs; ++i) {
- memcpy (sendbufs[i], bufs[i], sizeof (Sample) * nframes);
- }
-
-
- IO::deliver_output (sendbufs, nbufs, nframes, offset);
-
- if (_metering) {
- uint32_t n;
- uint32_t no = n_outputs().get(DataType::AUDIO);
+ sendbufs.read_from(bufs, nframes);
+ assert(sendbufs.count() == bufs.count());
- if (_gain == 0) {
-
- for (n = 0; n < no; ++n) {
- _peak_power[n] = 0;
- }
+ _io->deliver_output (sendbufs, start_frame, end_frame, nframes, offset);
+ if (_metering) {
+ if (_io->effective_gain() == 0) {
+ _io->peak_meter().reset();
} else {
-
- for (n = 0; n < no; ++n) {
- _peak_power[n] = Session::compute_peak (audio_output(n)->get_audio_buffer().data(nframes, offset), nframes, _peak_power[n]);
- }
+ _io->peak_meter().run_in_place(_io->output_buffers(), start_frame, end_frame, nframes, offset);
}
}
} else {
- silence (nframes, offset);
+ _io->silence (nframes, offset);
if (_metering) {
- uint32_t n;
- uint32_t no = n_outputs().get(DataType::AUDIO);
-
- for (n = 0; n < no; ++n) {
- _peak_power[n] = 0;
- }
+ _io->peak_meter().reset();
}
}
}
if (!_metering) {
/* XXX possible thread hazard here */
- reset_peak_meters ();
+ _io->peak_meter().reset();
+ }
+}
+
+bool
+Send::can_support_io_configuration (const ChanCount& in, ChanCount& out_is_ignored) const
+{
+ if (_io->input_maximum() == ChanCount::INFINITE && _io->output_maximum() == ChanCount::INFINITE) {
+
+ /* not configured yet */
+
+ return 1; /* we can support anything the first time we're asked */
+
+ } else {
+
+ /* the "input" config for a port insert corresponds to how
+ many output ports it will have.
+ */
+
+ if (_io->output_maximum() == in) {
+ return 1;
+ }
+ }
+
+ return -1;
+}
+
+bool
+Send::configure_io (ChanCount in, ChanCount out)
+{
+ /* we're transparent no matter what. fight the power. */
+
+ if (out != in) {
+ return false;
+ }
+
+ _io->set_output_maximum (in);
+ _io->set_output_minimum (in);
+ _io->set_input_maximum (ChanCount::ZERO);
+ _io->set_input_minimum (ChanCount::ZERO);
+
+ if (_io->ensure_io (ChanCount::ZERO, in, false, this) != 0) {
+ return false;
}
+
+ Processor::configure_io(in, out);
+ _io->reset_panner();
+
+ return true;
}
+ChanCount
+Send::output_streams() 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 _configured_input;
+}
+
+ChanCount
+Send::input_streams() const
+{
+ return _configured_input;
+}
+
+
void
-Send::expect_inputs (uint32_t expected)
+Send::expect_inputs (const ChanCount& expected)
{
if (expected != expected_inputs) {
expected_inputs = expected;
- reset_panner ();
+ _io->reset_panner ();
+ }
+}
+
+/** Set up the XML description of a send so that its name is unique.
+ * @param state XML send state.
+ * @param session Session.
+ */
+void
+Send::make_unique (XMLNode &state, Session &session)
+{
+ uint32_t const bitslot = session.next_send_id() + 1;
+
+ char buf[32];
+ snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
+ state.property("bitslot")->set_value (buf);
+
+ std::string const name = string_compose (_("send %1"), bitslot);
+
+ state.property("name")->set_value (name);
+
+ XMLNode* io = state.child ("IO");
+ if (io) {
+ io->property("name")->set_value (name);
}
}
projects / ardour.git / blobdiff