mirror of
https://github.com/robbert-vdh/yabridge.git
synced 2026-05-17 14:10:02 +02:00
No longer return a lambda in passthrough_event()
Now that it's no longer used directly this is no longer needed, and it's much clearer without the lambda.
This commit is contained in:
Robbert van der Helm
+147
-161
@@ -565,10 +565,10 @@ class EventHandler {
|
||||
* then a blocking loop that handles events from the primary `socket`.
|
||||
*
|
||||
* The specified function will be used to create an `EventResult` from an
|
||||
* `Event`. This is almost always a wrapper around `passthrough_event()`,
|
||||
* which converts the `EventPayload` into a format used by VST2, calls
|
||||
* either `dispatch()` or `audioMaster()` depending on the socket, and then
|
||||
* serializes the result back into an `EventResultPayload`.
|
||||
* `Event`. This is almost uses `passthrough_event()`, which converts a
|
||||
* `EventPayload` into the format used by VST2, calls either `dispatch()` or
|
||||
* `audioMaster()` depending on the context, and then serializes the result
|
||||
* back into an `EventResultPayload`.
|
||||
*
|
||||
* This function will also be used separately for receiving MIDI data, as
|
||||
* some plugins will need pointers to received MIDI data to stay alive until
|
||||
@@ -920,180 +920,166 @@ class Sockets {
|
||||
boost::filesystem::path generate_endpoint_base(const std::string& plugin_name);
|
||||
|
||||
/**
|
||||
* Create a callback function that takes an `Event` object, decodes the data
|
||||
* into the expected format for VST2 function calls, calls the given function
|
||||
* (either `AEffect::dispatcher()` for host -> plugin events or `audioMaster()`
|
||||
* for plugin -> host events), and serializes the results back into an
|
||||
* `EventResult` object. I'd rather not get too Haskell-y in my C++, but this is
|
||||
* the cleanest solution for this problem.
|
||||
* 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
|
||||
* serialize the results back into an `EventResult`.
|
||||
*
|
||||
* This is the receiving analogue of the `*DataCovnerter` objects.
|
||||
*
|
||||
* TODO: Now that `EventHandler::receive_events` replaced `receive_event()`,
|
||||
* refactor this to just handle the event directly rather than returning a
|
||||
* lambda
|
||||
*
|
||||
* @param plugin The `AEffect` instance that should be passed to the callback
|
||||
* function.
|
||||
* function. During `WantsAEffect` we'll send back a copy of this, and when we
|
||||
* get sent an `AEffect` instance (e.g. during `audioMasterIOChanged()`) we'll
|
||||
* write the updated values to this isntance.
|
||||
* @param callback The function to call with the arguments received from the
|
||||
* socket.
|
||||
* socket, either `AEffect::dispatcher()` or `audioMasterCallback()`.
|
||||
*
|
||||
* @tparam A function with the same signature as `AEffect::dispatcher` or
|
||||
* @tparam F A function with the same signature as `AEffect::dispatcher` or
|
||||
* `audioMasterCallback`.
|
||||
*
|
||||
* @return A `EventResult(Event)` callback function that can be passed to
|
||||
* `EditorHandler::receive_events()`.
|
||||
* @return The result of the operation. If necessary the `DataConverter` will
|
||||
* unmarshall the payload again and write it back.
|
||||
*
|
||||
* @relates EventHandler::receive_events
|
||||
*/
|
||||
template <typename F>
|
||||
auto passthrough_event(AEffect* plugin, F callback) {
|
||||
return [=](Event& event) -> EventResult {
|
||||
// This buffer is used to write strings and small objects to. We'll
|
||||
// initialize the beginning with null values to both prevent it from
|
||||
// being read as some arbitrary C-style string, and to make sure that
|
||||
// `*static_cast<void**>(string_buffer.data)` will be a null pointer if
|
||||
// the plugin is supposed to write a pointer there but doesn't (such as
|
||||
// with `effEditGetRect`/`WantsVstRect`).
|
||||
std::array<char, max_string_length> string_buffer;
|
||||
std::fill(string_buffer.begin(), string_buffer.begin() + sizeof(size_t),
|
||||
0);
|
||||
EventResult passthrough_event(AEffect* plugin, F callback, Event& event) {
|
||||
// This buffer is used to write strings and small objects to. We'll
|
||||
// initialize the beginning with null values to both prevent it from being
|
||||
// read as some arbitrary C-style string, and to make sure that
|
||||
// `*static_cast<void**>(string_buffer.data)` will be a null pointer if the
|
||||
// plugin is supposed to write a pointer there but doesn't (such as with
|
||||
// `effEditGetRect`/`WantsVstRect`).
|
||||
std::array<char, max_string_length> string_buffer;
|
||||
std::fill(string_buffer.begin(), string_buffer.begin() + sizeof(size_t), 0);
|
||||
|
||||
auto read_payload_fn = overload{
|
||||
[&](const std::nullptr_t&) -> void* { return nullptr; },
|
||||
[&](const std::string& s) -> void* {
|
||||
return const_cast<char*>(s.c_str());
|
||||
},
|
||||
[&](const std::vector<uint8_t>& buffer) -> void* {
|
||||
return const_cast<uint8_t*>(buffer.data());
|
||||
},
|
||||
[&](native_size_t& window_handle) -> void* {
|
||||
// This is the X11 window handle that the editor should reparent
|
||||
// itself to. We have a special wrapper around the dispatch
|
||||
// function that intercepts `effEditOpen` events and creates a
|
||||
// Win32 window and then finally embeds the X11 window Wine
|
||||
// created into this wnidow handle. Make sure to convert the
|
||||
// window ID first to `size_t` in case this is the 32-bit host.
|
||||
return reinterpret_cast<void*>(
|
||||
static_cast<size_t>(window_handle));
|
||||
},
|
||||
[&](const AEffect&) -> void* { return nullptr; },
|
||||
[&](DynamicVstEvents& events) -> void* {
|
||||
return &events.as_c_events();
|
||||
},
|
||||
[&](DynamicSpeakerArrangement& speaker_arrangement) -> void* {
|
||||
return &speaker_arrangement.as_c_speaker_arrangement();
|
||||
},
|
||||
[&](WantsAEffectUpdate&) -> void* {
|
||||
// The host will never actually ask for an updated `AEffect`
|
||||
// object since that should not be a thing. This is purely a
|
||||
// meant as a workaround for plugins that initialize their
|
||||
// `AEffect` object after the plugin has already finished
|
||||
// initializing.
|
||||
auto read_payload_fn = overload{
|
||||
[&](const std::nullptr_t&) -> void* { return nullptr; },
|
||||
[&](const std::string& s) -> void* {
|
||||
return const_cast<char*>(s.c_str());
|
||||
},
|
||||
[&](const std::vector<uint8_t>& buffer) -> void* {
|
||||
return const_cast<uint8_t*>(buffer.data());
|
||||
},
|
||||
[&](native_size_t& window_handle) -> void* {
|
||||
// This is the X11 window handle that the editor should reparent
|
||||
// itself to. We have a special wrapper around the dispatch function
|
||||
// that intercepts `effEditOpen` events and creates a Win32 window
|
||||
// and then finally embeds the X11 window Wine created into this
|
||||
// wnidow handle. Make sure to convert the window ID first to
|
||||
// `size_t` in case this is the 32-bit host.
|
||||
return reinterpret_cast<void*>(static_cast<size_t>(window_handle));
|
||||
},
|
||||
[&](const AEffect&) -> void* { return nullptr; },
|
||||
[&](DynamicVstEvents& events) -> void* {
|
||||
return &events.as_c_events();
|
||||
},
|
||||
[&](DynamicSpeakerArrangement& speaker_arrangement) -> void* {
|
||||
return &speaker_arrangement.as_c_speaker_arrangement();
|
||||
},
|
||||
[&](WantsAEffectUpdate&) -> void* {
|
||||
// The host will never actually ask for an updated `AEffect` object
|
||||
// since that should not be a thing. This is purely a meant as a
|
||||
// workaround for plugins that initialize their `AEffect` object
|
||||
// after the plugin has already finished initializing.
|
||||
return nullptr;
|
||||
},
|
||||
[&](WantsChunkBuffer&) -> void* { return string_buffer.data(); },
|
||||
[&](VstIOProperties& props) -> void* { return &props; },
|
||||
[&](VstMidiKeyName& key_name) -> void* { return &key_name; },
|
||||
[&](VstParameterProperties& props) -> void* { return &props; },
|
||||
[&](WantsVstRect&) -> void* { return string_buffer.data(); },
|
||||
[&](const WantsVstTimeInfo&) -> void* { return nullptr; },
|
||||
[&](WantsString&) -> void* { return string_buffer.data(); }};
|
||||
|
||||
// Almost all events pass data through the `data` argument. There are two
|
||||
// events, `effSetParameter` and `effGetParameter` that also pass data
|
||||
// through the value argument.
|
||||
void* data = std::visit(read_payload_fn, event.payload);
|
||||
intptr_t value = event.value;
|
||||
if (event.value_payload) {
|
||||
value = reinterpret_cast<intptr_t>(
|
||||
std::visit(read_payload_fn, *event.value_payload));
|
||||
}
|
||||
|
||||
const intptr_t return_value =
|
||||
callback(plugin, event.opcode, event.index, value, data, event.option);
|
||||
|
||||
// Only write back data when needed, this depends on the event payload type
|
||||
auto write_payload_fn = overload{
|
||||
[&](auto) -> EventResultPayload { return nullptr; },
|
||||
[&](const AEffect& updated_plugin) -> EventResultPayload {
|
||||
// This is a bit of a special case! Instead of writing some
|
||||
// return value, we will update values on the native VST
|
||||
// plugin's `AEffect` object. This is triggered by the
|
||||
// `audioMasterIOChanged` callback from the hosted VST plugin.
|
||||
update_aeffect(*plugin, updated_plugin);
|
||||
|
||||
return nullptr;
|
||||
},
|
||||
[&](DynamicSpeakerArrangement& speaker_arrangement)
|
||||
-> EventResultPayload { return speaker_arrangement; },
|
||||
[&](WantsChunkBuffer&) -> EventResultPayload {
|
||||
// In this case the plugin will have written its data stored in
|
||||
// an array to which a pointer is stored in `data`, with the
|
||||
// return value from the event determines how much data the
|
||||
// plugin has written
|
||||
const uint8_t* chunk_data = *static_cast<uint8_t**>(data);
|
||||
return std::vector<uint8_t>(chunk_data, chunk_data + return_value);
|
||||
},
|
||||
[&](VstIOProperties& props) -> EventResultPayload { return props; },
|
||||
[&](VstMidiKeyName& key_name) -> EventResultPayload {
|
||||
return key_name;
|
||||
},
|
||||
[&](VstParameterProperties& props) -> EventResultPayload {
|
||||
return props;
|
||||
},
|
||||
[&](WantsAEffectUpdate&) -> EventResultPayload { return *plugin; },
|
||||
[&](WantsVstRect&) -> EventResultPayload {
|
||||
// The plugin should have written a pointer to a VstRect struct into
|
||||
// the data pointer. I haven't seen this fail yet, but since some
|
||||
// hosts will call `effEditGetRect()` before `effEditOpen()` I can
|
||||
// assume there are plugins that don't handle this correctly.
|
||||
VstRect* editor_rect = *static_cast<VstRect**>(data);
|
||||
if (!editor_rect) {
|
||||
return nullptr;
|
||||
},
|
||||
[&](WantsChunkBuffer&) -> void* { return string_buffer.data(); },
|
||||
[&](VstIOProperties& props) -> void* { return &props; },
|
||||
[&](VstMidiKeyName& key_name) -> void* { return &key_name; },
|
||||
[&](VstParameterProperties& props) -> void* { return &props; },
|
||||
[&](WantsVstRect&) -> void* { return string_buffer.data(); },
|
||||
[&](const WantsVstTimeInfo&) -> void* { return nullptr; },
|
||||
[&](WantsString&) -> void* { return string_buffer.data(); }};
|
||||
|
||||
// Almost all events pass data through the `data` argument. There are
|
||||
// two events, `effSetParameter` and `effGetParameter` that also pass
|
||||
// data through the value argument.
|
||||
void* data = std::visit(read_payload_fn, event.payload);
|
||||
intptr_t value = event.value;
|
||||
if (event.value_payload) {
|
||||
value = reinterpret_cast<intptr_t>(
|
||||
std::visit(read_payload_fn, *event.value_payload));
|
||||
}
|
||||
|
||||
const intptr_t return_value = callback(
|
||||
plugin, event.opcode, event.index, value, data, event.option);
|
||||
|
||||
// Only write back data when needed, this depends on the event payload
|
||||
// type
|
||||
auto write_payload_fn = overload{
|
||||
[&](auto) -> EventResultPayload { return nullptr; },
|
||||
[&](const AEffect& updated_plugin) -> EventResultPayload {
|
||||
// This is a bit of a special case! Instead of writing some
|
||||
// return value, we will update values on the native VST
|
||||
// plugin's `AEffect` object. This is triggered by the
|
||||
// `audioMasterIOChanged` callback from the hosted VST plugin.
|
||||
update_aeffect(*plugin, updated_plugin);
|
||||
}
|
||||
|
||||
return *editor_rect;
|
||||
},
|
||||
[&](WantsVstTimeInfo&) -> EventResultPayload {
|
||||
// Not sure why the VST API has twenty different ways of returning
|
||||
// structs, but in this case the value returned from the callback
|
||||
// function is actually a pointer to a `VstTimeInfo` struct! It can
|
||||
// also be a null pointer if the host doesn't support this.
|
||||
const auto time_info =
|
||||
reinterpret_cast<const VstTimeInfo*>(return_value);
|
||||
if (!time_info) {
|
||||
return nullptr;
|
||||
},
|
||||
[&](DynamicSpeakerArrangement& speaker_arrangement)
|
||||
-> EventResultPayload { return speaker_arrangement; },
|
||||
[&](WantsChunkBuffer&) -> EventResultPayload {
|
||||
// In this case the plugin will have written its data stored in
|
||||
// an array to which a pointer is stored in `data`, with the
|
||||
// return value from the event determines how much data the
|
||||
// plugin has written
|
||||
const uint8_t* chunk_data = *static_cast<uint8_t**>(data);
|
||||
return std::vector<uint8_t>(chunk_data,
|
||||
chunk_data + return_value);
|
||||
},
|
||||
[&](VstIOProperties& props) -> EventResultPayload { return props; },
|
||||
[&](VstMidiKeyName& key_name) -> EventResultPayload {
|
||||
return key_name;
|
||||
},
|
||||
[&](VstParameterProperties& props) -> EventResultPayload {
|
||||
return props;
|
||||
},
|
||||
[&](WantsAEffectUpdate&) -> EventResultPayload { return *plugin; },
|
||||
[&](WantsVstRect&) -> EventResultPayload {
|
||||
// The plugin should have written a pointer to a VstRect struct
|
||||
// into the data pointer. I haven't seen this fail yet, but
|
||||
// since some hosts will call `effEditGetRect()` before
|
||||
// `effEditOpen()` I can assume there are plugins that don't
|
||||
// handle this correctly.
|
||||
VstRect* editor_rect = *static_cast<VstRect**>(data);
|
||||
if (!editor_rect) {
|
||||
return nullptr;
|
||||
}
|
||||
} else {
|
||||
return *time_info;
|
||||
}
|
||||
},
|
||||
[&](WantsString&) -> EventResultPayload {
|
||||
return std::string(static_cast<char*>(data));
|
||||
}};
|
||||
|
||||
return *editor_rect;
|
||||
},
|
||||
[&](WantsVstTimeInfo&) -> EventResultPayload {
|
||||
// Not sure why the VST API has twenty different ways of
|
||||
// returning structs, but in this case the value returned from
|
||||
// the callback function is actually a pointer to a
|
||||
// `VstTimeInfo` struct! It can also be a null pointer if the
|
||||
// host doesn't support this.
|
||||
const auto time_info =
|
||||
reinterpret_cast<const VstTimeInfo*>(return_value);
|
||||
if (!time_info) {
|
||||
return nullptr;
|
||||
} else {
|
||||
return *time_info;
|
||||
}
|
||||
},
|
||||
[&](WantsString&) -> EventResultPayload {
|
||||
return std::string(static_cast<char*>(data));
|
||||
}};
|
||||
// As mentioned about, the `effSetSpeakerArrangement` and
|
||||
// `effGetSpeakerArrangement` events are the only two events that use the
|
||||
// value argument as a pointer to write data to. Additionally, the
|
||||
// `effGetSpeakerArrangement` expects the plugin to write its own data to
|
||||
// this value. Hence why we need to encode the response here separately.
|
||||
const EventResultPayload response_data =
|
||||
std::visit(write_payload_fn, event.payload);
|
||||
std::optional<EventResultPayload> value_response_data = std::nullopt;
|
||||
if (event.value_payload) {
|
||||
value_response_data =
|
||||
std::visit(write_payload_fn, *event.value_payload);
|
||||
}
|
||||
|
||||
// As mentioned about, the `effSetSpeakerArrangement` and
|
||||
// `effGetSpeakerArrangement` events are the only two events that use
|
||||
// the value argument as a pointer to write data to. Additionally, the
|
||||
// `effGetSpeakerArrangement` expects the plugin to write its own data
|
||||
// to this value. Hence why we need to encode the response here
|
||||
// separately.
|
||||
const EventResultPayload response_data =
|
||||
std::visit(write_payload_fn, event.payload);
|
||||
std::optional<EventResultPayload> value_response_data = std::nullopt;
|
||||
if (event.value_payload) {
|
||||
value_response_data =
|
||||
std::visit(write_payload_fn, *event.value_payload);
|
||||
}
|
||||
EventResult response{.return_value = return_value,
|
||||
.payload = response_data,
|
||||
.value_payload = value_response_data};
|
||||
|
||||
EventResult response{.return_value = return_value,
|
||||
.payload = response_data,
|
||||
.value_payload = value_response_data};
|
||||
|
||||
return response;
|
||||
};
|
||||
return response;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user