summaryrefslogtreecommitdiffstats
path: root/src/server/EdgeImpl.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/server/EdgeImpl.cpp')
-rw-r--r--src/server/EdgeImpl.cpp192
1 files changed, 192 insertions, 0 deletions
diff --git a/src/server/EdgeImpl.cpp b/src/server/EdgeImpl.cpp
new file mode 100644
index 00000000..a5c63d4a
--- /dev/null
+++ b/src/server/EdgeImpl.cpp
@@ -0,0 +1,192 @@
+/*
+ This file is part of Ingen.
+ Copyright 2007-2012 David Robillard <http://drobilla.net/>
+
+ Ingen is free software: you can redistribute it and/or modify it under the
+ terms of the GNU Affero General Public License as published by the Free
+ Software Foundation, either version 3 of the License, or any later version.
+
+ Ingen is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE. See the GNU Affero General Public License for details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with Ingen. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <algorithm>
+#include <boost/intrusive_ptr.hpp>
+
+#include "ingen/shared/URIs.hpp"
+#include "lv2/lv2plug.in/ns/ext/atom/util.h"
+#include "raul/Maid.hpp"
+#include "raul/log.hpp"
+
+#include "AudioBuffer.hpp"
+#include "BufferFactory.hpp"
+#include "EdgeImpl.hpp"
+#include "Engine.hpp"
+#include "InputPort.hpp"
+#include "MessageContext.hpp"
+#include "NodeImpl.hpp"
+#include "OutputPort.hpp"
+#include "PortImpl.hpp"
+#include "ProcessContext.hpp"
+#include "mix.hpp"
+#include "util.hpp"
+
+namespace Ingen {
+namespace Server {
+
+/** Constructor for a edge from a node's output port.
+ *
+ * This handles both polyphonic and monophonic nodes, transparently to the
+ * user (InputPort).
+ */
+EdgeImpl::EdgeImpl(PortImpl* tail, PortImpl* head)
+ : _tail(tail)
+ , _head(head)
+ , _queue(NULL)
+{
+ assert(tail);
+ assert(head);
+ assert(tail != head);
+ assert(tail->path() != head->path());
+
+ if (must_queue())
+ _queue = new Raul::RingBuffer(tail->buffer_size() * 2);
+}
+
+void
+EdgeImpl::dump() const
+{
+ Raul::debug << _tail->path() << " -> " << _head->path()
+ << (must_mix() ? " (MIX) " : " (DIRECT) ")
+ << (must_queue() ? " (QUEUE)" : " (NOQUEUE) ")
+ << "POLY: " << _tail->poly() << " => " << _head->poly()
+ << std::endl;
+}
+
+const Raul::Path&
+EdgeImpl::tail_path() const
+{
+ return _tail->path();
+}
+
+const Raul::Path&
+EdgeImpl::head_path() const
+{
+ return _head->path();
+}
+
+void
+EdgeImpl::get_sources(Context& context,
+ uint32_t voice,
+ boost::intrusive_ptr<Buffer>* srcs,
+ uint32_t max_num_srcs,
+ uint32_t& num_srcs)
+{
+ if (must_queue() && _queue->read_space() > 0) {
+ LV2_Atom obj;
+ _queue->peek(sizeof(LV2_Atom), &obj);
+ BufferRef buf = context.engine().buffer_factory()->get(
+ head()->buffer_type(), sizeof(LV2_Atom) + obj.size);
+ void* data = buf->port_data(PortType::ATOM, context.offset());
+ _queue->read(sizeof(LV2_Atom) + obj.size, (LV2_Atom*)data);
+ srcs[num_srcs++] = buf;
+ } else if (must_mix()) {
+ // Mixing down voices: every src voice mixed into every dst voice
+ for (uint32_t v = 0; v < _tail->poly(); ++v) {
+ assert(num_srcs < max_num_srcs);
+ srcs[num_srcs++] = _tail->buffer(v).get();
+ }
+ } else {
+ // Matching polyphony: each src voice mixed into corresponding dst voice
+ assert(_tail->poly() == _head->poly());
+ assert(num_srcs < max_num_srcs);
+ srcs[num_srcs++] = _tail->buffer(voice).get();
+ }
+}
+
+void
+EdgeImpl::queue(Context& context)
+{
+ if (!must_queue())
+ return;
+
+ const Ingen::Shared::URIs& uris = _tail->bufs().uris();
+
+ boost::intrusive_ptr<Buffer> src_buf = _tail->buffer(0);
+ if (src_buf->atom()->type != uris.atom_Sequence) {
+ Raul::error << "Queued edge source is not a Sequence" << std::endl;
+ return;
+ }
+
+ LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)src_buf->atom();
+ LV2_ATOM_SEQUENCE_FOREACH(seq, ev) {
+ _queue->write(sizeof(LV2_Atom) + ev->body.size, &ev->body);
+ context.engine().message_context()->run(
+ _head->parent_node(), context.start() + ev->time.frames);
+
+ }
+}
+
+BufferRef
+EdgeImpl::buffer(uint32_t voice) const
+{
+ assert(!must_mix());
+ assert(!must_queue());
+ assert(_tail->poly() == 1 || _tail->poly() > voice);
+ if (_tail->poly() == 1) {
+ return _tail->buffer(0);
+ } else {
+ return _tail->buffer(voice);
+ }
+}
+
+bool
+EdgeImpl::must_mix() const
+{
+ return _tail->poly() > _head->poly();
+}
+
+bool
+EdgeImpl::must_queue() const
+{
+ return _tail->parent_node()->context()
+ != _head->parent_node()->context();
+}
+
+bool
+EdgeImpl::can_connect(const OutputPort* src, const InputPort* dst)
+{
+ const Ingen::Shared::URIs& uris = src->bufs().uris();
+ return (
+ // (Audio | Control | CV) => (Audio | Control | CV)
+ ( (src->is_a(PortType::CONTROL) ||
+ src->is_a(PortType::AUDIO) ||
+ src->is_a(PortType::CV))
+ && (dst->is_a(PortType::CONTROL)
+ || dst->is_a(PortType::AUDIO)
+ || dst->is_a(PortType::CV)))
+
+ // Equal types
+ || (src->type() == dst->type() &&
+ src->buffer_type() == dst->buffer_type())
+
+ // Control => atom:Float Value
+ || (src->is_a(PortType::CONTROL) && dst->supports(uris.atom_Float))
+
+ // Audio => atom:Sound Value
+ || (src->is_a(PortType::AUDIO) && dst->supports(uris.atom_Sound))
+
+ // atom:Float Value => Control
+ || (src->supports(uris.atom_Float) && dst->is_a(PortType::CONTROL))
+
+ // atom:Sound Value => Audio
+ || (src->supports(uris.atom_Sound) && dst->is_a(PortType::AUDIO)));
+}
+
+} // namespace Server
+} // namespace Ingen
+