Fix thread local audio thread buffers

For CLAP and VST3, as mentioned in the last commit's changelog update.

src/common/communication/clap.h

@@ -295,8 +295,9 @@ class ClapSockets final : public Sockets {
         const T& object,
         std::optional<std::pair<ClapLogger&, bool>> logging) {
         typename T::Response response_object;
-        return receive_audio_thread_control_message_into(
+        return audio_thread_sockets_.at(object.instance_id)
-            object, response_object, object.instance_id, logging);
+            .control_.receive_into(object, response_object, logging,
+                                   audio_thread_buffer());
     }
 
     /**
@@ -308,8 +309,9 @@ class ClapSockets final : public Sockets {
         const MessageReference<T>& object_ref,
         std::optional<std::pair<ClapLogger&, bool>> logging) {
         typename T::Response response_object;
-        return receive_audio_thread_control_message_into(
+        return audio_thread_sockets_.at(object_ref.get().instance_id)
-            object_ref, response_object, object_ref.get().instance_id, logging);
+            .control_.receive_into(object_ref, response_object, logging,
+                                   audio_thread_buffer());
     }
 
     /**
@@ -324,8 +326,9 @@ class ClapSockets final : public Sockets {
         const MessageReference<T>& request_ref,
         typename T::Response& response_ref,
         std::optional<std::pair<ClapLogger&, bool>> logging) {
-        return receive_audio_thread_control_message_into(
+        return audio_thread_sockets_.at(request_ref.get().instance_id)
-            request_ref, response_ref, request_ref.get().instance_id, logging);
+            .control_.receive_into(request_ref, response_ref, logging,
+                                   audio_thread_buffer());
     }
 
     /**
@@ -343,11 +346,9 @@ class ClapSockets final : public Sockets {
         const T& object,
         std::optional<std::pair<ClapLogger&, bool>> logging) {
         typename T::Response response_object;
-        thread_local SerializationBuffer<2048> audio_thread_buffer{};
-
         return audio_thread_sockets_.at(object.owner_instance_id)
             .callback_.receive_into(object, response_object, logging,
-                                    audio_thread_buffer);
+                                    audio_thread_buffer());
     }
 
     /**
@@ -371,21 +372,14 @@ class ClapSockets final : public Sockets {
 
    private:
     /**
-     * The actual implementation for `send_audio_thread_message` and
+     * Get the shared thread local serialization buffer for audio threads. This
-     * `receive_audio_thread_message_into`. Here we keep a thread local
+     * is defined here so the buffer can be shared regardless of which `T` is
-     * static variable for our buffers sending.
+     * being sent.
      */
-    template <typename T>
+    SerializationBufferBase& audio_thread_buffer() {
-    typename T::Response& receive_audio_thread_control_message_into(
+        thread_local SerializationBuffer<2048> audio_thread_buffer{};
-        const T& object,
-        typename T::Response& response_object,
-        size_t instance_id,
-        std::optional<std::pair<ClapLogger&, bool>> logging) {
-        thread_local SerializationBuffer<256> audio_thread_buffer{};
 
-        return audio_thread_sockets_.at(instance_id)
+        return audio_thread_buffer;
-            .control_.receive_into(object, response_object, logging,
-                                   audio_thread_buffer);
     }
 
     asio::io_context& io_context_;

src/common/communication/vst3.h

@@ -197,8 +197,9 @@ class Vst3Sockets final : public Sockets {
         const T& object,
         std::optional<std::pair<Vst3Logger&, bool>> logging) {
         typename T::Response response_object;
-        return receive_audio_processor_message_into(
+        return audio_processor_sockets_.at(object.instance_id)
-            object, response_object, object.instance_id, logging);
+            .receive_into(object, response_object, logging,
+                          audio_processor_buffer());
     }
 
     /**
@@ -210,8 +211,9 @@ class Vst3Sockets final : public Sockets {
         const MessageReference<T>& object_ref,
         std::optional<std::pair<Vst3Logger&, bool>> logging) {
         typename T::Response response_object;
-        return receive_audio_processor_message_into(
+        return audio_processor_sockets_.at(object_ref.get().instance_id)
-            object_ref, response_object, object_ref.get().instance_id, logging);
+            .receive_into(object_ref, response_object, logging,
+                          audio_processor_buffer());
     }
 
     /**
@@ -226,8 +228,9 @@ class Vst3Sockets final : public Sockets {
         const MessageReference<T>& request_ref,
         typename T::Response& response_ref,
         std::optional<std::pair<Vst3Logger&, bool>> logging) {
-        return receive_audio_processor_message_into(
+        return audio_processor_sockets_.at(request_ref.get().instance_id)
-            request_ref, response_ref, request_ref.get().instance_id, logging);
+            .receive_into(request_ref, response_ref, logging,
+                          audio_processor_buffer());
     }
 
     /**
@@ -253,21 +256,14 @@ class Vst3Sockets final : public Sockets {
 
    private:
     /**
-     * The actual implementation for `send_audio_processor_message` and
+     * Get the shared thread local serialization buffer for audio processors.
-     * `receive_audio_processor_message_into`. Here we keep a thread local
+     * This is defined here so the buffer can be shared regardless of which `T`
-     * static variable for our buffers sending.
+     * is being sent.
      */
-    template <typename T>
+    SerializationBufferBase& audio_processor_buffer() {
-    typename T::Response& receive_audio_processor_message_into(
-        const T& object,
-        typename T::Response& response_object,
-        size_t instance_id,
-        std::optional<std::pair<Vst3Logger&, bool>> logging) {
         thread_local SerializationBuffer<2048> audio_processor_buffer{};
 
-        return audio_processor_sockets_.at(instance_id)
+        return audio_processor_buffer;
-            .receive_into(object, response_object, logging,
-                          audio_processor_buffer);
     }
 
     asio::io_context& io_context_;