vanja/yabridge
1
0
Fork 0
mirror of https://github.com/robbert-vdh/yabridge.git synced 2026-05-08 20:40:11 +02:00
Code Issues Packages Projects Releases Wiki Activity

Move EventPayload to Vst2Event::Payload

Browse Source
This commit is contained in:
Robbert van der Helm
2021-05-20 15:50:22 +02:00
parent b1c9d75112
commit 2bf41c6fe1
7 changed files with 140 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/common/communication/vst2.cpp
+5 -5
View File
@@ -18,10 +18,10 @@
DefaultDataConverter::~DefaultDataConverter() noexcept {}
EventPayload DefaultDataConverter::read_data(const int /*opcode*/,
const int /*index*/,
const intptr_t /*value*/,
const void* data) const {
Vst2Event::Payload DefaultDataConverter::read_data(const int /*opcode*/,
const int /*index*/,
const intptr_t /*value*/,
const void* data) const {
if (!data) {
return nullptr;
}
@@ -38,7 +38,7 @@ EventPayload DefaultDataConverter::read_data(const int /*opcode*/,
}
}
std::optional<EventPayload> DefaultDataConverter::read_value(
std::optional<Vst2Event::Payload> DefaultDataConverter::read_value(
const int /*opcode*/,
const intptr_t /*value*/) const {
return std::nullopt;
src/common/communication/vst2.h
+27 -23
View File
@@ -34,21 +34,23 @@ class DefaultDataConverter {
virtual ~DefaultDataConverter() noexcept;
/**
* Read data from the `data` void pointer into a an `EventPayload` value
* that can be serialized and conveys the meaning of the event.
* Read data from the `data` void pointer into a an `Vst2Event::Payload`
* value that can be serialized and conveys the meaning of the event.
*/
virtual EventPayload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const;
virtual Vst2Event::Payload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const;
/**
* Read data from the `value` pointer into a an `EventPayload` value that
* can be serialized and conveys the meaning of the event. This is only used
* for the `effSetSpeakerArrangement` and `effGetSpeakerArrangement` events.
* Read data from the `value` pointer into a an `Vst2Event::Payload` value
* that can be serialized and conveys the meaning of the event. This is only
* used for the `effSetSpeakerArrangement` and `effGetSpeakerArrangement`
* events.
*/
virtual std::optional<EventPayload> read_value(const int opcode,
const intptr_t value) const;
virtual std::optional<Vst2Event::Payload> read_value(
const int opcode,
const intptr_t value) const;
/**
* Write the response back to the `data` pointer.
@@ -153,8 +155,9 @@ class Vst2EventHandler : public AdHocSocketHandler<Thread> {
* write data back to the `data` void pointer. For host callbacks this
* parameter contains either a string or a null pointer while `dispatch()`
* calls might contain opcode specific structs. See the documentation for
* `EventPayload` for more information. The `DefaultDataConverter` defined
* above handles the basic behavior that's sufficient for host callbacks.
* `Vst2Event::Payload` for more information. The `DefaultDataConverter`
* defined above handles the basic behavior that's sufficient for host
* callbacks.
* @param logging A pair containing a logger instance and whether or not
* this is for sending `dispatch()` events or host callbacks. Optional
* since it doesn't have to be done on both sides.
@@ -171,12 +174,13 @@ class Vst2EventHandler : public AdHocSocketHandler<Thread> {
void* data,
float option) {
// Encode the right payload types for this event. Check the
// documentation for `EventPayload` for more information. These types
// are converted to C-style data structures in `passthrough_event()` so
// they can be passed to a plugin or callback function.
const EventPayload payload =
// documentation for `Vst2Event::Payload` for more information. These
// types are converted to C-style data structures in
// `passthrough_event()` so they can be passed to a plugin or callback
// function.
const Vst2Event::Payload payload =
data_converter.read_data(opcode, index, value, data);
const std::optional<EventPayload> value_payload =
const std::optional<Vst2Event::Payload> value_payload =
data_converter.read_value(opcode, value);
if (logging) {
@@ -224,8 +228,8 @@ class Vst2EventHandler : public AdHocSocketHandler<Thread> {
*
* The specified function will be used to create an `EventResult` from an
* `Vst2Event`. This is almost always uses `passthrough_event()`, which
* converts a `EventPayload` into the format used by VST2, calls either
* `dispatch()` or `audioMaster()` depending on the context, and then
* converts a `Vst2Event::Payload` into the format used by VST2, calls
* either `dispatch()` or `audioMaster()` depending on the context, and then
* serializes the result back into an `EventResultPayload`.
*
* @param logging A pair containing a logger instance and whether or not
@@ -381,9 +385,9 @@ class Vst2Sockets : public Sockets {
};
/**
* Unmarshall an `EventPayload` back to the representation used by VST2, pass
* that value to a callback function (either `AEffect::dispatcher()` for host ->
* plugin events or `audioMaster()` for plugin -> host events), and then
* Unmarshall an `Vst2Event::Payload` back to the representation used by VST2,
* pass that value to a callback function (either `AEffect::dispatcher()` for
* host -> plugin events or `audioMaster()` for plugin -> host events), and then
* serialize the results back into an `EventResult`.
*
* This is the receiving analogue of the `*DataCovnerter` objects.
src/common/logging/vst2.cpp
+2 -2
View File
@@ -360,9 +360,9 @@ void Vst2Logger::log_event(bool is_dispatch,
int opcode,
int index,
intptr_t value,
const EventPayload& payload,
const Vst2Event::Payload& payload,
float option,
const std::optional<EventPayload>& value_payload) {
const std::optional<Vst2Event::Payload>& value_payload) {
if (BOOST_UNLIKELY(logger.verbosity >= Logger::Verbosity::most_events)) {
if (should_filter_event(is_dispatch, opcode)) {
return;
src/common/logging/vst2.h
+2 -2
View File
@@ -66,9 +66,9 @@ class Vst2Logger {
int opcode,
int index,
intptr_t value,
const EventPayload& payload,
const Vst2Event::Payload& payload,
float option,
const std::optional<EventPayload>& value_payload);
const std::optional<Vst2Event::Payload>& value_payload);
void log_event_response(
bool is_dispatch,
int opcode,
src/common/serialization/vst2.h
+94 -92
View File
@@ -304,60 +304,103 @@ struct WantsVstTimeInfo {};
struct WantsString {};
/**
* VST events are passed a void pointer that can contain a variety of different
* data types depending on the event's opcode. This is typically either:
*
* - A null pointer, used for simple events.
* - A char pointer to a null terminated string, used for passing strings to the
* plugin such as when renaming presets. Bitsery handles the serialization for
* us.
*
* NOTE: Bitsery does not support null terminated C-strings without a known
* size. We can replace `std::string` with `char*` once it does for
* clarity's sake.
*
* - A byte vector for handling chunk data during `effSetChunk()`. We can't
* reuse the regular string handling here since the data may contain null
* bytes and `std::string::as_c_str()` might cut off everything after the
* first null byte.
* - An X11 window handle.
* - Specific data structures from `aeffextx.h`. For instance an event with the
* opcode `effProcessEvents` the hosts passes a `VstEvents` struct containing
* MIDI events, and `audioMasterIOChanged` lets the host know that the
* `AEffect` struct has changed.
*
* - Some empty buffer for the plugin to write its own data to, for instance for
* a plugin to report its name or the label for a certain parameter. There are
* two separate cases here. This is typically a short null terminated
* C-string. We'll assume this as the default case when none of the above
* options apply.
*
* - Either the plugin writes arbitrary data and uses its return value to
* indicate how much data was written (i.e. for the `effGetChunk` opcode).
* For this we use a vector of bytes instead of a string since
* - Or the plugin will write a short null terminated C-string there. We'll
* assume that this is the default if none of the above options apply.
*
* @relates passthrough_event
* An event as dispatched by the VST host. These events will get forwarded to
* the VST host process running under Wine. The fields here mirror those
* arguments sent to the `AEffect::dispatch` function.
*/
using EventPayload = std::variant<std::nullptr_t,
std::string,
native_size_t,
AEffect,
ChunkData,
DynamicVstEvents,
DynamicSpeakerArrangement,
WantsAEffectUpdate,
WantsChunkBuffer,
VstIOProperties,
VstMidiKeyName,
VstParameterProperties,
WantsVstRect,
WantsVstTimeInfo,
WantsString>;
struct Vst2Event {
/**
* VST events are passed a void pointer that can contain a variety of
* different data types depending on the event's opcode. This is typically
* either:
*
* - A null pointer, used for simple events.
* - A char pointer to a null terminated string, used for passing strings to
* the plugin such as when renaming presets. Bitsery handles the
* serialization for us.
*
* NOTE: Bitsery does not support null terminated C-strings without a
* known size. We can replace `std::string` with `char*` once it
* does for clarity's sake.
*
* - A byte vector for handling chunk data during `effSetChunk()`. We can't
* reuse the regular string handling here since the data may contain null
* bytes and `std::string::as_c_str()` might cut off everything after the
* first null byte.
* - An X11 window handle.
* - Specific data structures from `aeffextx.h`. For instance an event with
* the opcode `effProcessEvents` the hosts passes a `VstEvents` struct
* containing MIDI events, and `audioMasterIOChanged` lets the host know
* that the `AEffect` struct has changed.
*
* - Some empty buffer for the plugin to write its own data to, for instance
* for a plugin to report its name or the label for a certain parameter.
* There are two separate cases here. This is typically a short null
* terminated C-string. We'll assume this as the default case when none of
* the above options apply.
*
* - Either the plugin writes arbitrary data and uses its return value to
* indicate how much data was written (i.e. for the `effGetChunk`
* opcode). For this we use a vector of bytes instead of a string since
* - Or the plugin will write a short null terminated C-string there.
* We'll assume that this is the default if none of the above options
* apply.
*
* @relates passthrough_event
*/
using Payload = std::variant<std::nullptr_t,
std::string,
native_size_t,
AEffect,
ChunkData,
DynamicVstEvents,
DynamicSpeakerArrangement,
WantsAEffectUpdate,
WantsChunkBuffer,
VstIOProperties,
VstMidiKeyName,
VstParameterProperties,
WantsVstRect,
WantsVstTimeInfo,
WantsString>;
int opcode;
int index;
native_intptr_t value;
float option;
/**
* The event dispatch function has a void pointer parameter that's often
* used to either pass additional data for the event or to provide a buffer
* for the plugin to write a string into.
*
* The `VstEvents` struct passed for the `effProcessEvents` event contains
* an array of pointers. This requires some special handling which is why we
* have to use an `std::variant` instead of a simple string buffer. Luckily
* Bitsery can do all the hard work for us.
*/
Payload payload;
/**
* The same as the above value, but for values passed through the `intptr_t`
* value parameter. `effGetSpeakerArrangement` and
* `effSetSpeakerArrangement` are the only events that use this.
*/
std::optional<Payload> value_payload;
template <typename S>
void serialize(S& s) {
s.value4b(opcode);
s.value4b(index);
s.value8b(value);
s.value4b(option);
s.object(payload);
s.ext(value_payload, bitsery::ext::StdOptional(),
[](S& s, auto& v) { s.object(v); });
}
};
template <typename S>
void serialize(S& s, EventPayload& payload) {
void serialize(S& s, Vst2Event::Payload& payload) {
s.ext(payload,
bitsery::ext::StdVariant{
[](S&, std::nullptr_t&) {},
@@ -383,47 +426,6 @@ void serialize(S& s, EventPayload& payload) {
[](S&, WantsString&) {}});
}
/**
* An event as dispatched by the VST host. These events will get forwarded to
* the VST host process running under Wine. The fields here mirror those
* arguments sent to the `AEffect::dispatch` function.
*/
struct Vst2Event {
int opcode;
int index;
native_intptr_t value;
float option;
/**
* The event dispatch function has a void pointer parameter that's often
* used to either pass additional data for the event or to provide a buffer
* for the plugin to write a string into.
*
* The `VstEvents` struct passed for the `effProcessEvents` event contains
* an array of pointers. This requires some special handling which is why we
* have to use an `std::variant` instead of a simple string buffer. Luckily
* Bitsery can do all the hard work for us.
*/
EventPayload payload;
/**
* The same as the above value, but for values passed through the `intptr_t`
* value parameter. `effGetSpeakerArrangement` and
* `effSetSpeakerArrangement` are the only events that use this.
*/
std::optional<EventPayload> value_payload;
template <typename S>
void serialize(S& s) {
s.value4b(opcode);
s.value4b(index);
s.value8b(value);
s.value4b(option);
s.object(payload);
s.ext(value_payload, bitsery::ext::StdOptional(),
[](S& s, auto& v) { s.object(v); });
}
};
/**
* The response for an event. This is usually either:
*
src/plugin/bridges/vst2.cpp
+5 -5
View File
@@ -190,10 +190,10 @@ class DispatchDataConverter : public DefaultDataConverter {
VstRect& editor_rectangle) noexcept
: chunk(chunk_data), plugin(plugin), rect(editor_rectangle) {}
EventPayload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const override {
Vst2Event::Payload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const override {
// There are some events that need specific structs that we can't simply
// serialize as a string because they might contain null bytes
switch (opcode) {
@@ -307,7 +307,7 @@ class DispatchDataConverter : public DefaultDataConverter {
}
}
std::optional<EventPayload> read_value(
std::optional<Vst2Event::Payload> read_value(
const int opcode,
const intptr_t value) const override {
switch (opcode) {
src/wine-host/bridges/vst2.cpp
+5 -5
View File
@@ -519,10 +519,10 @@ class HostCallbackDataConverter : public DefaultDataConverter {
last_time_info(last_time_info),
mutual_recursion(mutual_recursion) {}
EventPayload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const override {
Vst2Event::Payload read_data(const int opcode,
const int index,
const intptr_t value,
const void* data) const override {
switch (opcode) {
case audioMasterGetTime:
return WantsVstTimeInfo{};
@@ -580,7 +580,7 @@ class HostCallbackDataConverter : public DefaultDataConverter {
}
}
std::optional<EventPayload> read_value(
std::optional<Vst2Event::Payload> read_value(
const int opcode,
const intptr_t value) const override {
return DefaultDataConverter::read_value(opcode, value);