Fully implement INoteExpressionCOntroller

src/common/serialization/vst3.h

@@ -62,7 +62,8 @@ struct WantsConfiguration {
  * encodes the information we request or the operation we want to perform. A
  * request of type `ControlRequest(T)` should send back a `T::Response`.
  */
-using ControlRequest = std::variant<Vst3PlugViewProxy::Destruct,
+using ControlRequest =
+    std::variant<Vst3PlugViewProxy::Destruct,
                  Vst3PluginProxy::Construct,
                  Vst3PluginProxy::Destruct,
                  Vst3PluginProxy::SetState,
@@ -84,6 +85,10 @@ using ControlRequest = std::variant<Vst3PlugViewProxy::Destruct,
                  YaEditController2::SetKnobMode,
                  YaEditController2::OpenHelp,
                  YaEditController2::OpenAboutBox,
+                 YaNoteExpressionController::GetNoteExpressionCount,
+                 YaNoteExpressionController::GetNoteExpressionInfo,
+                 YaNoteExpressionController::GetNoteExpressionStringByValue,
+                 YaNoteExpressionController::GetNoteExpressionValueByString,
                  YaPlugView::IsPlatformTypeSupported,
                  YaPlugView::Attached,
                  YaPlugView::Removed,

src/common/serialization/vst3/plugin/note-expression-controller.h

@@ -117,7 +117,7 @@ class YaNoteExpressionController
 
         int32 bus_index;
         int16 channel;
-        int16 note_expression_index;
+        int32 note_expression_index;
 
         template <typename S>
         void serialize(S& s) {

src/plugin/bridges/vst3-impls/plugin-proxy.cpp

@@ -415,10 +415,11 @@ tresult PLUGIN_API Vst3PluginProxyImpl::openAboutBox(TBool onlyCheck) {
 
 int32 PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionCount(int32 busIndex,
                                                              int16 channel) {
-    // TODO: Implement
+    return bridge.send_message(
-    bridge.logger.log(
+        YaNoteExpressionController::GetNoteExpressionCount{
-        "TODO: Implement INoteExpressionCOntroller::getNoteExpressionCount()");
+            .instance_id = instance_id(),
-    return Steinberg::kNotImplemented;
+            .bus_index = busIndex,
+            .channel = channel});
 }
 
 tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionInfo(
@@ -426,10 +427,16 @@ tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionInfo(
     int16 channel,
     int32 noteExpressionIndex,
     Steinberg::Vst::NoteExpressionTypeInfo& info /*out*/) {
-    // TODO: Implement
+    const GetNoteExpressionInfoResponse response =
-    bridge.logger.log(
+        bridge.send_message(YaNoteExpressionController::GetNoteExpressionInfo{
-        "TODO: Implement INoteExpressionCOntroller::getNoteExpressionInfo()");
+            .instance_id = instance_id(),
-    return Steinberg::kNotImplemented;
+            .bus_index = busIndex,
+            .channel = channel,
+            .note_expression_index = noteExpressionIndex});
+
+    info = response.info;
+
+    return response.result;
 }
 
 tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionStringByValue(
@@ -438,11 +445,18 @@ tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionStringByValue(
     Steinberg::Vst::NoteExpressionTypeID id,
     Steinberg::Vst::NoteExpressionValue valueNormalized /*in*/,
     Steinberg::Vst::String128 string /*out*/) {
-    // TODO: Implement
+    const GetNoteExpressionStringByValueResponse response = bridge.send_message(
-    bridge.logger.log(
+        YaNoteExpressionController::GetNoteExpressionStringByValue{
-        "TODO: Implement "
+            .instance_id = instance_id(),
-        "INoteExpressionCOntroller::getNoteExpressionStringByValue()");
+            .bus_index = busIndex,
-    return Steinberg::kNotImplemented;
+            .channel = channel,
+            .id = id,
+            .value_normalized = valueNormalized});
+
+    std::copy(response.string.begin(), response.string.end(), string);
+    string[response.string.size()] = 0;
+
+    return response.result;
 }
 
 tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionValueByString(
@@ -451,11 +465,17 @@ tresult PLUGIN_API Vst3PluginProxyImpl::getNoteExpressionValueByString(
     Steinberg::Vst::NoteExpressionTypeID id,
     const Steinberg::Vst::TChar* string /*in*/,
     Steinberg::Vst::NoteExpressionValue& valueNormalized /*out*/) {
-    // TODO: Implement
+    const GetNoteExpressionValueByStringResponse response = bridge.send_message(
-    bridge.logger.log(
+        YaNoteExpressionController::GetNoteExpressionValueByString{
-        "TODO: Implement "
+            .instance_id = instance_id(),
-        "INoteExpressionCOntroller::getNoteExpressionValueByString()");
+            .bus_index = busIndex,
-    return Steinberg::kNotImplemented;
+            .channel = channel,
+            .id = id,
+            .string = string});
+
+    valueNormalized = response.value_normalized;
+
+    return response.result;
 }
 
 tresult PLUGIN_API Vst3PluginProxyImpl::initialize(FUnknown* context) {

src/wine-host/bridges/vst3.cpp

@@ -370,6 +370,65 @@ void Vst3Bridge::run() {
                 return object_instances[request.instance_id]
                     .edit_controller_2->openAboutBox(request.only_check);
             },
+            [&](const YaNoteExpressionController::GetNoteExpressionCount&
+                    request)
+                -> YaNoteExpressionController::GetNoteExpressionCount::
+                    Response {
+                        return object_instances[request.instance_id]
+                            .note_expression_controller->getNoteExpressionCount(
+                                request.bus_index, request.channel);
+                    },
+            [&](const YaNoteExpressionController::GetNoteExpressionInfo&
+                    request)
+                -> YaNoteExpressionController::GetNoteExpressionInfo::Response {
+                Steinberg::Vst::NoteExpressionTypeInfo info{};
+                const tresult result =
+                    object_instances[request.instance_id]
+                        .note_expression_controller->getNoteExpressionInfo(
+                            request.bus_index, request.channel,
+                            request.note_expression_index, info);
+
+                return YaNoteExpressionController::
+                    GetNoteExpressionInfoResponse{.result = result,
+                                                  .info = std::move(info)};
+            },
+            [&](const YaNoteExpressionController::
+                    GetNoteExpressionStringByValue& request)
+                -> YaNoteExpressionController::GetNoteExpressionStringByValue::
+                    Response {
+                        Steinberg::Vst::String128 string{0};
+                        const tresult result =
+                            object_instances[request.instance_id]
+                                .note_expression_controller
+                                ->getNoteExpressionStringByValue(
+                                    request.bus_index, request.channel,
+                                    request.id, request.value_normalized,
+                                    string);
+
+                        return YaNoteExpressionController::
+                            GetNoteExpressionStringByValueResponse{
+                                .result = result,
+                                .string = tchar_pointer_to_u16string(string)};
+                    },
+            [&](const YaNoteExpressionController::
+                    GetNoteExpressionValueByString& request)
+                -> YaNoteExpressionController::GetNoteExpressionValueByString::
+                    Response {
+                        Steinberg::Vst::NoteExpressionValue value_normalized;
+                        const tresult result =
+                            object_instances[request.instance_id]
+                                .note_expression_controller
+                                ->getNoteExpressionValueByString(
+                                    request.bus_index, request.channel,
+                                    request.id,
+                                    u16string_to_tchar_pointer(request.string),
+                                    value_normalized);
+
+                        return YaNoteExpressionController::
+                            GetNoteExpressionValueByStringResponse{
+                                .result = result,
+                                .value_normalized = value_normalized};
+                    },
             [&](const YaPlugView::IsPlatformTypeSupported& request)
                 -> YaPlugView::IsPlatformTypeSupported::Response {
                 // The host will of course want to pass an X11 window ID for the
@@ -831,7 +890,7 @@ size_t Vst3Bridge::register_object_instance(
                     },
                     [&](const YaComponent::GetControllerClassId& request)
                         -> YaComponent::GetControllerClassId::Response {
-                        Steinberg::TUID cid;
+                        Steinberg::TUID cid{0};
                         const tresult result =
                             object_instances[request.instance_id]
                                 .component->getControllerClassId(cid);