comparison vamp-json/VampJson.h @ 97:427c4c725085

Bring in the Request/Response classes that were in the Vamp SDK, adding them to vamp-support in here instead

 #include <json11/json11.hpp>
 #include <base-n/include/basen.hpp>
 
 #include <vamp-hostsdk/Plugin.h>
 #include <vamp-hostsdk/PluginLoader.h>
-#include <vamp-hostsdk/PluginStaticData.h>
-#include <vamp-hostsdk/PluginConfiguration.h>
-#include <vamp-hostsdk/RequestResponse.h>
+
+#include "vamp-support/PluginStaticData.h"
+#include "vamp-support/PluginConfiguration.h"
+#include "vamp-support/RequestResponse.h"
 
 #include "vamp-support/PluginHandleMapper.h"
 #include "vamp-support/PluginOutputIdMapper.h"
 #include "vamp-support/RequestResponseType.h"
 
-namespace piper {
+namespace piper_vamp {
 
 /**
  * Convert the structures laid out in the Vamp SDK classes into JSON
  * (and back again) following the schema in the vamp-json-schema
  * project repo.

             return {};
         }
     }
 
     static json11::Json
-    fromPluginStaticData(const Vamp::HostExt::PluginStaticData &d) {
+    fromPluginStaticData(const PluginStaticData &d) {
 
         json11::Json::object jo;
         jo["key"] = d.pluginKey;
         jo["basic"] = fromBasicDescriptor(d.basic);
         jo["maker"] = d.maker;

         jo["basicOutputInfo"] = outinfo;
     
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::PluginStaticData
+    static PluginStaticData
     toPluginStaticData(json11::Json j, std::string &err) {
 
         if (!j.has_shape({
                     { "key", json11::Json::STRING },
                     { "version", json11::Json::NUMBER },

             
             err = "array expected for basicOutputInfo";
 
         } else {
 
-            Vamp::HostExt::PluginStaticData psd;
+            PluginStaticData psd;
 
             psd.pluginKey = j["key"].string_value();
 
             toBasicDescriptor(j["basic"], psd.basic, err);
             if (failed(err)) return {};

 
             psd.inputDomain = toInputDomain(j["inputDomain"].string_value(), err);
             if (failed(err)) return {};
 
             for (const auto &bo : j["basicOutputInfo"].array_items()) {
-                Vamp::HostExt::PluginStaticData::Basic b;
+                PluginStaticData::Basic b;
                 toBasicDescriptor(bo, b, err);
                 if (failed(err)) return {};
                 psd.basicOutputInfo.push_back(b);
             }
             

         // fallthrough error case
         return {};
     }
 
     static json11::Json
-    fromPluginConfiguration(const Vamp::HostExt::PluginConfiguration &c) {
+    fromPluginConfiguration(const PluginConfiguration &c) {
 
         json11::Json::object jo;
 
         json11::Json::object paramValues;
         for (auto &vp: c.parameterValues) {

         jo["blockSize"] = c.blockSize;
     
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::PluginConfiguration
+    static PluginConfiguration
     toPluginConfiguration(json11::Json j, std::string &err) {
         
         if (!j.has_shape({
                     { "channelCount", json11::Json::NUMBER },
                     { "stepSize", json11::Json::NUMBER },

             !j["currentProgram"].is_string()) {
             err = "string expected for program name";
             return {};
         }
 
-        Vamp::HostExt::PluginConfiguration config;
+        PluginConfiguration config;
 
         config.channelCount = j["channelCount"].number_value();
         config.stepSize = j["stepSize"].number_value();
         config.blockSize = j["blockSize"].number_value();
         

 
         return Vamp::HostExt::PluginLoader::AdapterFlags(flags);
     }
 
     static json11::Json
-    fromLoadRequest(const Vamp::HostExt::LoadRequest &req) {
+    fromLoadRequest(const LoadRequest &req) {
 
         json11::Json::object jo;
         jo["key"] = req.pluginKey;
         jo["inputSampleRate"] = req.inputSampleRate;
         jo["adapterFlags"] = fromAdapterFlags(req.adapterFlags);
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::LoadRequest
+    static LoadRequest
     toLoadRequest(json11::Json j, std::string &err) {
         
         if (!j.has_shape({
                     { "key", json11::Json::STRING },
                     { "inputSampleRate", json11::Json::NUMBER } }, err)) {
             err = "malformed load request: " + err;
             return {};
         }
     
-        Vamp::HostExt::LoadRequest req;
+        LoadRequest req;
         req.pluginKey = j["key"].string_value();
         req.inputSampleRate = j["inputSampleRate"].number_value();
         if (!j["adapterFlags"].is_null()) {
             req.adapterFlags = toAdapterFlags(j["adapterFlags"], err);
             if (failed(err)) return {};
         }
         return req;
     }
 
     static json11::Json
-    fromLoadResponse(const Vamp::HostExt::LoadResponse &resp,
+    fromLoadResponse(const LoadResponse &resp,
                      const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
         jo["handle"] = double(pmapper.pluginToHandle(resp.plugin));
         jo["staticData"] = fromPluginStaticData(resp.staticData);
         jo["defaultConfiguration"] =
             fromPluginConfiguration(resp.defaultConfiguration);
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::LoadResponse
+    static LoadResponse
     toLoadResponse(json11::Json j,
                    const PluginHandleMapper &pmapper, std::string &err) {
 
         if (!j.has_shape({
                     { "handle", json11::Json::NUMBER },

                     { "defaultConfiguration", json11::Json::OBJECT } }, err)) {
             err = "malformed load response: " + err;
             return {};
         }
 
-        Vamp::HostExt::LoadResponse resp;
+        LoadResponse resp;
         resp.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         resp.staticData = toPluginStaticData(j["staticData"], err);
         if (failed(err)) return {};
         resp.defaultConfiguration = toPluginConfiguration(j["defaultConfiguration"],
                                                           err);
         if (failed(err)) return {};
         return resp;
     }
 
     static json11::Json
-    fromConfigurationRequest(const Vamp::HostExt::ConfigurationRequest &cr,
+    fromConfigurationRequest(const ConfigurationRequest &cr,
                              const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
 
         jo["handle"] = double(pmapper.pluginToHandle(cr.plugin));
         jo["configuration"] = fromPluginConfiguration(cr.configuration);
         
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::ConfigurationRequest
+    static ConfigurationRequest
     toConfigurationRequest(json11::Json j,
                            const PluginHandleMapper &pmapper, std::string &err) {
 
         if (!j.has_shape({
                     { "handle", json11::Json::NUMBER },
                     { "configuration", json11::Json::OBJECT } }, err)) {
             err = "malformed configuration request: " + err;
             return {};
         }
 
-        Vamp::HostExt::ConfigurationRequest cr;
+        ConfigurationRequest cr;
         cr.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         cr.configuration = toPluginConfiguration(j["configuration"], err);
         if (failed(err)) return {};
         return cr;
     }
 
     static json11::Json
-    fromConfigurationResponse(const Vamp::HostExt::ConfigurationResponse &cr,
+    fromConfigurationResponse(const ConfigurationResponse &cr,
                               const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
 
         jo["handle"] = double(pmapper.pluginToHandle(cr.plugin));

         jo["outputList"] = outs;
         
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::ConfigurationResponse
+    static ConfigurationResponse
     toConfigurationResponse(json11::Json j,
                             const PluginHandleMapper &pmapper, std::string &err) {
         
-        Vamp::HostExt::ConfigurationResponse cr;
+        ConfigurationResponse cr;
 
         cr.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         
         if (!j["outputList"].is_array()) {
             err = "array expected for output list";

 
         return cr;
     }
 
     static json11::Json
-    fromProcessRequest(const Vamp::HostExt::ProcessRequest &r,
+    fromProcessRequest(const ProcessRequest &r,
                        const PluginHandleMapper &pmapper,
                        BufferSerialisation serialisation) {
 
         json11::Json::object jo;
         jo["handle"] = double(pmapper.pluginToHandle(r.plugin));

         
         jo["processInput"] = io;
         return json11::Json(jo);
     }
 
-    static Vamp::HostExt::ProcessRequest
+    static ProcessRequest
     toProcessRequest(json11::Json j,
                      const PluginHandleMapper &pmapper,
                      BufferSerialisation &serialisation, std::string &err) {
 
         if (!j.has_shape({

                     { "inputBuffers", json11::Json::ARRAY } }, err)) {
             err = "malformed process request: " + err;
             return {};
         }
 
-        Vamp::HostExt::ProcessRequest r;
+        ProcessRequest r;
         r.plugin = pmapper.handleToPlugin(j["handle"].int_value());
 
         r.timestamp = toRealTime(input["timestamp"], err);
         if (failed(err)) return {};
 

         addId(jo, id);
         return json11::Json(jo);
     }
 
     static json11::Json
-    fromRpcResponse_List(const Vamp::HostExt::ListResponse &resp,
+    fromRpcResponse_List(const ListResponse &resp,
                          const json11::Json &id) {
 
         json11::Json::object jo;
         markRPC(jo);
 

         addId(jo, id);
         return json11::Json(jo);
     }
     
     static json11::Json
-    fromRpcRequest_Load(const Vamp::HostExt::LoadRequest &req,
+    fromRpcRequest_Load(const LoadRequest &req,
                         const json11::Json &id) {
 
         json11::Json::object jo;
         markRPC(jo);
 

         addId(jo, id);
         return json11::Json(jo);
     }    
 
     static json11::Json
-    fromRpcResponse_Load(const Vamp::HostExt::LoadResponse &resp,
+    fromRpcResponse_Load(const LoadResponse &resp,
                          const PluginHandleMapper &pmapper,
                          const json11::Json &id) {
 
         if (resp.plugin) {
 

             return fromError("Failed to load plugin", RRType::Load, id);
         }
     }
 
     static json11::Json
-    fromRpcRequest_Configure(const Vamp::HostExt::ConfigurationRequest &req,
+    fromRpcRequest_Configure(const ConfigurationRequest &req,
                              const PluginHandleMapper &pmapper,
                              const json11::Json &id) {
 
         json11::Json::object jo;
         markRPC(jo);

         addId(jo, id);
         return json11::Json(jo);
     }    
 
     static json11::Json
-    fromRpcResponse_Configure(const Vamp::HostExt::ConfigurationResponse &resp,
+    fromRpcResponse_Configure(const ConfigurationResponse &resp,
                               const PluginHandleMapper &pmapper,
                               const json11::Json &id) {
 
         if (!resp.outputs.empty()) {
         

             return fromError("Failed to configure plugin", RRType::Configure, id);
         }
     }
     
     static json11::Json
-    fromRpcRequest_Process(const Vamp::HostExt::ProcessRequest &req,
+    fromRpcRequest_Process(const ProcessRequest &req,
                            const PluginHandleMapper &pmapper,
                            BufferSerialisation serialisation,
                            const json11::Json &id) {
 
         json11::Json::object jo;

         addId(jo, id);
         return json11::Json(jo);
     }    
 
     static json11::Json
-    fromRpcResponse_Process(const Vamp::HostExt::ProcessResponse &resp,
+    fromRpcResponse_Process(const ProcessResponse &resp,
                             const PluginHandleMapper &pmapper,
                             BufferSerialisation serialisation,
                             const json11::Json &id) {
         
         json11::Json::object jo;

         addId(jo, id);
         return json11::Json(jo);
     }
     
     static json11::Json
-    fromRpcRequest_Finish(const Vamp::HostExt::FinishRequest &req,
+    fromRpcRequest_Finish(const FinishRequest &req,
                           const PluginHandleMapper &pmapper,
                           const json11::Json &id) {
 
         json11::Json::object jo;
         markRPC(jo);

         addId(jo, id);
         return json11::Json(jo);
     }    
     
     static json11::Json
-    fromRpcResponse_Finish(const Vamp::HostExt::ProcessResponse &resp,
+    fromRpcResponse_Finish(const FinishResponse &resp,
                            const PluginHandleMapper &pmapper,
                            BufferSerialisation serialisation,
                            const json11::Json &id) {
 
         json11::Json::object jo;

     static void
     toRpcRequest_List(json11::Json j, std::string &err) {
         checkTypeField(j, "list", err);
     }
 
-    static Vamp::HostExt::ListResponse
+    static ListResponse
     toRpcResponse_List(json11::Json j, std::string &err) {
 
-        Vamp::HostExt::ListResponse resp;
+        ListResponse resp;
         if (successful(j, err) && !failed(err)) {
             for (const auto &a: j["result"]["available"].array_items()) {
                 resp.available.push_back(toPluginStaticData(a, err));
                 if (failed(err)) return {};
             }
         }
         
         return resp;
     }
 
-    static Vamp::HostExt::LoadRequest
+    static LoadRequest
     toRpcRequest_Load(json11::Json j, std::string &err) {
         
         checkTypeField(j, "load", err);
         if (failed(err)) return {};
         return toLoadRequest(j["params"], err);
     }
     
-    static Vamp::HostExt::LoadResponse
+    static LoadResponse
     toRpcResponse_Load(json11::Json j,
                         const PluginHandleMapper &pmapper,
                         std::string &err) {
         
-        Vamp::HostExt::LoadResponse resp;
+        LoadResponse resp;
         if (successful(j, err) && !failed(err)) {
             resp = toLoadResponse(j["result"], pmapper, err);
         }
         return resp;
     }
     
-    static Vamp::HostExt::ConfigurationRequest
+    static ConfigurationRequest
     toRpcRequest_Configure(json11::Json j,
                             const PluginHandleMapper &pmapper,
                             std::string &err) {
         
         checkTypeField(j, "configure", err);
         if (failed(err)) return {};
         return toConfigurationRequest(j["params"], pmapper, err);
     }
     
-    static Vamp::HostExt::ConfigurationResponse
+    static ConfigurationResponse
     toRpcResponse_Configure(json11::Json j,
                              const PluginHandleMapper &pmapper,
                              std::string &err) {
         
-        Vamp::HostExt::ConfigurationResponse resp;
+        ConfigurationResponse resp;
         if (successful(j, err) && !failed(err)) {
             resp = toConfigurationResponse(j["result"], pmapper, err);
         }
         return resp;
     }
     
-    static Vamp::HostExt::ProcessRequest
+    static ProcessRequest
     toRpcRequest_Process(json11::Json j, const PluginHandleMapper &pmapper,
                           BufferSerialisation &serialisation, std::string &err) {
         
         checkTypeField(j, "process", err);
         if (failed(err)) return {};
         return toProcessRequest(j["params"], pmapper, serialisation, err);
     }
     
-    static Vamp::HostExt::ProcessResponse
+    static ProcessResponse
     toRpcResponse_Process(json11::Json j,
                            const PluginHandleMapper &pmapper,
                            BufferSerialisation &serialisation, std::string &err) {
         
-        Vamp::HostExt::ProcessResponse resp;
+        ProcessResponse resp;
         if (successful(j, err) && !failed(err)) {
             auto jc = j["result"];
             auto h = jc["handle"].int_value();
             resp.plugin = pmapper.handleToPlugin(h);
             resp.features = toFeatureSet(jc["features"],

                                          serialisation, err);
         }
         return resp;
     }
     
-    static Vamp::HostExt::FinishRequest
+    static FinishRequest
     toRpcRequest_Finish(json11::Json j, const PluginHandleMapper &pmapper,
                          std::string &err) {
         
         checkTypeField(j, "finish", err);
         if (failed(err)) return {};
-        Vamp::HostExt::FinishRequest req;
+        FinishRequest req;
         req.plugin = pmapper.handleToPlugin
             (j["params"]["handle"].int_value());
         return req;
     }
     
-    static Vamp::HostExt::ProcessResponse
+    static FinishResponse
     toRpcResponse_Finish(json11::Json j,
-                          const PluginHandleMapper &pmapper,
-                          BufferSerialisation &serialisation, std::string &err) {
-        
-        Vamp::HostExt::ProcessResponse resp;
+                         const PluginHandleMapper &pmapper,
+                         BufferSerialisation &serialisation, std::string &err) {
+        
+        FinishResponse resp;
         if (successful(j, err) && !failed(err)) {
             auto jc = j["result"];
             auto h = jc["handle"].int_value();
             resp.plugin = pmapper.handleToPlugin(h);
             resp.features = toFeatureSet(jc["features"],