From a2792bd09212eed55bba1aa30dc09043a6955486 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Sun, 31 Aug 2014 01:24:57 +0000 Subject: Use float sequences for sample-accurate control ports. git-svn-id: http://svn.drobilla.net/lad/trunk/ingen@5462 a436a847-0d15-0410-975c-d299462d15a1 --- src/gui/NodeModule.cpp | 3 +- src/gui/Port.cpp | 3 + src/gui/Style.cpp | 11 +++- src/gui/Style.hpp | 1 + src/server/ArcImpl.cpp | 25 ++++++-- src/server/ArcImpl.hpp | 2 +- src/server/BlockImpl.cpp | 46 ++++++++++++++- src/server/BlockImpl.hpp | 14 +++-- src/server/Buffer.cpp | 114 +++++++++++++++++++++++++++++++++--- src/server/Buffer.hpp | 73 ++++++++++++++++++++--- src/server/BufferFactory.cpp | 9 +-- src/server/BufferFactory.hpp | 3 +- src/server/Context.cpp | 38 +++++++++--- src/server/Context.hpp | 20 +++++-- src/server/ControlBindings.cpp | 1 + src/server/DuplexPort.cpp | 16 ++++- src/server/DuplexPort.hpp | 3 + src/server/Event.hpp | 3 +- src/server/GraphImpl.cpp | 22 ++++++- src/server/GraphImpl.hpp | 2 + src/server/InputPort.cpp | 103 ++++++++++++++++++++------------ src/server/InputPort.hpp | 8 ++- src/server/LV2Block.cpp | 28 +++++---- src/server/LV2Block.hpp | 10 ++-- src/server/OutputPort.cpp | 24 +++++++- src/server/OutputPort.hpp | 7 +-- src/server/PortImpl.cpp | 101 +++++++++++++++++++++++--------- src/server/PortImpl.hpp | 25 +++++++- src/server/ProcessContext.hpp | 2 + src/server/internals/Controller.cpp | 31 +++++----- src/server/internals/Controller.hpp | 2 +- src/server/internals/Delay.cpp | 6 +- src/server/internals/Delay.hpp | 2 +- src/server/internals/Note.cpp | 28 +++++---- src/server/internals/Note.hpp | 2 +- src/server/internals/Time.cpp | 6 +- src/server/internals/Time.hpp | 2 +- src/server/internals/Trigger.cpp | 30 +++++----- src/server/internals/Trigger.hpp | 2 +- src/server/mix.cpp | 2 + 40 files changed, 630 insertions(+), 200 deletions(-) (limited to 'src') diff --git a/src/gui/NodeModule.cpp b/src/gui/NodeModule.cpp index b9798339..0bacb70b 100644 --- a/src/gui/NodeModule.cpp +++ b/src/gui/NodeModule.cpp @@ -186,7 +186,8 @@ NodeModule::port_value_changed(uint32_t index, const Atom& value) return; } - if (value.type() == uris.atom_Float) { + if (value.type() == uris.atom_Float && + _block->get_port(index)->is_numeric()) { _plugin_ui->port_event(index, sizeof(float), 0, value.ptr()); } else { _plugin_ui->port_event(index, diff --git a/src/gui/Port.cpp b/src/gui/Port.cpp index b04e93b5..e123a571 100644 --- a/src/gui/Port.cpp +++ b/src/gui/Port.cpp @@ -83,6 +83,7 @@ Port::Port(App& app, assert(pm); set_border_width(1.0); + set_dash_length(app.style()->get_port_dash_length(pm.get())); if (app.can_control(pm.get())) { show_control(); @@ -367,6 +368,8 @@ Port::activity(const Atom& value) { if (model()->is_a(_app.uris().lv2_AudioPort)) { set_fill_color(peak_color(value.get())); + } else if (_app.can_control(model().get()) && value.type() == _app.uris().atom_Float) { + Ganv::Port::set_control_value(value.get()); } else { _app.port_activity(this); } diff --git a/src/gui/Style.cpp b/src/gui/Style.cpp index 1c61d995..287a1496 100644 --- a/src/gui/Style.cpp +++ b/src/gui/Style.cpp @@ -82,7 +82,6 @@ Style::apply_settings() uint32_t Style::get_port_color(const Client::PortModel* p) { - assert(p != NULL); const URIs& uris = _app.uris(); if (p->is_a(uris.lv2_AudioPort)) { return _audio_port_color; @@ -102,5 +101,15 @@ Style::get_port_color(const Client::PortModel* p) return 0x666666FF; } +uint32_t +Style::get_port_dash_length(const Client::PortModel* p) +{ + const URIs& uris = _app.uris(); + if (p->is_a(uris.atom_AtomPort)) { + return 4.0; + } + return 0.0; +} + } // namespace GUI } // namespace Ingen diff --git a/src/gui/Style.hpp b/src/gui/Style.hpp index 13fa0546..a52a3d01 100644 --- a/src/gui/Style.hpp +++ b/src/gui/Style.hpp @@ -41,6 +41,7 @@ public: void apply_settings(); uint32_t get_port_color(const Client::PortModel* p); + uint32_t get_port_dash_length(const Client::PortModel* p); private: App& _app; diff --git a/src/server/ArcImpl.cpp b/src/server/ArcImpl.cpp index 8b8a23b4..e53f1880 100644 --- a/src/server/ArcImpl.cpp +++ b/src/server/ArcImpl.cpp @@ -55,21 +55,31 @@ ArcImpl::head_path() const } BufferRef -ArcImpl::buffer(uint32_t voice) const +ArcImpl::buffer(uint32_t voice, SampleCount offset) const { - assert(!must_mix()); assert(_tail->poly() == 1 || _tail->poly() > voice); if (_tail->poly() == 1) { - return _tail->buffer(0); - } else { - return _tail->buffer(voice); + voice = 0; } + + if (_tail->buffer(0)->is_sequence()) { + if (_head->type() == PortType::CONTROL) { + _tail->update_values(offset); // Update value buffer + return _tail->value_buffer(voice); // Return value buffer + } else if (_head->type() == PortType::CV) { + _tail->update_values(offset); // Update initial value + // Return full tail buffer below + } + } + + return _tail->buffer(voice); } bool ArcImpl::must_mix() const { - return _tail->poly() > _head->poly(); + return (_tail->poly() > _head->poly() || + (_tail->buffer(0)->is_sequence() != _head->buffer(0)->is_sequence())); } bool @@ -98,6 +108,9 @@ ArcImpl::can_connect(const OutputPort* src, const InputPort* dst) // atom:Float Value => Control || (src->supports(uris.atom_Float) && dst->is_a(PortType::ID::CONTROL)) + // atom:Float Value => CV + || (src->supports(uris.atom_Float) && dst->is_a(PortType::ID::CV)) + // atom:Sound Value => Audio || (src->supports(uris.atom_Sound) && dst->is_a(PortType::ID::AUDIO))); } diff --git a/src/server/ArcImpl.hpp b/src/server/ArcImpl.hpp index 9ea103a5..63ed8430 100644 --- a/src/server/ArcImpl.hpp +++ b/src/server/ArcImpl.hpp @@ -67,7 +67,7 @@ public: * buffer, and will return accordingly (e.g. the same buffer for every * voice in a mono->poly arc). */ - BufferRef buffer(uint32_t voice) const; + BufferRef buffer(uint32_t voice, SampleCount offset=0) const; /** Whether this arc must mix down voices into a local buffer */ bool must_mix() const; diff --git a/src/server/BlockImpl.cpp b/src/server/BlockImpl.cpp index 0cae55a2..069ecdfa 100644 --- a/src/server/BlockImpl.cpp +++ b/src/server/BlockImpl.cpp @@ -155,6 +155,45 @@ BlockImpl::pre_process(ProcessContext& context) } } +void +BlockImpl::process(ProcessContext& context) +{ + pre_process(context); + + ProcessContext subcontext(context); + for (SampleCount offset = 0; offset < context.nframes();) { + // Find earliest offset of a value change + SampleCount chunk_end = context.nframes(); + for (uint32_t i = 0; _ports && i < _ports->size(); ++i) { + PortImpl* const port = _ports->at(i); + if (port->type() == PortType::CONTROL && port->is_input()) { + const SampleCount o = port->next_value_offset( + offset, context.nframes()); + if (o < chunk_end) { + chunk_end = o; + } + } + } + + // Slice context into a chunk from now until the next change + subcontext.slice(offset, chunk_end - offset); + + // Prepare port buffers for reading, converting/mixing if necessary + for (uint32_t i = 0; _ports && i < _ports->size(); ++i) { + _ports->at(i)->connect_buffers(offset); + _ports->at(i)->pre_run(subcontext); + } + + // Run the chunk + run(subcontext); + + offset = chunk_end; + subcontext.slice(offset, chunk_end - offset); + } + + post_process(context); +} + void BlockImpl::post_process(ProcessContext& context) { @@ -165,9 +204,10 @@ BlockImpl::post_process(ProcessContext& context) } void -BlockImpl::set_port_buffer(uint32_t voice, - uint32_t port_num, - BufferRef buf) +BlockImpl::set_port_buffer(uint32_t voice, + uint32_t port_num, + BufferRef buf, + SampleCount offset) { /*std::cout << path() << " set port " << port_num << " voice " << voice << " buffer " << buf << " offset " << offset << std::endl;*/ diff --git a/src/server/BlockImpl.hpp b/src/server/BlockImpl.hpp index cfffcb96..58ced1fe 100644 --- a/src/server/BlockImpl.hpp +++ b/src/server/BlockImpl.hpp @@ -92,16 +92,20 @@ public: /** Do whatever needs doing in the process thread before process() is called */ virtual void pre_process(ProcessContext& context); - /** Run for the block of time specified by `context`. */ - virtual void process(ProcessContext& context) = 0; + /** Run block for an entire process cycle (calls run()). */ + virtual void process(ProcessContext& context); + + /** Run block for a portion of process cycle (called from process()). */ + virtual void run(ProcessContext& context) = 0; /** Do whatever needs doing in the process thread after process() is called */ virtual void post_process(ProcessContext& context); /** Set the buffer of a port to a given buffer (e.g. connect plugin to buffer) */ - virtual void set_port_buffer(uint32_t voice, - uint32_t port_num, - BufferRef buf); + virtual void set_port_buffer(uint32_t voice, + uint32_t port_num, + BufferRef buf, + SampleCount offset); virtual Node* port(uint32_t index) const; virtual PortImpl* port_impl(uint32_t index) const { return (*_ports)[index]; } diff --git a/src/server/Buffer.cpp b/src/server/Buffer.cpp index ebab53fd..ac77be63 100644 --- a/src/server/Buffer.cpp +++ b/src/server/Buffer.cpp @@ -39,10 +39,15 @@ namespace Ingen { namespace Server { -Buffer::Buffer(BufferFactory& bufs, LV2_URID type, uint32_t capacity) +Buffer::Buffer(BufferFactory& bufs, + LV2_URID type, + LV2_URID value_type, + uint32_t capacity) : _factory(bufs) , _type(type) + , _value_type(value_type) , _capacity(capacity) + , _latest_event(0) , _next(NULL) , _refs(0) { @@ -69,6 +74,10 @@ Buffer::Buffer(BufferFactory& bufs, LV2_URID type, uint32_t capacity) vec->body.child_type = bufs.uris().atom_Float; } + if (type == bufs.uris().atom_Sequence && value_type) { + _value_buffer = bufs.get_buffer(value_type, 0, 0, false); + } + clear(); } @@ -83,6 +92,15 @@ Buffer::recycle() _factory.recycle(this); } +void +Buffer::set_type(LV2_URID type, LV2_URID value_type) +{ + _type = type; + if (type == _factory.uris().atom_Sequence && value_type) { + _value_buffer = _factory.get_buffer(value_type, 0, 0, false); + } +} + void Buffer::clear() { @@ -95,18 +113,43 @@ Buffer::clear() _atom->size = sizeof(LV2_Atom_Sequence_Body); seq->body.unit = 0; seq->body.pad = 0; + _latest_event = 0; } } +void +Buffer::render_sequence(const Context& context, const Buffer* src, bool add) +{ + const LV2_URID atom_Float = _factory.uris().atom_Float; + const LV2_Atom_Sequence* seq = (const LV2_Atom_Sequence*)src->atom(); + const LV2_Atom_Float* init = (const LV2_Atom_Float*)src->value(); + float value = init ? init->body : 0.0f; + SampleCount offset = context.offset(); + LV2_ATOM_SEQUENCE_FOREACH(seq, ev) { + if (ev->time.frames >= offset && ev->body.type == atom_Float) { + write_block(value, offset, ev->time.frames, add); + value = ((const LV2_Atom_Float*)&ev->body)->body; + offset = ev->time.frames; + } + } + write_block(value, offset, context.offset() + context.nframes(), add); +} + void Buffer::copy(const Context& context, const Buffer* src) { if (_type == src->type() && src->_atom->size + sizeof(LV2_Atom) <= _capacity) { memcpy(_atom, src->_atom, sizeof(LV2_Atom) + src->_atom->size); + if (value() && src->value()) { + memcpy(value(), src->value(), lv2_atom_total_size(src->value())); + } } else if (src->is_audio() && is_control()) { samples()[0] = src->samples()[0]; } else if (src->is_control() && is_audio()) { set_block(src->samples()[0], 0, context.nframes()); + } else if (src->is_sequence() && is_audio() && + src->value_type() == _factory.uris().atom_Float) { + render_sequence(context, src, false); } else { clear(); } @@ -121,7 +164,7 @@ Buffer::resize(uint32_t capacity) } void* -Buffer::port_data(PortType port_type) +Buffer::port_data(PortType port_type, SampleCount offset) { switch (port_type.id()) { case PortType::ID::CONTROL: @@ -130,7 +173,7 @@ Buffer::port_data(PortType port_type) if (_atom->type == _factory.uris().atom_Float) { return (float*)LV2_ATOM_BODY(_atom); } else if (_atom->type == _factory.uris().atom_Sound) { - return (float*)LV2_ATOM_CONTENTS(LV2_Atom_Vector, _atom); + return (float*)LV2_ATOM_CONTENTS(LV2_Atom_Vector, _atom) + offset; } break; default: @@ -140,10 +183,10 @@ Buffer::port_data(PortType port_type) } const void* -Buffer::port_data(PortType port_type) const +Buffer::port_data(PortType port_type, SampleCount offset) const { return const_cast( - const_cast(this)->port_data(port_type)); + const_cast(this)->port_data(port_type, offset)); } #ifdef __SSE__ @@ -203,7 +246,9 @@ void Buffer::prepare_write(Context& context) { if (_type == _factory.uris().atom_Sequence) { - _atom->size = sizeof(LV2_Atom_Sequence_Body); + _atom->type = (LV2_URID)_factory.uris().atom_Sequence; + _atom->size = sizeof(LV2_Atom_Sequence_Body); + _latest_event = 0; } } @@ -211,8 +256,9 @@ void Buffer::prepare_output_write(Context& context) { if (_type == _factory.uris().atom_Sequence) { - _atom->type = (LV2_URID)_factory.uris().atom_Chunk; - _atom->size = _capacity - sizeof(LV2_Atom); + _atom->type = (LV2_URID)_factory.uris().atom_Chunk; + _atom->size = _capacity - sizeof(LV2_Atom); + _latest_event = 0; } } @@ -222,6 +268,12 @@ Buffer::append_event(int64_t frames, uint32_t type, const uint8_t* data) { + assert(frames >= _latest_event); + if (_atom->type == _factory.uris().atom_Chunk) { + // Chunk initialized with prepare_output_write(), clear + clear(); + } + if (sizeof(LV2_Atom) + _atom->size + lv2_atom_pad_size(size) > _capacity) { return false; } @@ -237,9 +289,55 @@ Buffer::append_event(int64_t frames, _atom->size += sizeof(LV2_Atom_Event) + lv2_atom_pad_size(size); + _latest_event = frames; + return true; } +SampleCount +Buffer::next_value_offset(SampleCount offset, SampleCount end) const +{ + SampleCount earliest = end; + LV2_ATOM_SEQUENCE_FOREACH((LV2_Atom_Sequence*)_atom, ev) { + if (ev->time.frames > offset && + ev->time.frames < earliest && + ev->body.type == _value_type) { + earliest = ev->time.frames; + break; + } + } + return earliest; +} + +const LV2_Atom* +Buffer::value() const +{ + return _value_buffer ? _value_buffer->atom() : NULL; +} + +LV2_Atom* +Buffer::value() +{ + return _value_buffer ? _value_buffer->atom() : NULL; +} + +void +Buffer::update_value_buffer(SampleCount offset) +{ + if (!_value_buffer) { + return; + } + + LV2_ATOM_SEQUENCE_FOREACH((LV2_Atom_Sequence*)_atom, ev) { + if (ev->time.frames <= offset && ev->body.type == _value_type) { + memcpy(_value_buffer->atom(), + &ev->body, + lv2_atom_total_size(&ev->body)); + break; + } + } +} + void intrusive_ptr_add_ref(Buffer* b) { diff --git a/src/server/Buffer.hpp b/src/server/Buffer.hpp index 14984de4..cf36bc21 100644 --- a/src/server/Buffer.hpp +++ b/src/server/Buffer.hpp @@ -41,20 +41,24 @@ class BufferFactory; class Buffer : public boost::noncopyable { public: - Buffer(BufferFactory& bufs, LV2_URID type, uint32_t capacity); + Buffer(BufferFactory& bufs, + LV2_URID type, + LV2_URID value_type, + uint32_t capacity); void clear(); void resize(uint32_t size); void copy(const Context& context, const Buffer* src); void prepare_write(Context& context); - void* port_data(PortType port_type); - const void* port_data(PortType port_type) const; + void* port_data(PortType port_type, SampleCount offset); + const void* port_data(PortType port_type, SampleCount offset) const; - inline LV2_URID type() const { return _type; } - inline uint32_t capacity() const { return _capacity; } + inline LV2_URID type() const { return _type; } + inline LV2_URID value_type() const { return _value_type; } + inline uint32_t capacity() const { return _capacity; } - inline void set_type(LV2_URID t) { _type = t; } + void set_type(LV2_URID type, LV2_URID value_type); inline bool is_audio() const { return _type == _factory.uris().atom_Sound; @@ -68,6 +72,12 @@ public: return _type == _factory.uris().atom_Sequence; } + inline bool empty() const { + return (_atom->type != _type || + (_type == _factory.uris().atom_Sequence && + _atom->size <= sizeof(LV2_Atom_Sequence_Body))); + } + /// Audio buffers only inline const Sample* samples() const { if (is_control()) { @@ -98,18 +108,21 @@ public: return 0; } - /// Audio buffers only + /// Numeric buffers only inline Sample value_at(SampleCount offset) const { if (is_audio() || is_control()) { return samples()[offset]; + } else if (_value_buffer) { + return ((LV2_Atom_Float*)value())->body; } return 0.0f; } - inline void set_block(Sample val, + inline void set_block(const Sample val, const SampleCount start, const SampleCount end) { + assert(is_audio() || is_control()); assert(end <= nframes()); // Note: Do not change this without ensuring GCC can still vectorize it Sample* const buf = samples() + start; @@ -118,6 +131,30 @@ public: } } + inline void add_block(const Sample val, + const SampleCount start, + const SampleCount end) + { + assert(is_audio() || is_control()); + assert(end <= nframes()); + // Note: Do not change this without ensuring GCC can still vectorize it + Sample* const buf = samples() + start; + for (SampleCount i = 0; i < (end - start); ++i) { + buf[i] += val; + } + } + + inline void write_block(const Sample val, + const SampleCount start, + const SampleCount end, + const bool add) + { + if (add) { + add_block(val, start, end); + } + set_block(val, start, end); + } + /// Audio buffers only float peak(const Context& context) const; @@ -130,6 +167,22 @@ public: uint32_t type, const uint8_t* data); + /// Value buffer for numeric sequences + BufferRef value_buffer() { return _value_buffer; } + const BufferRef value_buffer() const { return _value_buffer; } + + const LV2_Atom* value() const; + LV2_Atom* value(); + + /// Return offset of the first value change after `offset`. + SampleCount next_value_offset(SampleCount offset, SampleCount end) const; + + /// Update value buffer to value as of offset + void update_value_buffer(SampleCount offset); + + /// Set/add to audio buffer from the Sequence of Float in `src` + void render_sequence(const Context& context, const Buffer* src, bool add); + LV2_Atom* atom() { return _atom; } const LV2_Atom* atom() const { return _atom; } @@ -147,7 +200,11 @@ protected: BufferFactory& _factory; LV2_Atom* _atom; LV2_URID _type; + LV2_URID _value_type; uint32_t _capacity; + int64_t _latest_event; + + BufferRef _value_buffer; ///< Value buffer for numeric sequences friend class BufferFactory; ~Buffer(); diff --git a/src/server/BufferFactory.cpp b/src/server/BufferFactory.cpp index 6390a36b..88ec195b 100644 --- a/src/server/BufferFactory.cpp +++ b/src/server/BufferFactory.cpp @@ -97,6 +97,7 @@ BufferFactory::default_size(LV2_URID type) const BufferRef BufferFactory::get_buffer(LV2_URID type, + LV2_URID value_type, uint32_t capacity, bool real_time, bool force_create) @@ -116,7 +117,7 @@ BufferFactory::get_buffer(LV2_URID type, if (!try_head) { if (!real_time) { - return create(type, capacity); + return create(type, value_type, capacity); } else { _engine.world()->log().error("Failed to obtain buffer"); return BufferRef(); @@ -124,7 +125,7 @@ BufferFactory::get_buffer(LV2_URID type, } try_head->_next = NULL; - try_head->set_type(type); + try_head->set_type(type, value_type); return BufferRef(try_head); } @@ -135,7 +136,7 @@ BufferFactory::silent_buffer() } BufferRef -BufferFactory::create(LV2_URID type, uint32_t capacity) +BufferFactory::create(LV2_URID type, LV2_URID value_type, uint32_t capacity) { if (capacity == 0) { capacity = default_size(type); @@ -145,7 +146,7 @@ BufferFactory::create(LV2_URID type, uint32_t capacity) capacity = std::max(capacity, default_size(_uris.atom_Sound)); } - return BufferRef(new Buffer(*this, type, capacity)); + return BufferRef(new Buffer(*this, type, value_type, capacity)); } void diff --git a/src/server/BufferFactory.hpp b/src/server/BufferFactory.hpp index 54c02c77..662c8149 100644 --- a/src/server/BufferFactory.hpp +++ b/src/server/BufferFactory.hpp @@ -48,6 +48,7 @@ public: uint32_t default_size(LV2_URID type) const; BufferRef get_buffer(LV2_URID type, + LV2_URID value_type, uint32_t capacity, bool real_time, bool force_create = false); @@ -65,7 +66,7 @@ private: friend class Buffer; void recycle(Buffer* buf); - BufferRef create(LV2_URID type, uint32_t capacity=0); + BufferRef create(LV2_URID type, LV2_URID value_type, uint32_t capacity=0); inline std::atomic& free_list(LV2_URID type) { if (type == _uris.atom_Float) { diff --git a/src/server/Context.cpp b/src/server/Context.cpp index 67a247e1..ecf078e1 100644 --- a/src/server/Context.cpp +++ b/src/server/Context.cpp @@ -47,13 +47,35 @@ struct Notification Context::Context(Engine& engine, ID id) : _engine(engine) , _id(id) - , _event_sink(engine.event_queue_size() * sizeof(Notification)) + , _event_sink( + new Raul::RingBuffer(engine.event_queue_size() * sizeof(Notification))) , _start(0) , _end(0) + , _offset(0) , _nframes(0) , _realtime(true) + , _copy(false) {} +Context::Context(const Context& copy) + : _engine(copy._engine) + , _id(copy._id) + , _event_sink(copy._event_sink) + , _start(copy._start) + , _end(copy._end) + , _offset(copy._offset) + , _nframes(copy._nframes) + , _realtime(copy._realtime) + , _copy(true) +{} + +Context::~Context() +{ + if (!_copy) { + delete _event_sink; + } +} + bool Context::must_notify(const PortImpl* port) const { @@ -69,12 +91,12 @@ Context::notify(LV2_URID key, const void* body) { const Notification n(port, time, key, size, type); - if (_event_sink.write_space() < sizeof(n) + size) { + if (_event_sink->write_space() < sizeof(n) + size) { return false; } - if (_event_sink.write(sizeof(n), &n) != sizeof(n)) { + if (_event_sink->write(sizeof(n), &n) != sizeof(n)) { _engine.log().error("Error writing header to notification ring\n"); - } else if (_event_sink.write(size, body) != size) { + } else if (_event_sink->write(size, body) != size) { _engine.log().error("Error writing body to notification ring\n"); } else { return true; @@ -86,17 +108,17 @@ void Context::emit_notifications(FrameTime end) { const URIs& uris = _engine.buffer_factory()->uris(); - const uint32_t read_space = _event_sink.read_space(); + const uint32_t read_space = _event_sink->read_space(); Notification note; for (uint32_t i = 0; i < read_space; i += sizeof(note)) { - if (_event_sink.peek(sizeof(note), ¬e) != sizeof(note) || + if (_event_sink->peek(sizeof(note), ¬e) != sizeof(note) || note.time >= end) { return; } - if (_event_sink.read(sizeof(note), ¬e) == sizeof(note)) { + if (_event_sink->read(sizeof(note), ¬e) == sizeof(note)) { Atom value = _engine.world()->forge().alloc( note.size, note.type, NULL); - if (_event_sink.read(note.size, value.get_body()) == note.size) { + if (_event_sink->read(note.size, value.get_body()) == note.size) { i += note.size; const char* key = _engine.world()->uri_map().unmap_uri(note.key); if (key) { diff --git a/src/server/Context.hpp b/src/server/Context.hpp index bea43943..a11a5e8c 100644 --- a/src/server/Context.hpp +++ b/src/server/Context.hpp @@ -50,8 +50,9 @@ public: }; Context(Engine& engine, ID id); + Context(const Context& copy); - virtual ~Context() {} + virtual ~Context(); /** Return true iff the given port should broadcast its value. * @@ -75,7 +76,7 @@ public: void emit_notifications(FrameTime end); /** Return true iff any notifications are pending. */ - bool pending_notifications() const { return _event_sink.read_space(); } + bool pending_notifications() const { return _event_sink->read_space(); } inline ID id() const { return _id; } @@ -91,22 +92,33 @@ public: _nframes = other._nframes; } + inline void slice(SampleCount offset, SampleCount nframes) { + _offset = offset; + _nframes = nframes; + } + inline Engine& engine() const { return _engine; } inline FrameTime start() const { return _start; } + inline FrameTime time() const { return _start + _offset; } inline FrameTime end() const { return _end; } + inline SampleCount offset() const { return _offset; } inline SampleCount nframes() const { return _nframes; } inline bool realtime() const { return _realtime; } protected: + const Context& operator=(const Context& copy) = delete; + Engine& _engine; ///< Engine we're running in ID _id; ///< Fast ID for this context - Raul::RingBuffer _event_sink; ///< Port updates from process context + Raul::RingBuffer* _event_sink; ///< Port updates from process context FrameTime _start; ///< Start frame of this cycle, timeline relative FrameTime _end; ///< End frame of this cycle, timeline relative - SampleCount _nframes; ///< Length of this cycle in frames + SampleCount _offset; ///< Offset into data buffers + SampleCount _nframes; ///< Number of frames past offset to process bool _realtime; ///< True iff context is hard realtime + bool _copy; ///< True iff this is a copy (shared event_sink) }; } // namespace Server diff --git a/src/server/ControlBindings.cpp b/src/server/ControlBindings.cpp index 3c6d26df..6ffb5c7d 100644 --- a/src/server/ControlBindings.cpp +++ b/src/server/ControlBindings.cpp @@ -42,6 +42,7 @@ ControlBindings::ControlBindings(Engine& engine) , _bindings(new Bindings()) , _feedback(new Buffer(*_engine.buffer_factory(), engine.world()->uris().atom_Sequence, + 0, 4096)) // FIXME: capacity? { lv2_atom_forge_init( diff --git a/src/server/DuplexPort.cpp b/src/server/DuplexPort.cpp index 20f8f1b7..0713c35a 100644 --- a/src/server/DuplexPort.cpp +++ b/src/server/DuplexPort.cpp @@ -49,11 +49,10 @@ DuplexPort::DuplexPort(BufferFactory& bufs, } // Set default control range - if (!is_output && (type == PortType::CONTROL || type == PortType::CV)) { + if (!is_output && value.type() == bufs.uris().atom_Float) { set_property(bufs.uris().lv2_minimum, bufs.forge().make(0.0f)); set_property(bufs.uris().lv2_maximum, bufs.forge().make(1.0f)); } - } DuplexPort::~DuplexPort() @@ -148,10 +147,23 @@ DuplexPort::post_process(Context& context) perspective. Mix down input delivered by plugins so output (external perspective) is ready. */ InputPort::pre_process(context); + InputPort::pre_run(context); } else { monitor(context); } } +SampleCount +DuplexPort::next_value_offset(SampleCount offset, SampleCount end) const +{ + return OutputPort::next_value_offset(offset, end); +} + +void +DuplexPort::update_values(SampleCount offset) +{ + return OutputPort::update_values(offset); +} + } // namespace Server } // namespace Ingen diff --git a/src/server/DuplexPort.hpp b/src/server/DuplexPort.hpp index ba9658fb..d231cebd 100644 --- a/src/server/DuplexPort.hpp +++ b/src/server/DuplexPort.hpp @@ -72,6 +72,9 @@ public: void pre_process(Context& context); void post_process(Context& context); + SampleCount next_value_offset(SampleCount offset, SampleCount end) const; + void update_values(SampleCount offset); + bool is_input() const { return !_is_output; } bool is_output() const { return _is_output; } diff --git a/src/server/Event.hpp b/src/server/Event.hpp index 29a20c18..8ffbbe0a 100644 --- a/src/server/Event.hpp +++ b/src/server/Event.hpp @@ -105,9 +105,8 @@ protected: } inline bool pre_process_done(Status st, const Raul::URI& subject) { - _status = st; _err_subject = subject; - return st == Status::SUCCESS; + return pre_process_done(st); } inline bool pre_process_done(Status st, const Raul::Path& subject) { diff --git a/src/server/GraphImpl.cpp b/src/server/GraphImpl.cpp index 2bb99dc8..a8a44cf1 100644 --- a/src/server/GraphImpl.cpp +++ b/src/server/GraphImpl.cpp @@ -142,22 +142,38 @@ GraphImpl::apply_internal_poly(ProcessContext& context, return true; } +void +GraphImpl::pre_process(ProcessContext& context) +{ + // Mix down input ports and connect buffers + for (uint32_t i = 0; i < num_ports(); ++i) { + PortImpl* const port = _ports->at(i); + port->pre_process(context); + port->pre_run(context); + port->connect_buffers(); + } +} + void GraphImpl::process(ProcessContext& context) { if (!_process) return; - BlockImpl::pre_process(context); + pre_process(context); + run(context); + post_process(context); +} +void +GraphImpl::run(ProcessContext& context) +{ if (_compiled_graph && _compiled_graph->size() > 0) { // Run all blocks for (size_t i = 0; i < _compiled_graph->size(); ++i) { (*_compiled_graph)[i].block()->process(context); } } - - BlockImpl::post_process(context); } void diff --git a/src/server/GraphImpl.hpp b/src/server/GraphImpl.hpp index 0aba78bd..61bbdba4 100644 --- a/src/server/GraphImpl.hpp +++ b/src/server/GraphImpl.hpp @@ -63,7 +63,9 @@ public: void activate(BufferFactory& bufs); void deactivate(); + void pre_process(ProcessContext& context); void process(ProcessContext& context); + void run(ProcessContext& context); void set_buffer_size(Context& context, BufferFactory& bufs, diff --git a/src/server/InputPort.cpp b/src/server/InputPort.cpp index e0406f05..3e345f8d 100644 --- a/src/server/InputPort.cpp +++ b/src/server/InputPort.cpp @@ -75,6 +75,10 @@ InputPort::get_buffers(BufferFactory& bufs, { const size_t num_arcs = real_time ? _arcs.size() : _num_arcs; + if (is_a(PortType::ATOM) && !_value.is_valid()) { + poly = 1; + } + if (is_a(PortType::AUDIO) && num_arcs == 0) { // Audio input with no arcs, use shared zero buffer for (uint32_t v = 0; v < poly; ++v) { @@ -97,7 +101,8 @@ InputPort::get_buffers(BufferFactory& bufs, // Otherwise, allocate local buffers for (uint32_t v = 0; v < poly; ++v) { voices->at(v).buffer.reset(); - voices->at(v).buffer = bufs.get_buffer(buffer_type(), _buffer_size, real_time); + voices->at(v).buffer = bufs.get_buffer( + buffer_type(), _value.type(), _buffer_size, real_time); voices->at(v).buffer->clear(); } return true; @@ -135,34 +140,16 @@ InputPort::max_tail_poly(Context& context) const return parent_block()->parent_graph()->internal_poly_process(); } -static void -get_sources(const Context& context, - const ArcImpl& arc, - uint32_t voice, - const Buffer** srcs, - uint32_t max_num_srcs, - uint32_t& num_srcs) -{ - if (arc.must_mix()) { - // Mixing down voices: all tail voices => one head voice - for (uint32_t v = 0; v < arc.tail()->poly(); ++v) { - assert(num_srcs < max_num_srcs); - srcs[num_srcs++] = arc.tail()->buffer(v).get(); - } - } else { - // Matching polyphony: each tail voice => corresponding head voice - assert(arc.tail()->poly() == arc.head()->poly()); - assert(num_srcs < max_num_srcs); - srcs[num_srcs++] = arc.tail()->buffer(voice).get(); - } -} - void InputPort::pre_process(Context& context) { - // If value has been set (e.g. events pushed) by the user, don't smash it - if (_set_by_user) + if (_set_by_user) { + // Value has been set (e.g. events pushed) by the user, don't smash it + for (uint32_t v = 0; v < _poly; ++v) { + buffer(v)->update_value_buffer(context.offset()); + } return; + } if (_arcs.empty()) { for (uint32_t v = 0; v < _poly; ++v) { @@ -173,30 +160,74 @@ InputPort::pre_process(Context& context) _voices->at(v).buffer = _arcs.front().buffer(v); } } else { - const uint32_t src_poly = max_tail_poly(context); - const uint32_t max_num_srcs = _arcs.size() * src_poly; + // Mix down to local buffers in pre_run() + for (uint32_t v = 0; v < _poly; ++v) { + buffer(v)->prepare_write(context); + } + } +} + +void +InputPort::pre_run(Context& context) +{ + if (!_set_by_user && !_arcs.empty() && !direct_connect()) { + const uint32_t src_poly = max_tail_poly(context); + const uint32_t max_n_srcs = _arcs.size() * src_poly; - const Buffer* srcs[max_num_srcs]; for (uint32_t v = 0; v < _poly; ++v) { - // Get all the sources for this voice - uint32_t num_srcs = 0; - for (const auto& a : _arcs) { - get_sources(context, a, v, srcs, max_num_srcs, num_srcs); + // Get all sources for this voice + const Buffer* srcs[max_n_srcs]; + uint32_t n_srcs = 0; + for (const auto& arc : _arcs) { + if (_poly == 1) { + // P -> 1 or 1 -> 1: all tail voices => each head voice + for (uint32_t w = 0; w < arc.tail()->poly(); ++w) { + assert(n_srcs < max_n_srcs); + srcs[n_srcs++] = arc.buffer(w, context.offset()).get(); + assert(srcs[n_srcs - 1]); + } + } else { + // P -> P or 1 -> P: tail voice => corresponding head voice + assert(n_srcs < max_n_srcs); + srcs[n_srcs++] = arc.buffer(v, context.offset()).get(); + assert(srcs[n_srcs - 1]); + } } - // Then mix them into out buffer for this voice - mix(context, buffer(v).get(), srcs, num_srcs); + // Then mix them into our buffer for this voice + mix(context, buffer(v).get(), srcs, n_srcs); } } +} - if (!_arcs.empty()) { - monitor(context); +SampleCount +InputPort::next_value_offset(SampleCount offset, SampleCount end) const +{ + SampleCount earliest = end; + for (const auto& arc : _arcs) { + if (arc.tail()->type() != this->type()) { + const SampleCount o = arc.tail()->next_value_offset(offset, end); + if (o < earliest) { + earliest = o; + } + } } + return earliest; +} + +void +InputPort::update_values(SampleCount offset) +{ } void InputPort::post_process(Context& context) { + if (!_arcs.empty() || _force_monitor_update) { + monitor(context, _force_monitor_update); + _force_monitor_update = false; + } + if (_set_by_user) { if (_buffer_type == _bufs.uris().atom_Sequence) { // Clear events received via a SetPortValue diff --git a/src/server/InputPort.hpp b/src/server/InputPort.hpp index 12d28b04..d3bcd0be 100644 --- a/src/server/InputPort.hpp +++ b/src/server/InputPort.hpp @@ -96,12 +96,18 @@ public: uint32_t poly, bool real_time) const; - /** Prepare buffer for access, mixing if necessary. */ + /** Set up buffer pointers. */ void pre_process(Context& context); + /** Prepare buffer for access, mixing if necessary. */ + void pre_run(Context& context); + /** Prepare buffer for next process cycle. */ void post_process(Context& context); + SampleCount next_value_offset(SampleCount offset, SampleCount end) const; + void update_values(SampleCount offset); + size_t num_arcs() const { return _num_arcs; } ///< Pre-process thread void increment_num_arcs() { ++_num_arcs; } void decrement_num_arcs() { --_num_arcs; } diff --git a/src/server/LV2Block.cpp b/src/server/LV2Block.cpp index 952b1d7e..deafdcfe 100644 --- a/src/server/LV2Block.cpp +++ b/src/server/LV2Block.cpp @@ -351,7 +351,7 @@ LV2Block::instantiate(BufferFactory& bufs) break; } - if (!val.type() && port_type != PortType::ATOM) { + if (!val.type()) { val = forge.make(isnan(def_values[j]) ? 0.0f : def_values[j]); } @@ -473,12 +473,16 @@ LV2Block::work(uint32_t size, const void* data) } void -LV2Block::process(ProcessContext& context) +LV2Block::run(ProcessContext& context) { - BlockImpl::pre_process(context); - for (uint32_t i = 0; i < _polyphony; ++i) lilv_instance_run(instance(i), context.nframes()); +} + +void +LV2Block::post_process(ProcessContext& context) +{ + BlockImpl::post_process(context); if (_worker_iface) { LV2_Handle inst = lilv_instance_get_handle(instance(0)); @@ -493,19 +497,19 @@ LV2Block::process(ProcessContext& context) _worker_iface->end_run(inst); } } - - BlockImpl::post_process(context); } void -LV2Block::set_port_buffer(uint32_t voice, - uint32_t port_num, - BufferRef buf) +LV2Block::set_port_buffer(uint32_t voice, + uint32_t port_num, + BufferRef buf, + SampleCount offset) { - BlockImpl::set_port_buffer(voice, port_num, buf); + BlockImpl::set_port_buffer(voice, port_num, buf, offset); lilv_instance_connect_port( - instance(voice), port_num, - buf ? buf->port_data(_ports->at(port_num)->type()) : NULL); + instance(voice), + port_num, + buf ? buf->port_data(_ports->at(port_num)->type(), offset) : NULL); } } // namespace Server diff --git a/src/server/LV2Block.hpp b/src/server/LV2Block.hpp index 321fcd9c..35a2d5c3 100644 --- a/src/server/LV2Block.hpp +++ b/src/server/LV2Block.hpp @@ -56,11 +56,13 @@ public: void work(uint32_t size, const void* data); - void process(ProcessContext& context); + void run(ProcessContext& context); + void post_process(ProcessContext& context); - void set_port_buffer(uint32_t voice, - uint32_t port_num, - BufferRef buf); + void set_port_buffer(uint32_t voice, + uint32_t port_num, + BufferRef buf, + SampleCount offset); protected: SPtr make_instance(URIs& uris, diff --git a/src/server/OutputPort.cpp b/src/server/OutputPort.cpp index 9f97930e..395885ee 100644 --- a/src/server/OutputPort.cpp +++ b/src/server/OutputPort.cpp @@ -52,7 +52,8 @@ OutputPort::get_buffers(BufferFactory& bufs, bool real_time) const { for (uint32_t v = 0; v < poly; ++v) - voices->at(v).buffer = bufs.get_buffer(buffer_type(), _buffer_size, real_time); + voices->at(v).buffer = bufs.get_buffer( + buffer_type(), _value.type(), _buffer_size, real_time); return true; } @@ -64,6 +65,26 @@ OutputPort::pre_process(Context& context) _voices->at(v).buffer->prepare_output_write(context); } +SampleCount +OutputPort::next_value_offset(SampleCount offset, SampleCount end) const +{ + SampleCount earliest = end; + for (uint32_t v = 0; v < _poly; ++v) { + const SampleCount o = _voices->at(v).buffer->next_value_offset(offset, end); + if (o < earliest) { + earliest = o; + } + } + return earliest; +} + +void +OutputPort::update_values(SampleCount offset) +{ + for (uint32_t v = 0; v < _poly; ++v) + _voices->at(v).buffer->update_value_buffer(offset); +} + void OutputPort::post_process(Context& context) { @@ -71,6 +92,7 @@ OutputPort::post_process(Context& context) update_set_state(context, v); } + update_values(0); monitor(context); } diff --git a/src/server/OutputPort.hpp b/src/server/OutputPort.hpp index 92ed8428..24017059 100644 --- a/src/server/OutputPort.hpp +++ b/src/server/OutputPort.hpp @@ -29,10 +29,6 @@ namespace Server { * Output ports always have a locally allocated buffer, and buffer() will * always return that buffer. (This is very different from InputPort) * - * This class actually adds no functionality to Port whatsoever right now, - * it will in the future when more advanced port types exist, and it makes - * things clearer throughout the engine. - * * \ingroup engine */ class OutputPort : virtual public PortImpl @@ -58,6 +54,9 @@ public: void pre_process(Context& context); void post_process(Context& context); + SampleCount next_value_offset(SampleCount offset, SampleCount end) const; + void update_values(SampleCount offset); + bool is_input() const { return false; } bool is_output() const { return true; } }; diff --git a/src/server/PortImpl.cpp b/src/server/PortImpl.cpp index c9afd307..ade8c74a 100644 --- a/src/server/PortImpl.cpp +++ b/src/server/PortImpl.cpp @@ -68,6 +68,7 @@ PortImpl::PortImpl(BufferFactory& bufs, , _voices(new Raul::Array(static_cast(poly))) , _prepared_voices(NULL) , _monitored(false) + , _force_monitor_update(false) , _set_by_user(false) , _is_morph(false) , _is_auto_morph(false) @@ -83,13 +84,13 @@ PortImpl::PortImpl(BufferFactory& bufs, set_type(type, buffer_type); set_property(uris.lv2_index, bufs.forge().make((int32_t)index)); - if ((type == PortType::CONTROL || type == PortType::CV) && value.is_valid()) { + if (has_value()) { set_property(uris.ingen_value, value); } - // if (type == PortType::ATOM) { - // set_property(uris.atom_bufferType, - // bufs.forge().make_urid(buffer_type)); - // } + if (type == PortType::ATOM) { + set_property(uris.atom_bufferType, + bufs.forge().make_urid(buffer_type)); + } } PortImpl::~PortImpl() @@ -130,6 +131,15 @@ PortImpl::set_type(PortType port_type, LV2_URID buffer_type) _buffer_size = std::max(_buffer_size, _bufs.default_size(_buffer_type)); } +bool +PortImpl::has_value() const +{ + return (_type == PortType::CONTROL || + _type == PortType::CV || + (_type == PortType::ATOM && + _value.type() == _bufs.uris().atom_Float)); +} + bool PortImpl::supports(const Raul::URI& value_type) const { @@ -213,7 +223,7 @@ PortImpl::set_voice_value(const Context& context, switch (_type.id()) { case PortType::CONTROL: buffer(voice)->samples()[0] = value; - _voices->at(voice).set_state.state = SetState::State::SET; + _voices->at(voice).set_state.set(context, context.start(), value); break; case PortType::AUDIO: case PortType::CV: { @@ -229,13 +239,20 @@ PortImpl::set_voice_value(const Context& context, value for the next block, particularly for triggers on the last frame of a block (set nframes-1 to 1, then nframes to 0). */ - SetState& state = _voices->at(voice).set_state; - state.state = (offset == 0) - ? SetState::State::SET - : SetState::State::HALF_SET_CYCLE_1; - state.time = time; - state.value = value; - } + _voices->at(voice).set_state.set(context, time, value); + } break; + case PortType::ATOM: + if (buffer(voice)->is_sequence()) { + buffer(voice)->append_event(time - context.start(), + sizeof(value), + _bufs.uris().atom_Float, + (const uint8_t*)&value); + _voices->at(voice).set_state.set(context, time, value); + } else { + fprintf(stderr, + "error: %s set non-sequence atom port value (buffer type %u)\n", + path().c_str(), buffer(voice)->type()); + } default: break; } @@ -247,12 +264,25 @@ PortImpl::update_set_state(Context& context, uint32_t voice) SetState& state = _voices->at(voice).set_state; switch (state.state) { case SetState::State::SET: + if (state.time < context.start() && + buffer(voice)->is_sequence() && + !_parent->path().is_root()) { + buffer(voice)->clear(); + state.time = context.start(); + } break; case SetState::State::HALF_SET_CYCLE_1: state.state = SetState::State::HALF_SET_CYCLE_2; break; case SetState::State::HALF_SET_CYCLE_2: - buffer(voice)->set_block(state.value, 0, context.nframes()); + if (buffer(voice)->is_sequence()) { + buffer(voice)->clear(); + buffer(voice)->append_event( + 0, sizeof(float), _bufs.uris().atom_Float, + (const uint8_t*)&state.value); + } else { + buffer(voice)->set_block(state.value, 0, context.nframes()); + } state.state = SetState::State::SET; break; } @@ -262,9 +292,8 @@ bool PortImpl::prepare_poly(BufferFactory& bufs, uint32_t poly) { ThreadManager::assert_thread(THREAD_PRE_PROCESS); - if (_type != PortType::CONTROL && - _type != PortType::CV && - _type != PortType::AUDIO) { + if (_parent->path().is_root() || + (_type == PortType::ATOM && !_value.is_valid())) { return false; } @@ -291,9 +320,8 @@ PortImpl::prepare_poly(BufferFactory& bufs, uint32_t poly) bool PortImpl::apply_poly(ProcessContext& context, Raul::Maid& maid, uint32_t poly) { - if (_type != PortType::CONTROL && - _type != PortType::CV && - _type != PortType::AUDIO) { + if (_parent->path().is_root() || + (_type == PortType::ATOM && !_value.is_valid())) { return false; } @@ -333,10 +361,10 @@ PortImpl::set_buffer_size(Context& context, BufferFactory& bufs, size_t size) } void -PortImpl::connect_buffers() +PortImpl::connect_buffers(SampleCount offset) { for (uint32_t v = 0; v < _poly; ++v) - PortImpl::parent_block()->set_port_buffer(v, _index, buffer(v)); + PortImpl::parent_block()->set_port_buffer(v, _index, buffer(v), offset); } void @@ -382,7 +410,7 @@ PortImpl::monitor(Context& context, bool send_now) const bool time_to_send = send_now || _frames_since_monitor >= period; const bool is_sequence = (_type.id() == PortType::ATOM && _buffer_type == _bufs.uris().atom_Sequence); - if (!time_to_send && !(is_sequence && _monitored)) { + if (!time_to_send && (!is_sequence || _monitored || buffer(0)->value())) { return; } @@ -404,9 +432,14 @@ PortImpl::monitor(Context& context, bool send_now) break; case PortType::ATOM: if (_buffer_type == _bufs.uris().atom_Sequence) { - LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)buffer(0)->atom(); - if (_monitored) { + const LV2_Atom* atom = buffer(0)->atom(); + if (buffer(0)->value() && !_monitored) { + // Value sequence not fully monitored, monitor as control + key = uris.ingen_value; + val = ((LV2_Atom_Float*)buffer(0)->value())->body; + } else if (_monitored && !buffer(0)->empty()) { // Monitoring explictly enabled, send everything + const LV2_Atom_Sequence* seq = (const LV2_Atom_Sequence*)atom; LV2_ATOM_SEQUENCE_FOREACH(seq, ev) { context.notify(uris.ingen_activity, context.start() + ev->time.frames, @@ -415,8 +448,8 @@ PortImpl::monitor(Context& context, bool send_now) ev->body.type, LV2_ATOM_BODY(&ev->body)); } - } else if (seq->atom.size > sizeof(LV2_Atom_Sequence_Body)) { - // Just sending for blinkenlights, send one + } else if (!buffer(0)->empty()) { + // Just send activity for blinkenlights const int32_t one = 1; context.notify(uris.ingen_activity, context.start(), @@ -424,10 +457,11 @@ PortImpl::monitor(Context& context, bool send_now) sizeof(int32_t), (LV2_URID)uris.atom_Bool, &one); + _force_monitor_update = false; } } } - + _frames_since_monitor = _frames_since_monitor % period; if (key && val != _monitor_value) { if (context.notify(key, context.start(), this, @@ -440,7 +474,18 @@ PortImpl::monitor(Context& context, bool send_now) } // Otherwise failure, leave old value and try again next time } +} +BufferRef +PortImpl::value_buffer(uint32_t voice) +{ + return buffer(voice)->value_buffer(); +} + +SampleCount +PortImpl::next_value_offset(SampleCount offset, SampleCount end) const +{ + return end; } } // namespace Server diff --git a/src/server/PortImpl.hpp b/src/server/PortImpl.hpp index 4dd1afb3..ccefa0f1 100644 --- a/src/server/PortImpl.hpp +++ b/src/server/PortImpl.hpp @@ -48,6 +48,14 @@ public: SetState() : state(State::SET), value(0), time(0) {} + void set(const Context& context, FrameTime t, Sample v) { + time = t; + value = v; + state = (time == context.start() + ? State::SET + : State::HALF_SET_CYCLE_1); + } + State state; ///< State of buffer for setting control value Sample value; ///< Value currently being set FrameTime time; ///< Time value was set @@ -122,6 +130,7 @@ public: /** Called once per process cycle */ virtual void pre_process(Context& context) = 0; + virtual void pre_run(Context& context) {} virtual void post_process(Context& context) = 0; /** Empty buffer contents completely (ie silence) */ @@ -150,7 +159,7 @@ public: Resource::Properties& remove, Resource::Properties& add) {} - virtual void connect_buffers(); + virtual void connect_buffers(SampleCount offset=0); virtual void recycle_buffers(); virtual bool is_input() const = 0; @@ -160,6 +169,8 @@ public: inline bool is_a(PortType type) const { return _type == type; } + bool has_value() const; + PortType type() const { return _type; } LV2_URID buffer_type() const { return _buffer_type; } @@ -194,6 +205,17 @@ public: BufferFactory& bufs() const { return _bufs; } + BufferRef value_buffer(uint32_t voice); + + /** Return offset of the first value change after `offset`. */ + virtual SampleCount next_value_offset(SampleCount offset, + SampleCount end) const; + + /** Update value buffer to be current as of `offset`. */ + virtual void update_values(SampleCount offset) = 0; + + void force_monitor_update() { _force_monitor_update = true; } + void set_morphable(bool is_morph, bool is_auto_morph) { _is_morph = is_morph; _is_auto_morph = is_auto_morph; @@ -235,6 +257,7 @@ protected: Raul::Array* _voices; Raul::Array* _prepared_voices; bool _monitored; + bool _force_monitor_update; bool _set_by_user; bool _is_morph; bool _is_auto_morph; diff --git a/src/server/ProcessContext.hpp b/src/server/ProcessContext.hpp index 729bf4c4..78ed9344 100644 --- a/src/server/ProcessContext.hpp +++ b/src/server/ProcessContext.hpp @@ -33,6 +33,8 @@ class ProcessContext : public Context { public: explicit ProcessContext(Engine& engine) : Context(engine, ID::AUDIO) {} + + explicit ProcessContext(const ProcessContext& copy) : Context(copy) {} }; } // namespace Server diff --git a/src/server/internals/Controller.cpp b/src/server/internals/Controller.cpp index 1f4f75cc..5f084f6f 100644 --- a/src/server/internals/Controller.cpp +++ b/src/server/internals/Controller.cpp @@ -53,6 +53,10 @@ ControllerNode::ControllerNode(InternalPlugin* plugin, const Ingen::URIs& uris = bufs.uris(); _ports = new Raul::Array(6); + const Atom zero = bufs.forge().make(0.0f); + const Atom one = bufs.forge().make(1.0f); + const Atom atom_Float = bufs.forge().alloc_uri(LV2_ATOM__Float); + _midi_in_port = new InputPort(bufs, this, Raul::Symbol("input"), 0, 1, PortType::ATOM, uris.atom_Sequence, Atom()); _midi_in_port->set_property(uris.lv2_name, bufs.forge().alloc("Input")); @@ -61,40 +65,43 @@ ControllerNode::ControllerNode(InternalPlugin* plugin, _ports->at(0) = _midi_in_port; _param_port = new InputPort(bufs, this, Raul::Symbol("controller"), 1, 1, - PortType::CONTROL, 0, bufs.forge().make(0.0f)); - _param_port->set_property(uris.lv2_minimum, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _param_port->set_property(uris.atom_supports, atom_Float); + _param_port->set_property(uris.lv2_minimum, zero); _param_port->set_property(uris.lv2_maximum, bufs.forge().make(127.0f)); _param_port->set_property(uris.lv2_portProperty, uris.lv2_integer); _param_port->set_property(uris.lv2_name, bufs.forge().alloc("Controller")); _ports->at(1) = _param_port; _log_port = new InputPort(bufs, this, Raul::Symbol("logarithmic"), 2, 1, - PortType::CONTROL, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _log_port->set_property(uris.atom_supports, atom_Float); _log_port->set_property(uris.lv2_portProperty, uris.lv2_toggled); _log_port->set_property(uris.lv2_name, bufs.forge().alloc("Logarithmic")); _ports->at(2) = _log_port; _min_port = new InputPort(bufs, this, Raul::Symbol("minimum"), 3, 1, - PortType::CONTROL, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _min_port->set_property(uris.atom_supports, atom_Float); _min_port->set_property(uris.lv2_name, bufs.forge().alloc("Minimum")); _ports->at(3) = _min_port; _max_port = new InputPort(bufs, this, Raul::Symbol("maximum"), 4, 1, - PortType::CONTROL, 0, bufs.forge().make(1.0f)); + PortType::ATOM, uris.atom_Sequence, one); + _max_port->set_property(uris.atom_supports, atom_Float); _max_port->set_property(uris.lv2_name, bufs.forge().alloc("Maximum")); _ports->at(4) = _max_port; _audio_port = new OutputPort(bufs, this, Raul::Symbol("output"), 5, 1, - PortType::CV, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _audio_port->set_property(uris.atom_supports, atom_Float); _audio_port->set_property(uris.lv2_name, bufs.forge().alloc("Output")); _ports->at(5) = _audio_port; } void -ControllerNode::process(ProcessContext& context) +ControllerNode::run(ProcessContext& context) { - BlockImpl::pre_process(context); - Buffer* const midi_in = _midi_in_port->buffer(0).get(); LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)midi_in->atom(); LV2_ATOM_SEQUENCE_FOREACH(seq, ev) { @@ -105,8 +112,6 @@ ControllerNode::process(ProcessContext& context) control(context, buf[1], buf[2], ev->time.frames + context.start()); } } - - BlockImpl::post_process(context); } void @@ -117,10 +122,8 @@ ControllerNode::control(ProcessContext& context, uint8_t control_num, uint8_t va const Sample nval = (val / 127.0f); // normalized [0, 1] if (_learning) { - // FIXME: not thread safe - _param_port->set_value(context.engine().world()->forge().make(control_num)); _param_port->set_control_value(context, time, control_num); - _param_port->monitor(context, true); + _param_port->force_monitor_update(); _learning = false; } diff --git a/src/server/internals/Controller.hpp b/src/server/internals/Controller.hpp index 6cb78397..a5fc5ef2 100644 --- a/src/server/internals/Controller.hpp +++ b/src/server/internals/Controller.hpp @@ -45,7 +45,7 @@ public: GraphImpl* parent, SampleRate srate); - void process(ProcessContext& context); + void run(ProcessContext& context); void control(ProcessContext& context, uint8_t control_num, uint8_t val, FrameTime time); diff --git a/src/server/internals/Delay.cpp b/src/server/internals/Delay.cpp index 78d2118c..92bbe45b 100644 --- a/src/server/internals/Delay.cpp +++ b/src/server/internals/Delay.cpp @@ -138,14 +138,12 @@ static inline float cube_interp(const float fr, const float inm1, const float } void -DelayNode::process(ProcessContext& context) +DelayNode::run(ProcessContext& context) { Buffer* const delay_buf = _delay_port->buffer(0).get(); Buffer* const in_buf = _in_port->buffer(0).get(); Buffer* const out_buf = _out_port->buffer(0).get(); - BlockImpl::pre_process(context); - DelayNode* plugin_data = this; const float* const in = in_buf->samples(); @@ -200,8 +198,6 @@ DelayNode::process(ProcessContext& context) } _write_phase = write_phase; - - BlockImpl::post_process(context); } } // namespace Internals diff --git a/src/server/internals/Delay.hpp b/src/server/internals/Delay.hpp index 0dc5fb21..9df7349f 100644 --- a/src/server/internals/Delay.hpp +++ b/src/server/internals/Delay.hpp @@ -46,7 +46,7 @@ public: void activate(BufferFactory& bufs); - void process(ProcessContext& context); + void run(ProcessContext& context); static InternalPlugin* internal_plugin(URIs& uris); diff --git a/src/server/internals/Note.cpp b/src/server/internals/Note.cpp index e2ead4b7..7558334e 100644 --- a/src/server/internals/Note.cpp +++ b/src/server/internals/Note.cpp @@ -60,6 +60,8 @@ NoteNode::NoteNode(InternalPlugin* plugin, const Ingen::URIs& uris = bufs.uris(); _ports = new Raul::Array(6); + const Atom zero = bufs.forge().make(0.0f); + _midi_in_port = new InputPort(bufs, this, Raul::Symbol("input"), 0, 1, PortType::ATOM, uris.atom_Sequence, Atom()); _midi_in_port->set_property(uris.lv2_name, bufs.forge().alloc("Input")); @@ -68,35 +70,41 @@ NoteNode::NoteNode(InternalPlugin* plugin, _ports->at(0) = _midi_in_port; _freq_port = new OutputPort(bufs, this, Raul::Symbol("frequency"), 1, _polyphony, - PortType::CV, 0, bufs.forge().make(440.0f)); + PortType::ATOM, uris.atom_Sequence, + bufs.forge().make(440.0f)); + _freq_port->set_property(uris.atom_supports, bufs.uris().atom_Float); _freq_port->set_property(uris.lv2_name, bufs.forge().alloc("Frequency")); _freq_port->set_property(uris.lv2_minimum, bufs.forge().make(16.0f)); _freq_port->set_property(uris.lv2_maximum, bufs.forge().make(25088.0f)); _ports->at(1) = _freq_port; _num_port = new OutputPort(bufs, this, Raul::Symbol("number"), 1, _polyphony, - PortType::CV, 0, bufs.forge().make(0.0f)); - _num_port->set_property(uris.lv2_minimum, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _num_port->set_property(uris.atom_supports, bufs.uris().atom_Float); + _num_port->set_property(uris.lv2_minimum, zero); _num_port->set_property(uris.lv2_maximum, bufs.forge().make(127.0f)); _num_port->set_property(uris.lv2_portProperty, uris.lv2_integer); _num_port->set_property(uris.lv2_name, bufs.forge().alloc("Number")); _ports->at(2) = _num_port; _vel_port = new OutputPort(bufs, this, Raul::Symbol("velocity"), 2, _polyphony, - PortType::CV, 0, bufs.forge().make(0.0f)); - _vel_port->set_property(uris.lv2_minimum, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _vel_port->set_property(uris.atom_supports, bufs.uris().atom_Float); + _vel_port->set_property(uris.lv2_minimum, zero); _vel_port->set_property(uris.lv2_maximum, bufs.forge().make(1.0f)); _vel_port->set_property(uris.lv2_name, bufs.forge().alloc("Velocity")); _ports->at(3) = _vel_port; _gate_port = new OutputPort(bufs, this, Raul::Symbol("gate"), 3, _polyphony, - PortType::CV, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _gate_port->set_property(uris.atom_supports, bufs.uris().atom_Float); _gate_port->set_property(uris.lv2_portProperty, uris.lv2_toggled); _gate_port->set_property(uris.lv2_name, bufs.forge().alloc("Gate")); _ports->at(4) = _gate_port; _trig_port = new OutputPort(bufs, this, Raul::Symbol("trigger"), 4, _polyphony, - PortType::CV, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _trig_port->set_property(uris.atom_supports, bufs.uris().atom_Float); _trig_port->set_property(uris.lv2_portProperty, uris.lv2_toggled); _trig_port->set_property(uris.lv2_name, bufs.forge().alloc("Trigger")); _ports->at(5) = _trig_port; @@ -141,10 +149,8 @@ NoteNode::apply_poly(ProcessContext& context, Raul::Maid& maid, uint32_t poly) } void -NoteNode::process(ProcessContext& context) +NoteNode::run(ProcessContext& context) { - BlockImpl::pre_process(context); - Buffer* const midi_in = _midi_in_port->buffer(0).get(); LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)midi_in->atom(); LV2_ATOM_SEQUENCE_FOREACH(seq, ev) { @@ -182,8 +188,6 @@ NoteNode::process(ProcessContext& context) } } } - - BlockImpl::post_process(context); } static inline float diff --git a/src/server/internals/Note.hpp b/src/server/internals/Note.hpp index 027912b6..3b77cf12 100644 --- a/src/server/internals/Note.hpp +++ b/src/server/internals/Note.hpp @@ -50,7 +50,7 @@ public: bool prepare_poly(BufferFactory& bufs, uint32_t poly); bool apply_poly(ProcessContext& context, Raul::Maid& maid, uint32_t poly); - void process(ProcessContext& context); + void run(ProcessContext& context); void note_on(ProcessContext& context, uint8_t note_num, uint8_t velocity, FrameTime time); void note_off(ProcessContext& context, uint8_t note_num, FrameTime time); diff --git a/src/server/internals/Time.cpp b/src/server/internals/Time.cpp index 6f090257..54901172 100644 --- a/src/server/internals/Time.cpp +++ b/src/server/internals/Time.cpp @@ -57,10 +57,8 @@ TimeNode::TimeNode(InternalPlugin* plugin, } void -TimeNode::process(ProcessContext& context) +TimeNode::run(ProcessContext& context) { - BlockImpl::pre_process(context); - BufferRef buf = _notify_port->buffer(0); LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)buf->atom(); @@ -73,8 +71,6 @@ TimeNode::process(ProcessContext& context) // Ask the driver to append any time events for this cycle context.engine().driver()->append_time_events( context, *_notify_port->buffer(0)); - - BlockImpl::post_process(context); } } // namespace Internals diff --git a/src/server/internals/Time.hpp b/src/server/internals/Time.hpp index 7efe5d6a..8c0114b7 100644 --- a/src/server/internals/Time.hpp +++ b/src/server/internals/Time.hpp @@ -44,7 +44,7 @@ public: GraphImpl* parent, SampleRate srate); - void process(ProcessContext& context); + void run(ProcessContext& context); static InternalPlugin* internal_plugin(URIs& uris); diff --git a/src/server/internals/Trigger.cpp b/src/server/internals/Trigger.cpp index abef29ca..650126d4 100644 --- a/src/server/internals/Trigger.cpp +++ b/src/server/internals/Trigger.cpp @@ -53,6 +53,8 @@ TriggerNode::TriggerNode(InternalPlugin* plugin, const Ingen::URIs& uris = bufs.uris(); _ports = new Raul::Array(5); + const Atom zero = bufs.forge().make(0.0f); + _midi_in_port = new InputPort(bufs, this, Raul::Symbol("input"), 0, 1, PortType::ATOM, uris.atom_Sequence, Atom()); _midi_in_port->set_property(uris.lv2_name, bufs.forge().alloc("Input")); @@ -61,38 +63,41 @@ TriggerNode::TriggerNode(InternalPlugin* plugin, _ports->at(0) = _midi_in_port; _note_port = new InputPort(bufs, this, Raul::Symbol("note"), 1, 1, - PortType::CONTROL, 0, bufs.forge().make(60.0f)); - _note_port->set_property(uris.lv2_minimum, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, + bufs.forge().make(60.0f)); + _note_port->set_property(uris.atom_supports, bufs.uris().atom_Float); + _note_port->set_property(uris.lv2_minimum, zero); _note_port->set_property(uris.lv2_maximum, bufs.forge().make(127.0f)); _note_port->set_property(uris.lv2_portProperty, uris.lv2_integer); _note_port->set_property(uris.lv2_name, bufs.forge().alloc("Note")); _ports->at(1) = _note_port; _gate_port = new OutputPort(bufs, this, Raul::Symbol("gate"), 2, 1, - PortType::CV, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _gate_port->set_property(uris.atom_supports, bufs.uris().atom_Float); _gate_port->set_property(uris.lv2_portProperty, uris.lv2_toggled); _gate_port->set_property(uris.lv2_name, bufs.forge().alloc("Gate")); _ports->at(2) = _gate_port; _trig_port = new OutputPort(bufs, this, Raul::Symbol("trigger"), 3, 1, - PortType::CV, 0, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _trig_port->set_property(uris.atom_supports, bufs.uris().atom_Float); _trig_port->set_property(uris.lv2_portProperty, uris.lv2_toggled); _trig_port->set_property(uris.lv2_name, bufs.forge().alloc("Trigger")); _ports->at(3) = _trig_port; _vel_port = new OutputPort(bufs, this, Raul::Symbol("velocity"), 4, 1, - PortType::CV, 0, bufs.forge().make(0.0f)); - _vel_port->set_property(uris.lv2_minimum, bufs.forge().make(0.0f)); + PortType::ATOM, uris.atom_Sequence, zero); + _vel_port->set_property(uris.atom_supports, bufs.uris().atom_Float); + _vel_port->set_property(uris.lv2_minimum, zero); _vel_port->set_property(uris.lv2_maximum, bufs.forge().make(1.0f)); _vel_port->set_property(uris.lv2_name, bufs.forge().alloc("Velocity")); _ports->at(4) = _vel_port; } void -TriggerNode::process(ProcessContext& context) +TriggerNode::run(ProcessContext& context) { - BlockImpl::pre_process(context); - Buffer* const midi_in = _midi_in_port->buffer(0).get(); LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)midi_in->atom(); LV2_ATOM_SEQUENCE_FOREACH(seq, ev) { @@ -122,8 +127,6 @@ TriggerNode::process(ProcessContext& context) } } } - - BlockImpl::post_process(context); } void @@ -132,10 +135,8 @@ TriggerNode::note_on(ProcessContext& context, uint8_t note_num, uint8_t velocity assert(time >= context.start() && time <= context.end()); if (_learning) { - // FIXME: not thread safe - _note_port->set_value(context.engine().world()->forge().make((float)note_num)); _note_port->set_control_value(context, time, (float)note_num); - _note_port->monitor(context, true); + _note_port->force_monitor_update(); _learning = false; } @@ -145,7 +146,6 @@ TriggerNode::note_on(ProcessContext& context, uint8_t note_num, uint8_t velocity _trig_port->set_control_value(context, time, 1.0f); _trig_port->set_control_value(context, time + 1, 0.0f); _vel_port->set_control_value(context, time, velocity / 127.0f); - assert(_trig_port->buffer(0)->samples()[time - context.start()] == 1.0f); } } diff --git a/src/server/internals/Trigger.hpp b/src/server/internals/Trigger.hpp index b9ae4849..041bc801 100644 --- a/src/server/internals/Trigger.hpp +++ b/src/server/internals/Trigger.hpp @@ -48,7 +48,7 @@ public: GraphImpl* parent, SampleRate srate); - void process(ProcessContext& context); + void run(ProcessContext& context); void note_on(ProcessContext& context, uint8_t note_num, uint8_t velocity, FrameTime time); void note_off(ProcessContext& context, uint8_t note_num, FrameTime time); diff --git a/src/server/mix.cpp b/src/server/mix.cpp index 22ae60b0..afece4f6 100644 --- a/src/server/mix.cpp +++ b/src/server/mix.cpp @@ -63,6 +63,8 @@ mix(const Context& context, for (SampleCount i = 0; i < end; ++i) { out[i] += in[i]; } + } else if (srcs[i]->is_sequence()) { // sequence => audio + dst->render_sequence(context, srcs[i], true); } } } else if (dst->is_sequence()) { -- cgit v1.2.1