comparison vamp-client/CapnpRRClient.h @ 97:427c4c725085

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

 #include "vamp-support/AssignedPluginHandleMapper.h"
 #include "vamp-capnp/VampnProto.h"
 
 #include <capnp/serialize.h>
 
-namespace piper {
-namespace vampclient {
+namespace piper_vamp {
+namespace client {
 
 class CapnpRRClient : public PluginClient,
-                    public Loader
+		      public Loader
 {
     // unsigned to avoid undefined behaviour on possible wrap
     typedef uint32_t ReqId;
 
     class CompletenessChecker : public MessageCompletenessChecker {

     //!!! but the rest are only supposed to be called by the plugin --
     //!!! sort out the api here
 
     // Loader methods:
 
-    Vamp::HostExt::ListResponse
+    ListResponse
     listPluginData() override {
 
         if (!m_transport->isOK()) {
             throw std::runtime_error("Piper server failed to start");
         }
 
         capnp::MallocMessageBuilder message;
-        RpcRequest::Builder builder = message.initRoot<RpcRequest>();
+	piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
         VampnProto::buildRpcRequest_List(builder);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
 	auto karr = call(message);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
-        RpcResponse::Reader reader = responseMessage.getRoot<RpcResponse>();
-
-        checkResponseType(reader, RpcResponse::Response::Which::LIST, id);
-
-        Vamp::HostExt::ListResponse lr;
+        piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
+
+        checkResponseType(reader, piper::RpcResponse::Response::Which::LIST, id);
+
+        ListResponse lr;
         VampnProto::readListResponse(lr, reader.getResponse().getList());
         return lr;
     }
     
-    Vamp::HostExt::LoadResponse
-    loadPlugin(const Vamp::HostExt::LoadRequest &req) override {
-
-        if (!m_transport->isOK()) {
-            throw std::runtime_error("Piper server failed to start");
-        }
-
-        Vamp::HostExt::LoadResponse resp;
+    LoadResponse
+    loadPlugin(const LoadRequest &req) override {
+
+        if (!m_transport->isOK()) {
+            throw std::runtime_error("Piper server failed to start");
+        }
+
+        LoadResponse resp;
         PluginHandleMapper::Handle handle = serverLoad(req.pluginKey,
                                                        req.inputSampleRate,
                                                        req.adapterFlags,
                                                        resp.staticData,
                                                        resp.defaultConfiguration);

     // PluginClient methods:
     
     virtual
     Vamp::Plugin::OutputList
     configure(PluginStub *plugin,
-              Vamp::HostExt::PluginConfiguration config) override {
-
-        if (!m_transport->isOK()) {
-            throw std::runtime_error("Piper server failed to start");
-        }
-
-        Vamp::HostExt::ConfigurationRequest request;
+              PluginConfiguration config) override {
+
+        if (!m_transport->isOK()) {
+            throw std::runtime_error("Piper server failed to start");
+        }
+
+        ConfigurationRequest request;
         request.plugin = plugin;
         request.configuration = config;
 
         capnp::MallocMessageBuilder message;
-        RpcRequest::Builder builder = message.initRoot<RpcRequest>();
+        piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
 
         VampnProto::buildRpcRequest_Configure(builder, request, m_mapper);
         ReqId id = getId();
         builder.getId().setNumber(id);
 
 	auto karr = call(message);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
-        RpcResponse::Reader reader = responseMessage.getRoot<RpcResponse>();
+        piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case
 
-        checkResponseType(reader, RpcResponse::Response::Which::CONFIGURE, id);
-
-        Vamp::HostExt::ConfigurationResponse cr;
+        checkResponseType(reader, piper::RpcResponse::Response::Which::CONFIGURE, id);
+
+        ConfigurationResponse cr;
         VampnProto::readConfigurationResponse(cr,
                                               reader.getResponse().getConfigure(),
                                               m_mapper);
 
         return cr.outputs;

 
         if (!m_transport->isOK()) {
             throw std::runtime_error("Piper server failed to start");
         }
 
-        Vamp::HostExt::ProcessRequest request;
+        ProcessRequest request;
         request.plugin = plugin;
         request.inputBuffers = inputBuffers;
         request.timestamp = timestamp;
         
         capnp::MallocMessageBuilder message;
-        RpcRequest::Builder builder = message.initRoot<RpcRequest>();
+        piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
         VampnProto::buildRpcRequest_Process(builder, request, m_mapper);
 	ReqId id = getId();
         builder.getId().setNumber(id);
 
 	auto karr = call(message);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
-        RpcResponse::Reader reader = responseMessage.getRoot<RpcResponse>();
+        piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case
 
-        checkResponseType(reader, RpcResponse::Response::Which::PROCESS, id);
-
-        Vamp::HostExt::ProcessResponse pr;
+        checkResponseType(reader, piper::RpcResponse::Response::Which::PROCESS, id);
+
+        ProcessResponse pr;
         VampnProto::readProcessResponse(pr,
                                         reader.getResponse().getProcess(),
                                         m_mapper);
 
         return pr.features;

 
         if (!m_transport->isOK()) {
             throw std::runtime_error("Piper server failed to start");
         }
 
-        Vamp::HostExt::FinishRequest request;
+        FinishRequest request;
         request.plugin = plugin;
         
         capnp::MallocMessageBuilder message;
-        RpcRequest::Builder builder = message.initRoot<RpcRequest>();
+        piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
 
         VampnProto::buildRpcRequest_Finish(builder, request, m_mapper);
         ReqId id = getId();
         builder.getId().setNumber(id);
         
 	auto karr = call(message);
 
         capnp::FlatArrayMessageReader responseMessage(karr);
-        RpcResponse::Reader reader = responseMessage.getRoot<RpcResponse>();
+        piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case
 
-        checkResponseType(reader, RpcResponse::Response::Which::FINISH, id);
-
-        Vamp::HostExt::ProcessResponse pr;
+        checkResponseType(reader, piper::RpcResponse::Response::Which::FINISH, id);
+
+        FinishResponse pr;
         VampnProto::readFinishResponse(pr,
                                        reader.getResponse().getFinish(),
                                        m_mapper);
 
         m_mapper.removePlugin(m_mapper.pluginToHandle(plugin));

         return pr.features;
     }
 
     virtual void
     reset(PluginStub *plugin,
-          Vamp::HostExt::PluginConfiguration config) override {
+          PluginConfiguration config) override {
 
         // Reload the plugin on the server side, and configure it as requested
         
         if (!m_transport->isOK()) {
             throw std::runtime_error("Piper server failed to start");

 
         if (m_mapper.havePlugin(plugin)) {
             (void)finish(plugin); // server-side unload
         }
 
-        Vamp::HostExt::PluginStaticData psd;
-        Vamp::HostExt::PluginConfiguration defaultConfig;
+        PluginStaticData psd;
+        PluginConfiguration defaultConfig;
         PluginHandleMapper::Handle handle =
             serverLoad(plugin->getPluginKey(),
                        plugin->getInputSampleRate(),
                        plugin->getAdapterFlags(),
                        psd, defaultConfig);

 	memcpy(karr.begin(), buffer.data(), words * wordSize);
 	return karr;
     }
 
     void
-    checkResponseType(const RpcResponse::Reader &r,
-                      RpcResponse::Response::Which type,
+    checkResponseType(const piper::RpcResponse::Reader &r,
+                      piper::RpcResponse::Response::Which type,
                       ReqId id) {
         
         if (r.getResponse().which() != type) {
             throw std::runtime_error("Wrong response type");
         }

 	return toKJArray(responseBuffer);
     }
     
     PluginHandleMapper::Handle
     serverLoad(std::string key, float inputSampleRate, int adapterFlags,
-               Vamp::HostExt::PluginStaticData &psd,
-               Vamp::HostExt::PluginConfiguration &defaultConfig) {
-
-        Vamp::HostExt::LoadRequest request;
+               PluginStaticData &psd,
+               PluginConfiguration &defaultConfig) {
+
+        LoadRequest request;
         request.pluginKey = key;
         request.inputSampleRate = inputSampleRate;
         request.adapterFlags = adapterFlags;
 
         capnp::MallocMessageBuilder message;
-        RpcRequest::Builder builder = message.initRoot<RpcRequest>();
+        piper::RpcRequest::Builder builder = message.initRoot<piper::RpcRequest>();
 
         VampnProto::buildRpcRequest_Load(builder, request);
         ReqId id = getId();
         builder.getId().setNumber(id);
 

 
         //!!! ... --> will also need some way to kill this process
         //!!! (from another thread)
 
         capnp::FlatArrayMessageReader responseMessage(karr);
-        RpcResponse::Reader reader = responseMessage.getRoot<RpcResponse>();
+        piper::RpcResponse::Reader reader = responseMessage.getRoot<piper::RpcResponse>();
 
         //!!! handle (explicit) error case
 
-        checkResponseType(reader, RpcResponse::Response::Which::LOAD, id);
-        
-        const LoadResponse::Reader &lr = reader.getResponse().getLoad();
+        checkResponseType(reader, piper::RpcResponse::Response::Which::LOAD, id);
+        
+        const piper::LoadResponse::Reader &lr = reader.getResponse().getLoad();
         VampnProto::readExtractorStaticData(psd, lr.getStaticData());
         VampnProto::readConfiguration(defaultConfig, lr.getDefaultConfiguration());
         return lr.getHandle();
     };