From c4f8a01ff00404f1c2d0a1d32a3b7c8fac5caff9 Mon Sep 17 00:00:00 2001 From: David Robillard Date: Wed, 8 Jul 2020 21:19:30 +0200 Subject: [PATCH] WIP: Remove support for deprecated LV2 event extension Not tested whatsoever, don't merge this. --- libs/ardour/ardour/buffer_set.h | 5 +- libs/ardour/ardour/lv2_plugin.h | 2 - libs/ardour/buffer_set.cc | 5 +- libs/ardour/lv2_evbuf.c | 187 ++++++++------------------------ libs/ardour/lv2_evbuf.h | 29 +---- libs/ardour/lv2_plugin.cc | 29 ++--- 6 files changed, 64 insertions(+), 193 deletions(-) diff --git a/libs/ardour/ardour/buffer_set.h b/libs/ardour/ardour/buffer_set.h index 6308b8aae8..4cea72400c 100644 --- a/libs/ardour/ardour/buffer_set.h +++ b/libs/ardour/ardour/buffer_set.h @@ -115,10 +115,9 @@ public: /** Get a MIDI buffer translated into an LV2 MIDI buffer for use with * plugins. The index here corresponds directly to MIDI buffer numbers * (i.e. the index passed to get_midi), translation back and forth will - * happen as needed. If old_api is true, the returned buffer will be in - * old event format. Otherwise it will be in new atom sequence format. + * happen as needed. */ - LV2_Evbuf* get_lv2_midi(bool input, size_t i, bool old_api); + LV2_Evbuf* get_lv2_midi(bool input, size_t i); /** ensure minimum size of LV2 Atom port buffer */ void ensure_lv2_bufsize(bool input, size_t i, size_t buffer_capacity); diff --git a/libs/ardour/ardour/lv2_plugin.h b/libs/ardour/ardour/lv2_plugin.h index a54876efae..e5a8138a7f 100644 --- a/libs/ardour/ardour/lv2_plugin.h +++ b/libs/ardour/ardour/lv2_plugin.h @@ -125,7 +125,6 @@ class LIBARDOUR_API LV2Plugin : public ARDOUR::Plugin, public ARDOUR::Workee bool parameter_is_audio (uint32_t) const; bool parameter_is_control (uint32_t) const; - bool parameter_is_event (uint32_t) const; bool parameter_is_input (uint32_t) const; bool parameter_is_output (uint32_t) const; bool parameter_is_toggled (uint32_t) const; @@ -242,7 +241,6 @@ class LIBARDOUR_API LV2Plugin : public ARDOUR::Plugin, public ARDOUR::Workee PORT_OUTPUT = 1 << 1, ///< Output port PORT_AUDIO = 1 << 2, ///< Audio (buffer of float) PORT_CONTROL = 1 << 3, ///< Control (single float) - PORT_EVENT = 1 << 4, ///< Old event API event port PORT_SEQUENCE = 1 << 5, ///< New atom API event port PORT_MIDI = 1 << 6, ///< Event port understands MIDI PORT_POSITION = 1 << 7, ///< Event port understands position diff --git a/libs/ardour/buffer_set.cc b/libs/ardour/buffer_set.cc index 018633b864..68bb12732c 100644 --- a/libs/ardour/buffer_set.cc +++ b/libs/ardour/buffer_set.cc @@ -197,7 +197,6 @@ BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capac while (_lv2_buffers.size() < _buffers[type].size() * 2) { _lv2_buffers.push_back( std::make_pair(false, lv2_evbuf_new(buffer_capacity, - LV2_EVBUF_EVENT, URIMap::instance().urids.atom_Chunk, URIMap::instance().urids.atom_Sequence))); } @@ -269,20 +268,18 @@ BufferSet::ensure_lv2_bufsize(bool input, size_t i, size_t buffer_capacity) _lv2_buffers.at(i * 2 + (input ? 0 : 1)) = std::make_pair(false, lv2_evbuf_new( buffer_capacity, - LV2_EVBUF_EVENT, URIMap::instance().urids.atom_Chunk, URIMap::instance().urids.atom_Sequence)); } LV2_Evbuf* -BufferSet::get_lv2_midi(bool input, size_t i, bool old_api) +BufferSet::get_lv2_midi(bool input, size_t i) { assert(count().get(DataType::MIDI) > i); LV2Buffers::value_type b = _lv2_buffers.at(i * 2 + (input ? 0 : 1)); LV2_Evbuf* evbuf = b.second; - lv2_evbuf_set_type(evbuf, old_api ? LV2_EVBUF_EVENT : LV2_EVBUF_ATOM); lv2_evbuf_reset(evbuf, input); return evbuf; } diff --git a/libs/ardour/lv2_evbuf.c b/libs/ardour/lv2_evbuf.c index b487e1fea9..da0dceda82 100644 --- a/libs/ardour/lv2_evbuf.c +++ b/libs/ardour/lv2_evbuf.c @@ -24,14 +24,10 @@ #include "lv2_evbuf.h" struct LV2_Evbuf_Impl { - LV2_Evbuf_Type type; - uint32_t capacity; - uint32_t atom_Chunk; - uint32_t atom_Sequence; - union { - LV2_Event_Buffer event; - LV2_Atom_Sequence atom; - } buf; + uint32_t capacity; + uint32_t atom_Chunk; + uint32_t atom_Sequence; + LV2_Atom_Sequence atom; }; static inline uint32_t @@ -42,7 +38,6 @@ lv2_evbuf_pad_size(uint32_t size) LV2_Evbuf* lv2_evbuf_new(uint32_t capacity, - LV2_Evbuf_Type type, uint32_t atom_Chunk, uint32_t atom_Sequence) { @@ -52,7 +47,6 @@ lv2_evbuf_new(uint32_t capacity, evbuf->capacity = capacity; evbuf->atom_Chunk = atom_Chunk; evbuf->atom_Sequence = atom_Sequence; - lv2_evbuf_set_type(evbuf, type); lv2_evbuf_reset(evbuf, true); return evbuf; } @@ -63,56 +57,27 @@ lv2_evbuf_free(LV2_Evbuf* evbuf) free(evbuf); } -void -lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type) -{ - evbuf->type = type; - switch (type) { - case LV2_EVBUF_EVENT: - evbuf->buf.event.data = (uint8_t*)(evbuf + 1); - evbuf->buf.event.capacity = evbuf->capacity; - break; - case LV2_EVBUF_ATOM: - break; - } - lv2_evbuf_reset(evbuf, true); -} - void lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input) { - switch (evbuf->type) { - case LV2_EVBUF_EVENT: - evbuf->buf.event.header_size = sizeof(LV2_Event_Buffer); - evbuf->buf.event.stamp_type = LV2_EVENT_AUDIO_STAMP; - evbuf->buf.event.event_count = 0; - evbuf->buf.event.size = 0; - break; - case LV2_EVBUF_ATOM: - if (input) { - evbuf->buf.atom.atom.size = sizeof(LV2_Atom_Sequence_Body); - evbuf->buf.atom.atom.type = evbuf->atom_Sequence; - } else { - evbuf->buf.atom.atom.size = evbuf->capacity; - evbuf->buf.atom.atom.type = evbuf->atom_Chunk; - } + if (input) { + evbuf->atom.atom.size = sizeof(LV2_Atom_Sequence_Body); + evbuf->atom.atom.type = evbuf->atom_Sequence; + } else { + evbuf->atom.atom.size = evbuf->capacity; + evbuf->atom.atom.type = evbuf->atom_Chunk; } } uint32_t lv2_evbuf_get_size(LV2_Evbuf* evbuf) { - switch (evbuf->type) { - case LV2_EVBUF_EVENT: - return evbuf->buf.event.size; - case LV2_EVBUF_ATOM: - assert(evbuf->buf.atom.atom.type != evbuf->atom_Sequence - || evbuf->buf.atom.atom.size >= sizeof(LV2_Atom_Sequence_Body)); - return evbuf->buf.atom.atom.type == evbuf->atom_Sequence - ? evbuf->buf.atom.atom.size - sizeof(LV2_Atom_Sequence_Body) - : 0; - } - return 0; + assert(evbuf->atom.atom.type != evbuf->atom_Sequence + || evbuf->atom.atom.size >= sizeof(LV2_Atom_Sequence_Body)); + + return evbuf->atom.atom.type == evbuf->atom_Sequence + ? evbuf->atom.atom.size - sizeof(LV2_Atom_Sequence_Body) + : 0; } uint32_t @@ -124,13 +89,7 @@ lv2_evbuf_get_capacity(LV2_Evbuf* evbuf) void* lv2_evbuf_get_buffer(LV2_Evbuf* evbuf) { - switch (evbuf->type) { - case LV2_EVBUF_EVENT: - return &evbuf->buf.event; - case LV2_EVBUF_ATOM: - return &evbuf->buf.atom; - } - return NULL; + return &evbuf->atom; } LV2_Evbuf_Iterator @@ -163,19 +122,13 @@ lv2_evbuf_next(LV2_Evbuf_Iterator iter) LV2_Evbuf* evbuf = iter.evbuf; uint32_t offset = iter.offset; - uint32_t size; - switch (evbuf->type) { - case LV2_EVBUF_EVENT: - size = ((LV2_Event*)((uintptr_t)(evbuf->buf.event.data + offset)))->size; - offset += lv2_evbuf_pad_size(sizeof(LV2_Event) + size); - break; - case LV2_EVBUF_ATOM: - size = ((LV2_Atom_Event*)((uintptr_t) - ((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->buf.atom) - + offset)))->body.size; - offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); - break; - } + uint32_t size = + ((LV2_Atom_Event*)((uintptr_t)( + (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->atom) + + offset))) + ->body.size; + + offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); LV2_Evbuf_Iterator next = { evbuf, offset }; return next; @@ -196,32 +149,15 @@ lv2_evbuf_get(LV2_Evbuf_Iterator iter, return false; } - LV2_Event_Buffer* ebuf; - LV2_Event* ev; - LV2_Atom_Sequence* aseq; - LV2_Atom_Event* aev; - switch (iter.evbuf->type) { - case LV2_EVBUF_EVENT: - ebuf = &iter.evbuf->buf.event; - ev = (LV2_Event*)((uintptr_t)((char*)ebuf->data + iter.offset)); - *samples = ev->frames; - *subframes = ev->subframes; - *type = ev->type; - *size = ev->size; - *data = (uint8_t*)ev + sizeof(LV2_Event); - break; - case LV2_EVBUF_ATOM: - aseq = (LV2_Atom_Sequence*)&iter.evbuf->buf.atom; - aev = (LV2_Atom_Event*)((uintptr_t)( - (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) - + iter.offset)); - *samples = aev->time.frames; - *subframes = 0; - *type = aev->body.type; - *size = aev->body.size; - *data = (uint8_t*)LV2_ATOM_BODY(&aev->body); - break; - } + LV2_Atom_Sequence* aseq = (LV2_Atom_Sequence*)&iter.evbuf->atom; + LV2_Atom_Event* aev = (LV2_Atom_Event*)((uintptr_t)( + (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + iter.offset)); + + *samples = aev->time.frames; + *subframes = 0; + *type = aev->body.type; + *size = aev->body.size; + *data = (uint8_t*)LV2_ATOM_BODY(&aev->body); return true; } @@ -234,51 +170,24 @@ lv2_evbuf_write(LV2_Evbuf_Iterator* iter, uint32_t size, const uint8_t* data) { - LV2_Event_Buffer* ebuf; - LV2_Event* ev; - LV2_Atom_Sequence* aseq; - LV2_Atom_Event* aev; - switch (iter->evbuf->type) { - case LV2_EVBUF_EVENT: - ebuf = &iter->evbuf->buf.event; - if (ebuf->capacity - ebuf->size < sizeof(LV2_Event) + size) { - return false; - } + LV2_Atom_Sequence* aseq = (LV2_Atom_Sequence*)&iter->evbuf->atom; - ev = (LV2_Event*)((uintptr_t)(ebuf->data + iter->offset)); - ev->frames = samples; - ev->subframes = subframes; - ev->type = type; - ev->size = size; - memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size); - - size = lv2_evbuf_pad_size(sizeof(LV2_Event) + size); - ebuf->size += size; - ebuf->event_count += 1; - iter->offset += size; - break; - case LV2_EVBUF_ATOM: - aseq = (LV2_Atom_Sequence*)&iter->evbuf->buf.atom; - if (iter->evbuf->capacity - sizeof(LV2_Atom) - aseq->atom.size - < sizeof(LV2_Atom_Event) + size) { - return false; - } - - aev = (LV2_Atom_Event*)((uintptr_t)( - (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) - + iter->offset)); - aev->time.frames = samples; - aev->body.type = type; - aev->body.size = size; - memcpy(LV2_ATOM_BODY(&aev->body), data, size); - - size = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); - aseq->atom.size += size; - iter->offset += size; - break; - default: + if (iter->evbuf->capacity - sizeof(LV2_Atom) - aseq->atom.size + < sizeof(LV2_Atom_Event) + size) { return false; } + LV2_Atom_Event* aev = (LV2_Atom_Event*)((uintptr_t)( + (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + iter->offset)); + + aev->time.frames = samples; + aev->body.type = type; + aev->body.size = size; + memcpy(LV2_ATOM_BODY(&aev->body), data, size); + + size = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); + aseq->atom.size += size; + iter->offset += size; + return true; } diff --git a/libs/ardour/lv2_evbuf.h b/libs/ardour/lv2_evbuf.h index 000fb9c25f..e38dbf4ad2 100644 --- a/libs/ardour/lv2_evbuf.h +++ b/libs/ardour/lv2_evbuf.h @@ -25,21 +25,6 @@ extern "C" { #include #endif -/** - Format of actual buffer. -*/ -typedef enum { - /** - An (old) ev:EventBuffer (LV2_Event_Buffer). - */ - LV2_EVBUF_EVENT, - - /** - A (new) atom:Sequence (LV2_Atom_Sequence). - */ - LV2_EVBUF_ATOM -} LV2_Evbuf_Type; - /** An abstract/opaque LV2 event buffer. */ @@ -58,10 +43,9 @@ typedef struct { URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM. */ LV2_Evbuf* -lv2_evbuf_new(uint32_t capacity, - LV2_Evbuf_Type type, - uint32_t atom_Chunk, - uint32_t atom_Sequence); +lv2_evbuf_new(uint32_t capacity, + uint32_t atom_Chunk, + uint32_t atom_Sequence); /** Free an event buffer allocated with lv2_evbuf_new. @@ -69,13 +53,6 @@ lv2_evbuf_new(uint32_t capacity, void lv2_evbuf_free(LV2_Evbuf* evbuf); -/** - Reset and change the type of an existing event buffer. - URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM. -*/ -void -lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type); - /** Clear and initialize an existing event buffer. The contents of buf are ignored entirely and overwritten, except capacity diff --git a/libs/ardour/lv2_plugin.cc b/libs/ardour/lv2_plugin.cc index 9dbba967d9..00b505da8b 100644 --- a/libs/ardour/lv2_plugin.cc +++ b/libs/ardour/lv2_plugin.cc @@ -722,9 +722,6 @@ LV2Plugin::init(const void* c_plugin, samplecnt_t rate) flags |= PORT_CONTROL; } else if (lilv_port_is_a(_impl->plugin, port, _world.lv2_AudioPort)) { flags |= PORT_AUDIO; - } else if (lilv_port_is_a(_impl->plugin, port, _world.ev_EventPort)) { - flags |= PORT_EVENT; - flags |= PORT_MIDI; // We assume old event API ports are for MIDI } else if (lilv_port_is_a(_impl->plugin, port, _world.atom_AtomPort)) { LilvNodes* buffer_types = lilv_port_get_value( _impl->plugin, port, _world.atom_bufferType); @@ -2334,7 +2331,7 @@ LV2Plugin::describe_io_port (ARDOUR::DataType dt, bool input, uint32_t id) const match = PORT_AUDIO; break; case DataType::MIDI: - match = PORT_SEQUENCE | PORT_MIDI; // ignore old PORT_EVENT + match = PORT_SEQUENCE | PORT_MIDI; break; default: return Plugin::IOPortDescription ("?"); @@ -2594,8 +2591,9 @@ LV2Plugin::allocate_atom_event_buffers() DEBUG_TRACE(DEBUG::LV2, string_compose("allocate %1 atom_ev_buffers of %2 bytes\n", total_atom_buffers, minimumSize)); _atom_ev_buffers = (LV2_Evbuf**) malloc((total_atom_buffers + 1) * sizeof(LV2_Evbuf*)); for (int i = 0; i < total_atom_buffers; ++i ) { - _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, LV2_EVBUF_ATOM, - _uri_map.urids.atom_Chunk, _uri_map.urids.atom_Sequence); + _atom_ev_buffers[i] = lv2_evbuf_new(minimumSize, + _uri_map.urids.atom_Chunk, + _uri_map.urids.atom_Sequence); } _atom_ev_buffers[total_atom_buffers] = 0; return; @@ -2740,7 +2738,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, ? bufs.get_audio(index).data(offset) : scratch_bufs.get_audio(0).data(offset); } - } else if (flags & (PORT_EVENT|PORT_SEQUENCE)) { + } else if (flags & PORT_SEQUENCE) { /* FIXME: The checks here for bufs.count().n_midi() > index shouldn't be necessary, but the mapping is illegal in some cases. Ideally that should be fixed, but this is easier... @@ -2759,7 +2757,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, */ bufs.ensure_lv2_bufsize((flags & PORT_INPUT), index, _port_minimumSize[port_index]); _ev_buffers[port_index] = bufs.get_lv2_midi( - (flags & PORT_INPUT), index, (flags & PORT_EVENT)); + (flags & PORT_INPUT), index); } } else if ((flags & PORT_POSITION) && (flags & PORT_INPUT)) { lv2_evbuf_reset(_atom_ev_buffers[atom_port_index], true); @@ -2829,7 +2827,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, scratch_bufs.ensure_lv2_bufsize((flags & PORT_INPUT), 0, _port_minimumSize[port_index]); _ev_buffers[port_index] = scratch_bufs.get_lv2_midi( - (flags & PORT_INPUT), 0, (flags & PORT_EVENT)); + (flags & PORT_INPUT), 0); } buf = lv2_evbuf_get_buffer(_ev_buffers[port_index]); @@ -2911,7 +2909,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, * for quite a while at least ;) */ // copy output of LV2 plugin's MIDI port to Ardour MIDI buffers -- MIDI OUT - if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE|PORT_MIDI))) { + if ((flags & PORT_OUTPUT) && (flags & (PORT_SEQUENCE|PORT_MIDI))) { const uint32_t buf_index = out_map.get( DataType::MIDI, midi_out_index++, &valid); if (valid) { @@ -2919,7 +2917,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, } } // Flush MIDI (write back to Ardour MIDI buffers) -- MIDI THRU - else if ((flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) { + else if ((flags & PORT_OUTPUT) && (flags & PORT_SEQUENCE)) { const uint32_t buf_index = out_map.get( DataType::MIDI, midi_out_index++, &valid); if (valid) { @@ -2929,7 +2927,7 @@ LV2Plugin::connect_and_run(BufferSet& bufs, // Write messages to UI if ((_to_ui || _can_write_automation || _patch_port_out_index != (uint32_t)-1) && - (flags & PORT_OUTPUT) && (flags & (PORT_EVENT|PORT_SEQUENCE))) { + (flags & PORT_OUTPUT) && (flags & PORT_SEQUENCE)) { LV2_Evbuf* buf = _ev_buffers[port_index]; for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(buf); lv2_evbuf_is_valid(i); @@ -3151,13 +3149,6 @@ LV2Plugin::parameter_is_audio(uint32_t param) const return _port_flags[param] & PORT_AUDIO; } -bool -LV2Plugin::parameter_is_event(uint32_t param) const -{ - assert(param < _port_flags.size()); - return _port_flags[param] & PORT_EVENT; -} - bool LV2Plugin::parameter_is_output(uint32_t param) const {