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

Add messages for creating plugin instances

Browse Source
This commit is contained in:
Robbert van der Helm
2022-09-08 00:10:20 +02:00
parent 8c5fb448de
commit e74c25445d
2 changed files with 45 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/common/serialization/clap/README.md
-6
View File
@@ -12,12 +12,6 @@ Yabridge currently tracks CLAP 1.1.1. The implementation status for CLAP's core
| `clap.plugin-factory` | :heavy_check_mark: |
| `clap.plugin-invalidation-factory/draft0` | :x: Not supported yet |
| extension | status |
| ----------------------------------------- | --------------------- |
| Core plugin and host functionality | :x: Work in progress |
| `clap.plugin-factory` | :x: Work in progress |
| `clap.plugin-invalidation-factory/draft0` | :x: Not supported yet |
| extension | status |
| ------------------------- | --------------------- |
| `clap.audio-ports` | :x: Not supported yet |
src/common/serialization/clap/plugin-factory.h
+45 -239
View File
@@ -16,6 +16,8 @@
#pragma once
#include "../common.h"
#include "host.h"
#include "plugin.h"
// Serialization messages for `clap/plugin-factory.h`
@@ -24,7 +26,7 @@ namespace clap {
namespace plugin_factory {
/**
* The response to the `clap::plugin_factory::list` message defined below.
* The response to the `clap::plugin_factory::List` message defined below.
*/
struct ListResponse {
/**
@@ -54,243 +56,47 @@ struct List {
void serialize(S&) {}
};
/**
* The response to the `clap::plugin_factory::Create` message defined below.
*/
struct CreateResponse {
/**
* The new plugin instance's ID, if it was initialized correctly. We'll
* assume the instance's plugin descriptor is the same as the one from the
* factory.
*/
std::optional<native_size_t> instance_id;
template <typename S>
void serialize(S& s) {
s.ext(instance_id, bitsery::ext::InPlaceOptional{},
[](S& s, auto& v) { s.value8b(v); });
}
};
/**
* Message struct for `clap_plugin_factory::create()`. Contains information
* about the host for the `clap_host_t*`. If the plugin instance was created
* successfully, then the Wine host side will generate a unique identifier for
* the instance that is used to refer to it in further messages.
*/
struct Create {
using Response = CreateResponse;
/**
* Information about the native host that can be used to construct a
* `clap_host_t*` proxy.
*/
clap::host::Host host;
std::string plugin_id;
template <typename S>
void serialize(S& s) {
s.object(host);
s.text1b(plugin_id, 4096);
}
};
} // namespace plugin_factory
} // namespace clap
// #include <bitsery/traits/string.h>
// #include <pluginterfaces/base/ipluginbase.h>
// #include "../../../bitsery/ext/in-place-optional.h"
// #include "../base.h"
// #include "../host-context-proxy.h"
// #pragma GCC diagnostic push
// #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
// /**
// * Wraps around `IPluginFactory{1,2,3}` for serialization purposes. This is
// * instantiated as part of `Vst3PluginFactoryProxy`.
// */
// class YaPluginFactory3 : public Steinberg::IPluginFactory3 {
// public:
// /**
// * These are the arguments for creating a `YaPluginFactory3`. All class
// * infos in all available formats are read from the plugin so the host
// can
// * query them.
// */
// struct ConstructArgs {
// ConstructArgs() noexcept;
// /**
// * Check whether an existing implementation implements
// * `IPluginFactory1`, `IPluginFactory2`, and ``IPluginFactory3`` and
// * read arguments from it.
// */
// ConstructArgs(Steinberg::IPtr<Steinberg::FUnknown> object);
// /**
// * Whether the object supported `IPluginFactory`.
// */
// bool supports_plugin_factory = false;
// /**
// * Whether the object supported `IPluginFactory2`.
// */
// bool supports_plugin_factory_2 = false;
// /**
// * Whether the object supported `IPluginFactory3`.
// */
// bool supports_plugin_factory_3 = false;
// /**
// * For `IPluginFactory::getFactoryInfo`.
// */
// std::optional<Steinberg::PFactoryInfo> factory_info;
// /**
// * For `IPluginFactory::countClasses`.
// */
// int num_classes;
// /**
// * For `IPluginFactory::getClassInfo`. We need to store all four
// class
// * info versions if the plugin can provide them since we don't know
// * which version of the interface the host will use. Will be
// * `std::nullopt` if the plugin doesn't return a class info.
// *
// * NOTE: We'll have already converted all returned class IDs to
// native
// * class IDs using `WineUID::to_native_uid()` for
// cross-platform
// * compatibility. This applies to all `class_info_*` fields
// here.
// */
// std::vector<std::optional<Steinberg::PClassInfo>> class_infos_1;
// /**
// * For `IPluginFactory2::getClassInfo2`, works the same way as the
// * above.
// */
// std::vector<std::optional<Steinberg::PClassInfo2>> class_infos_2;
// /**
// * For `IPluginFactory3::getClassInfoUnicode`, works the same way as
// the
// * above.
// */
// std::vector<std::optional<Steinberg::PClassInfoW>>
// class_infos_unicode;
// template <typename S>
// void serialize(S& s) {
// s.value1b(supports_plugin_factory);
// s.value1b(supports_plugin_factory_2);
// s.value1b(supports_plugin_factory_3);
// s.ext(factory_info, bitsery::ext::InPlaceOptional{});
// s.value4b(num_classes);
// s.container(class_infos_1, 2048,
// [](S& s, std::optional<Steinberg::PClassInfo>& info)
// {
// s.ext(info, bitsery::ext::InPlaceOptional{});
// });
// s.container(class_infos_2, 2048,
// [](S& s, std::optional<Steinberg::PClassInfo2>& info)
// {
// s.ext(info, bitsery::ext::InPlaceOptional{});
// });
// s.container(class_infos_unicode, 2048,
// [](S& s, std::optional<Steinberg::PClassInfoW>& info)
// {
// s.ext(info, bitsery::ext::InPlaceOptional{});
// });
// }
// };
// /**
// * Instantiate this instance with arguments read from the Windows VST3
// * plugin's plugin factory.
// */
// YaPluginFactory3(ConstructArgs&& args) noexcept;
// virtual ~YaPluginFactory3() noexcept = default;
// inline bool supports_plugin_factory() const noexcept {
// return arguments_.supports_plugin_factory;
// }
// inline bool supports_plugin_factory_2() const noexcept {
// return arguments_.supports_plugin_factory_2;
// }
// inline bool supports_plugin_factory_3() const noexcept {
// return arguments_.supports_plugin_factory_3;
// }
// // All of these functiosn returning class information are fetched once on
// // the Wine side since they'll be static so we can just copy over the
// // responses
// // From `IPluginFactory`
// tresult PLUGIN_API getFactoryInfo(Steinberg::PFactoryInfo* info)
// override; int32 PLUGIN_API countClasses() override; tresult PLUGIN_API
// getClassInfo(Steinberg::int32 index,
// Steinberg::PClassInfo* info) override;
// /**
// * See the implementation in `Vst3PluginFactoryProxyImpl` for how this is
// * handled. We'll create new managed `Vst3PluginProxy` objects from here.
// */
// virtual tresult PLUGIN_API createInstance(Steinberg::FIDString cid,
// Steinberg::FIDString _iid,
// void** obj) override = 0;
// // From `IPluginFactory2`
// tresult PLUGIN_API getClassInfo2(int32 index,
// Steinberg::PClassInfo2* info) override;
// // From `IPluginFactory3`
// tresult PLUGIN_API
// getClassInfoUnicode(int32 index, Steinberg::PClassInfoW* info) override;
// /**
// * Message to pass through a call to `IPluginFactory3::setHostContext()`
// to
// * the Wine plugin host. A `Vst3HostContextProxy` should be created on
// the
// * Wine plugin host and then passed as an argument to
// * `IPluginFactory3::setHostContext()`.
// */
// struct SetHostContext {
// using Response = UniversalTResult;
// Vst3HostContextProxy::ConstructArgs host_context_args;
// template <typename S>
// void serialize(S& s) {
// s.object(host_context_args);
// }
// };
// virtual tresult PLUGIN_API
// setHostContext(Steinberg::FUnknown* context) override = 0;
// protected:
// ConstructArgs arguments_;
// };
// #pragma GCC diagnostic pop
// // Serialization functions have to live in the same namespace as the objects
// // they're serializing
// namespace Steinberg {
// template <typename S>
// void serialize(S& s, PClassInfo& class_info) {
// s.container1b(class_info.cid);
// s.value4b(class_info.cardinality);
// s.text1b(class_info.category);
// s.text1b(class_info.name);
// }
// template <typename S>
// void serialize(S& s, PClassInfo2& class_info) {
// s.container1b(class_info.cid);
// s.value4b(class_info.cardinality);
// s.text1b(class_info.category);
// s.text1b(class_info.name);
// s.value4b(class_info.classFlags);
// s.text1b(class_info.subCategories);
// s.text1b(class_info.vendor);
// s.text1b(class_info.version);
// s.text1b(class_info.sdkVersion);
// }
// template <typename S>
// void serialize(S& s, PClassInfoW& class_info) {
// s.container1b(class_info.cid);
// s.value4b(class_info.cardinality);
// s.text1b(class_info.category);
// // FIXME: Bitsery uses `std::char_traits<wchar_t>::length()` under the hood
// // for `text2b()` on the Wine side, and under winegcc this function
// // this length is incorrect. As a workaround we're just serializing
// // the entire container. This applies to every place where we use
// // `container2b()` to serialize a `String128`, so if we end up fixing
// // this we should replace all of the instances of `container2b()`
// // that serialize a `String128`.
// s.container2b(class_info.name);
// s.value4b(class_info.classFlags);
// s.text1b(class_info.subCategories);
// s.container2b(class_info.vendor);
// s.container2b(class_info.version);
// s.container2b(class_info.sdkVersion);
// }
// template <typename S>
// void serialize(S& s, PFactoryInfo& factory_info) {
// s.text1b(factory_info.vendor);
// s.text1b(factory_info.url);
// s.text1b(factory_info.email);
// s.value4b(factory_info.flags);
// }
// } // namespace Steinberg