Mercurial > hg > piper-cpp

changeset 68:a5ba837bca28

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Update again to latest plugin-terminology-free schema
author Chris Cannam <c.cannam@qmul.ac.uk>
date Thu, 06 Oct 2016 14:32:58 +0100
parents db17657ac875
children 91fda9470ee2
files capnproto/VampnProto.h capnproto/vamp.capnp json/VampJson.h test/test-vampipe-server.sh utilities/vampipe-convert.cpp utilities/vampipe-server.cpp
diffstat 6 files changed, 280 insertions(+), 259 deletions(-) [+]
line wrap: on
line diff
--- a/capnproto/VampnProto.h	Wed Oct 05 13:53:08 2016 +0100
+++ b/capnproto/VampnProto.h	Thu Oct 06 14:32:58 2016 +0100
@@ -370,17 +370,17 @@
     }
     
     static void
-    buildPluginStaticData(PluginStaticData::Builder &b,
+    buildExtractorStaticData(ExtractorStaticData::Builder &b,
                           const Vamp::HostExt::PluginStaticData &d) {
 
-        b.setPluginKey(d.pluginKey);
+        b.setKey(d.pluginKey);
 
         auto basic = b.initBasic();
         buildBasicDescriptor(basic, d.basic);
 
         b.setMaker(d.maker);
         b.setCopyright(d.copyright);
-        b.setPluginVersion(d.pluginVersion);
+        b.setVersion(d.pluginVersion);
 
         auto clist = b.initCategory(d.category.size());
         for (size_t i = 0; i < d.category.size(); ++i) {
@@ -414,16 +414,16 @@
     }
 
     static void
-    readPluginStaticData(Vamp::HostExt::PluginStaticData &d,
-                         const PluginStaticData::Reader &r) {
+    readExtractorStaticData(Vamp::HostExt::PluginStaticData &d,
+                         const ExtractorStaticData::Reader &r) {
         
-        d.pluginKey = r.getPluginKey();
+        d.pluginKey = r.getKey();
 
         readBasicDescriptor(d.basic, r.getBasic());
 
         d.maker = r.getMaker();
         d.copyright = r.getCopyright();
-        d.pluginVersion = r.getPluginVersion();
+        d.pluginVersion = r.getVersion();
 
         d.category.clear();
         auto cc = r.getCategory();
@@ -460,8 +460,8 @@
     }
 
     static void
-    buildPluginConfiguration(PluginConfiguration::Builder &b,
-                             const Vamp::HostExt::PluginConfiguration &c) {
+    buildConfiguration(Configuration::Builder &b,
+                       const Vamp::HostExt::PluginConfiguration &c) {
 
         const auto &vparams = c.parameterValues;
         auto params = b.initParameterValues(vparams.size());
@@ -479,8 +479,8 @@
     }
 
     static void
-    readPluginConfiguration(Vamp::HostExt::PluginConfiguration &c,
-                            const PluginConfiguration::Reader &r) {
+    readConfiguration(Vamp::HostExt::PluginConfiguration &c,
+                      const Configuration::Reader &r) {
 
         auto pp = r.getParameterValues();
         for (const auto &p: pp) {
@@ -497,7 +497,7 @@
     buildLoadRequest(LoadRequest::Builder &r,
                      const Vamp::HostExt::LoadRequest &req) {
 
-        r.setPluginKey(req.pluginKey);
+        r.setKey(req.pluginKey);
         r.setInputSampleRate(req.inputSampleRate);
 
         std::vector<AdapterFlag> flags;
@@ -521,7 +521,7 @@
     readLoadRequest(Vamp::HostExt::LoadRequest &req,
                     const LoadRequest::Reader &r) {
 
-        req.pluginKey = r.getPluginKey();
+        req.pluginKey = r.getKey();
         req.inputSampleRate = r.getInputSampleRate();
 
         int flags = 0;
@@ -545,11 +545,11 @@
                       const Vamp::HostExt::LoadResponse &resp,
                       const PluginHandleMapper &pmapper) {
 
-        b.setPluginHandle(pmapper.pluginToHandle(resp.plugin));
+        b.setHandle(pmapper.pluginToHandle(resp.plugin));
         auto sd = b.initStaticData();
-        buildPluginStaticData(sd, resp.staticData);
+        buildExtractorStaticData(sd, resp.staticData);
         auto conf = b.initDefaultConfiguration();
-        buildPluginConfiguration(conf, resp.defaultConfiguration);
+        buildConfiguration(conf, resp.defaultConfiguration);
     }
 
     static void
@@ -557,9 +557,9 @@
                      const LoadResponse::Reader &r,
                      const PluginHandleMapper &pmapper) {
 
-        resp.plugin = pmapper.handleToPlugin(r.getPluginHandle());
-        readPluginStaticData(resp.staticData, r.getStaticData());
-        readPluginConfiguration(resp.defaultConfiguration,
+        resp.plugin = pmapper.handleToPlugin(r.getHandle());
+        readExtractorStaticData(resp.staticData, r.getStaticData());
+        readConfiguration(resp.defaultConfiguration,
                                 r.getDefaultConfiguration());
     }
 
@@ -568,9 +568,9 @@
                               const Vamp::HostExt::ConfigurationRequest &cr,
                               const PluginHandleMapper &pmapper) {
 
-        b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
+        b.setHandle(pmapper.pluginToHandle(cr.plugin));
         auto c = b.initConfiguration();
-        buildPluginConfiguration(c, cr.configuration);
+        buildConfiguration(c, cr.configuration);
     }
 
     static void
@@ -578,10 +578,10 @@
                              const ConfigurationRequest::Reader &r,
                              const PluginHandleMapper &pmapper) {
 
-        auto h = r.getPluginHandle();
+        auto h = r.getHandle();
         cr.plugin = pmapper.handleToPlugin(h);
         auto c = r.getConfiguration();
-        readPluginConfiguration(cr.configuration, c);
+        readConfiguration(cr.configuration, c);
     }
 
     static void
@@ -589,7 +589,7 @@
                                const Vamp::HostExt::ConfigurationResponse &cr,
                                const PluginHandleMapper &pmapper) {
 
-        b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
+        b.setHandle(pmapper.pluginToHandle(cr.plugin));
         auto olist = b.initOutputs(cr.outputs.size());
         for (size_t i = 0; i < cr.outputs.size(); ++i) {
             auto od = olist[i];
@@ -602,7 +602,7 @@
                               const ConfigurationResponse::Reader &r,
                               const PluginHandleMapper &pmapper) {
 
-        cr.plugin = pmapper.handleToPlugin(r.getPluginHandle());
+        cr.plugin = pmapper.handleToPlugin(r.getHandle());
         cr.outputs.clear();
         auto oo = r.getOutputs();
         for (const auto &o: oo) {
@@ -652,7 +652,7 @@
                         const Vamp::HostExt::ProcessRequest &pr,
                         const PluginHandleMapper &pmapper) {
 
-        b.setPluginHandle(pmapper.pluginToHandle(pr.plugin));
+        b.setHandle(pmapper.pluginToHandle(pr.plugin));
         auto input = b.initProcessInput();
         buildProcessInput(input, pr.timestamp, pr.inputBuffers);
     }
@@ -662,7 +662,7 @@
                        const ProcessRequest::Reader &r,
                        const PluginHandleMapper &pmapper) {
 
-        auto h = r.getPluginHandle();
+        auto h = r.getHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readProcessInput(pr.timestamp, pr.inputBuffers, r.getProcessInput());
     }
@@ -672,7 +672,7 @@
                          const Vamp::HostExt::ProcessResponse &pr,
                          const PluginHandleMapper &pmapper) {
 
-        b.setPluginHandle(pmapper.pluginToHandle(pr.plugin));
+        b.setHandle(pmapper.pluginToHandle(pr.plugin));
         auto f = b.initFeatures();
         buildFeatureSet(f, pr.features,
                         *pmapper.pluginToOutputIdMapper(pr.plugin));
@@ -683,47 +683,51 @@
                         const ProcessResponse::Reader &r,
                         const PluginHandleMapper &pmapper) {
 
-        auto h = r.getPluginHandle();
+        auto h = r.getHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readFeatureSet(pr.features, r.getFeatures(),
-                       *pmapper.handleToOutputIdMapper(r.getPluginHandle()));
+                       *pmapper.handleToOutputIdMapper(r.getHandle()));
     }
 
     static void
-    buildVampRequest_List(VampRequest::Builder &b) {
-        b.getRequest().setList();
+    buildRpcRequest_List(RpcRequest::Builder &b) {
+        b.getRequest().initList();
     }
 
     static void
-    buildVampResponse_List(VampResponse::Builder &b,
+    buildRpcResponse_List(RpcResponse::Builder &b,
                            const Vamp::HostExt::ListResponse &resp) {
-        b.setSuccess(true);
+
         auto r = b.getResponse().initList();
-        auto p = r.initPlugins(resp.plugins.size());
+        auto p = r.initAvailable(resp.plugins.size());
         for (size_t i = 0; i < resp.plugins.size(); ++i) {
             auto pd = p[i];
-            buildPluginStaticData(pd, resp.plugins[i]);
+            buildExtractorStaticData(pd, resp.plugins[i]);
         }
     }
     
     static void
-    buildVampRequest_Load(VampRequest::Builder &b,
+    buildRpcRequest_Load(RpcRequest::Builder &b,
                           const Vamp::HostExt::LoadRequest &req) {
         auto u = b.getRequest().initLoad();
         buildLoadRequest(u, req);
     }
 
     static void
-    buildVampResponse_Load(VampResponse::Builder &b,
+    buildRpcResponse_Load(RpcResponse::Builder &b,
                            const Vamp::HostExt::LoadResponse &resp,
                            const PluginHandleMapper &pmapper) {
-        b.setSuccess(resp.plugin != 0);
-        auto u = b.getResponse().initLoad();
-        buildLoadResponse(u, resp, pmapper);
+
+        if (resp.plugin) {
+            auto u = b.getResponse().initLoad();
+            buildLoadResponse(u, resp, pmapper);
+        } else {
+            buildRpcResponse_Error(b, "Failed to load plugin", RRType::Load);
+        }
     }
 
     static void
-    buildVampRequest_Configure(VampRequest::Builder &b,
+    buildRpcRequest_Configure(RpcRequest::Builder &b,
                                const Vamp::HostExt::ConfigurationRequest &cr,
                                const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initConfigure();
@@ -731,16 +735,21 @@
     }
 
     static void
-    buildVampResponse_Configure(VampResponse::Builder &b,
+    buildRpcResponse_Configure(RpcResponse::Builder &b,
                                 const Vamp::HostExt::ConfigurationResponse &cr,
                                 const PluginHandleMapper &pmapper) {
-        b.setSuccess(!cr.outputs.empty());
-        auto u = b.getResponse().initConfigure();
-        buildConfigurationResponse(u, cr, pmapper);
+
+        if (!cr.outputs.empty()) {
+            auto u = b.getResponse().initConfigure();
+            buildConfigurationResponse(u, cr, pmapper);
+        } else {
+            buildRpcResponse_Error(b, "Failed to configure plugin",
+                                   RRType::Configure);
+        }
     }
     
     static void
-    buildVampRequest_Process(VampRequest::Builder &b,
+    buildRpcRequest_Process(RpcRequest::Builder &b,
                              const Vamp::HostExt::ProcessRequest &pr,
                              const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initProcess();
@@ -748,131 +757,140 @@
     }
     
     static void
-    buildVampResponse_Process(VampResponse::Builder &b,
+    buildRpcResponse_Process(RpcResponse::Builder &b,
                               const Vamp::HostExt::ProcessResponse &pr,
                               const PluginHandleMapper &pmapper) {
-        b.setSuccess(true);
+
         auto u = b.getResponse().initProcess();
         buildProcessResponse(u, pr, pmapper);
     }
     
     static void
-    buildVampRequest_Finish(VampRequest::Builder &b,
+    buildRpcRequest_Finish(RpcRequest::Builder &b,
                             const Vamp::HostExt::FinishRequest &req,
                             const PluginHandleMapper &pmapper) {
 
         auto u = b.getRequest().initFinish();
-        u.setPluginHandle(pmapper.pluginToHandle(req.plugin));
+        u.setHandle(pmapper.pluginToHandle(req.plugin));
     }
     
     static void
-    buildVampResponse_Finish(VampResponse::Builder &b,
+    buildRpcResponse_Finish(RpcResponse::Builder &b,
                              const Vamp::HostExt::ProcessResponse &pr,
                              const PluginHandleMapper &pmapper) {
-        b.setSuccess(true);
+
         auto u = b.getResponse().initFinish();
         buildProcessResponse(u, pr, pmapper);
     }
 
     static void
-    buildVampResponse_Error(VampResponse::Builder &b,
+    buildRpcResponse_Error(RpcResponse::Builder &b,
                             const std::string &errorText,
                             RRType responseType)
     {
         std::string type;
 
+        auto e = b.getResponse().initError();
+
         if (responseType == RRType::List) {
             type = "list";
-            b.getResponse().initList();
         } else if (responseType == RRType::Load) {
             type = "load";
-            b.getResponse().initLoad();
         } else if (responseType == RRType::Configure) {
             type = "configure";
-            b.getResponse().initConfigure();
         } else if (responseType == RRType::Process) {
             type = "process";
-            b.getResponse().initProcess();
         } else if (responseType == RRType::Finish) {
             type = "finish";
-            b.getResponse().initFinish();
         } else {
             type = "invalid";
         }
 
-        b.setSuccess(false);
-        b.setErrorText(std::string("error in ") + type + " request: " + errorText);
+        //!!! + code
+        
+        e.setMessage(std::string("error in ") + type + " request: " + errorText);
     }
 
     static void
-    buildVampResponse_Exception(VampResponse::Builder &b,
+    buildRpcResponse_Exception(RpcResponse::Builder &b,
                                 const std::exception &e,
                                 RRType responseType)
     {
-        return buildVampResponse_Error(b, e.what(), responseType);
+        return buildRpcResponse_Error(b, e.what(), responseType);
     }
     
     static RRType
-    getRequestResponseType(const VampRequest::Reader &r) {
+    getRequestResponseType(const RpcRequest::Reader &r) {
         switch (r.getRequest().which()) {
-        case VampRequest::Request::Which::LIST:
+        case RpcRequest::Request::Which::LIST:
             return RRType::List;
-        case VampRequest::Request::Which::LOAD:
+        case RpcRequest::Request::Which::LOAD:
             return RRType::Load;
-        case VampRequest::Request::Which::CONFIGURE:
+        case RpcRequest::Request::Which::CONFIGURE:
             return RRType::Configure;
-        case VampRequest::Request::Which::PROCESS:
+        case RpcRequest::Request::Which::PROCESS:
             return RRType::Process;
-        case VampRequest::Request::Which::FINISH:
+        case RpcRequest::Request::Which::FINISH:
             return RRType::Finish;
         }
         return RRType::NotValid;
     }
 
     static RRType
-    getRequestResponseType(const VampResponse::Reader &r) {
+    getRequestResponseType(const RpcResponse::Reader &r) {
         switch (r.getResponse().which()) {
-        case VampResponse::Response::Which::LIST:
+        case RpcResponse::Response::Which::ERROR:
+            return RRType::NotValid; //!!! or error type? test this
+        case RpcResponse::Response::Which::LIST:
             return RRType::List;
-        case VampResponse::Response::Which::LOAD:
+        case RpcResponse::Response::Which::LOAD:
             return RRType::Load;
-        case VampResponse::Response::Which::CONFIGURE:
+        case RpcResponse::Response::Which::CONFIGURE:
             return RRType::Configure;
-        case VampResponse::Response::Which::PROCESS:
+        case RpcResponse::Response::Which::PROCESS:
             return RRType::Process;
-        case VampResponse::Response::Which::FINISH:
+        case RpcResponse::Response::Which::FINISH:
             return RRType::Finish;
         }
         return RRType::NotValid;
     }
     
     static void
-    readVampRequest_List(const VampRequest::Reader &r) {
+    readRpcResponse_Error(int &code,
+                          std::string &message,
+                          const RpcResponse::Reader &r) {
+        if (getRequestResponseType(r) != RRType::NotValid) {
+            throw std::logic_error("not an error response");
+        }
+        code = r.getResponse().getError().getCode();
+        message = r.getResponse().getError().getMessage();
+    }
+        
+    static void
+    readRpcRequest_List(const RpcRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list request");
         }
     }
 
     static void
-    readVampResponse_List(Vamp::HostExt::ListResponse &resp,
-                          const VampResponse::Reader &r) {
+    readRpcResponse_List(Vamp::HostExt::ListResponse &resp,
+                          const RpcResponse::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list response");
         }
         resp.plugins.clear();
-        if (r.getSuccess()) {
-            auto pp = r.getResponse().getList().getPlugins();
-            for (const auto &p: pp) {
-                Vamp::HostExt::PluginStaticData psd;
-                readPluginStaticData(psd, p);
-                resp.plugins.push_back(psd);
-            }
+        auto pp = r.getResponse().getList().getAvailable();
+        for (const auto &p: pp) {
+            Vamp::HostExt::PluginStaticData psd;
+            readExtractorStaticData(psd, p);
+            resp.plugins.push_back(psd);
         }
     }
     
     static void
-    readVampRequest_Load(Vamp::HostExt::LoadRequest &req,
-                         const VampRequest::Reader &r) {
+    readRpcRequest_Load(Vamp::HostExt::LoadRequest &req,
+                         const RpcRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load request");
         }
@@ -880,21 +898,19 @@
     }
 
     static void
-    readVampResponse_Load(Vamp::HostExt::LoadResponse &resp,
-                          const VampResponse::Reader &r,
-                          const PluginHandleMapper &pmapper) {
+    readRpcResponse_Load(Vamp::HostExt::LoadResponse &resp,
+                         const RpcResponse::Reader &r,
+                         const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load response");
         }
         resp = {};
-        if (r.getSuccess()) {
-            readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
-        }
+        readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
     }
     
     static void
-    readVampRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
-                              const VampRequest::Reader &r,
+    readRpcRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
+                              const RpcRequest::Reader &r,
                               const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration request");
@@ -903,23 +919,21 @@
     }
 
     static void
-    readVampResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
-                               const VampResponse::Reader &r,
+    readRpcResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
+                               const RpcResponse::Reader &r,
                                const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration response");
         }
         resp = {};
-        if (r.getSuccess()) {
-            readConfigurationResponse(resp,
-                                      r.getResponse().getConfigure(),
-                                      pmapper);
-        }
+        readConfigurationResponse(resp,
+                                  r.getResponse().getConfigure(),
+                                  pmapper);
     }
     
     static void
-    readVampRequest_Process(Vamp::HostExt::ProcessRequest &req,
-                            const VampRequest::Reader &r,
+    readRpcRequest_Process(Vamp::HostExt::ProcessRequest &req,
+                            const RpcRequest::Reader &r,
                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process request");
@@ -928,40 +942,36 @@
     }
 
     static void
-    readVampResponse_Process(Vamp::HostExt::ProcessResponse &resp,
-                             const VampResponse::Reader &r,
+    readRpcResponse_Process(Vamp::HostExt::ProcessResponse &resp,
+                             const RpcResponse::Reader &r,
                              const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process response");
         }
         resp = {};
-        if (r.getSuccess()) {
-            readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
-        }
+        readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
     }
     
     static void
-    readVampRequest_Finish(Vamp::HostExt::FinishRequest &req,
-                           const VampRequest::Reader &r,
+    readRpcRequest_Finish(Vamp::HostExt::FinishRequest &req,
+                           const RpcRequest::Reader &r,
                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish request");
         }
         req.plugin = pmapper.handleToPlugin
-            (r.getRequest().getFinish().getPluginHandle());
+            (r.getRequest().getFinish().getHandle());
     }
 
     static void
-    readVampResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
-                            const VampResponse::Reader &r,
+    readRpcResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
+                            const RpcResponse::Reader &r,
                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish response");
         }
         resp = {};
-        if (r.getSuccess()) {
-            readProcessResponse(resp, r.getResponse().getFinish(), pmapper);
-        }
+        readProcessResponse(resp, r.getResponse().getFinish(), pmapper);
     }
 };
 
--- a/capnproto/vamp.capnp	Wed Oct 05 13:53:08 2016 +0100
+++ b/capnproto/vamp.capnp	Thu Oct 06 14:32:58 2016 +0100
@@ -69,12 +69,12 @@
     configured         @1  :ConfiguredOutputDescriptor;
 }
 
-struct PluginStaticData {
-    pluginKey          @0  :Text;
+struct ExtractorStaticData {
+    key                @0  :Text;
     basic              @1  :Basic;
     maker              @2  :Text;
     copyright          @3  :Text;
-    pluginVersion      @4  :Int32;
+    version            @4  :Int32;
     category           @5  :List(Text);
     minChannelCount    @6  :Int32;
     maxChannelCount    @7  :Int32;
@@ -106,7 +106,7 @@
     featurePairs       @0  :List(FSPair);
 }
 
-struct PluginConfiguration {
+struct Configuration {
     struct PVPair {
         parameter      @0  :Text;
         value          @1  :Float32;
@@ -118,49 +118,57 @@
     blockSize          @4  :Int32;
 }
 
+struct ListRequest {
+}
+
 struct ListResponse {
-    plugins            @0  :List(PluginStaticData);    
+    available          @0  :List(ExtractorStaticData);    
 }
 
 struct LoadRequest {
-    pluginKey          @0  :Text;
+    key                @0  :Text;
     inputSampleRate    @1  :Float32;
     adapterFlags       @2  :List(AdapterFlag);
 }
 
 struct LoadResponse {
-    pluginHandle       @0  :Int32;
-    staticData         @1  :PluginStaticData;
-    defaultConfiguration @2  :PluginConfiguration;
+    handle             @0  :Int32;
+    staticData         @1  :ExtractorStaticData;
+    defaultConfiguration @2  :Configuration;
 }
 
 struct ConfigurationRequest {
-    pluginHandle       @0  :Int32;
-    configuration      @1  :PluginConfiguration;
+    handle             @0  :Int32;
+    configuration      @1  :Configuration;
 }
 
 struct ConfigurationResponse {
-    pluginHandle       @0  :Int32;
+    handle             @0  :Int32;
     outputs            @1  :List(OutputDescriptor);
 }
 
 struct ProcessRequest {
-    pluginHandle       @0  :Int32;
+    handle             @0  :Int32;
     processInput       @1  :ProcessInput;
 }
 
 struct ProcessResponse {
-    pluginHandle       @0  :Int32;
+    handle             @0  :Int32;
     features           @1  :FeatureSet;
 }
 
 struct FinishRequest {
-    pluginHandle       @0  :Int32;
+    handle             @0  :Int32;
 }
 
-struct VampRequest {
+struct Error {
+    code               @0  :Int32;
+    message            @1  :Text;
+}
+
+struct RpcRequest {
     request :union {
-	list           @0  :Void;
+	list           @0  :ListRequest;
 	load           @1  :LoadRequest;
 	configure      @2  :ConfigurationRequest;
 	process        @3  :ProcessRequest;
@@ -168,15 +176,14 @@
     }
 }
 
-struct VampResponse {
-    success            @0  :Bool;
-    errorText          @1  :Text = "";
+struct RpcResponse {
     response :union {
-	list           @2  :ListResponse;
-	load           @3  :LoadResponse;
-	configure      @4  :ConfigurationResponse;
-	process        @5  :ProcessResponse;
-	finish         @6  :ProcessResponse;
+        error          @0  :Error;
+	list           @1  :ListResponse;
+	load           @2  :LoadResponse;
+	configure      @3  :ConfigurationResponse;
+	process        @4  :ProcessResponse;
+	finish         @5  :ProcessResponse;
     }
 }
 
--- a/json/VampJson.h	Wed Oct 05 13:53:08 2016 +0100
+++ b/json/VampJson.h	Thu Oct 06 14:32:58 2016 +0100
@@ -536,11 +536,11 @@
     fromPluginStaticData(const Vamp::HostExt::PluginStaticData &d) {
 
         json11::Json::object jo;
-        jo["pluginKey"] = d.pluginKey;
+        jo["key"] = d.pluginKey;
         jo["basic"] = fromBasicDescriptor(d.basic);
         jo["maker"] = d.maker;
         jo["copyright"] = d.copyright;
-        jo["pluginVersion"] = d.pluginVersion;
+        jo["version"] = d.pluginVersion;
 
         json11::Json::array cat;
         for (const std::string &c: d.category) cat.push_back(c);
@@ -573,8 +573,8 @@
     toPluginStaticData(json11::Json j, std::string &err) {
 
         if (!j.has_shape({
-                    { "pluginKey", json11::Json::STRING },
-                    { "pluginVersion", json11::Json::NUMBER },
+                    { "key", json11::Json::STRING },
+                    { "version", json11::Json::NUMBER },
                     { "minChannelCount", json11::Json::NUMBER },
                     { "maxChannelCount", json11::Json::NUMBER },
                     { "inputDomain", json11::Json::STRING }}, err)) {
@@ -623,14 +623,14 @@
 
             Vamp::HostExt::PluginStaticData psd;
 
-            psd.pluginKey = j["pluginKey"].string_value();
+            psd.pluginKey = j["key"].string_value();
 
             toBasicDescriptor(j["basic"], psd.basic, err);
             if (failed(err)) return {};
 
             psd.maker = j["maker"].string_value();
             psd.copyright = j["copyright"].string_value();
-            psd.pluginVersion = j["pluginVersion"].int_value();
+            psd.pluginVersion = j["version"].int_value();
 
             for (const auto &c : j["category"].array_items()) {
                 if (!c.is_string()) {
@@ -802,7 +802,7 @@
     fromLoadRequest(const Vamp::HostExt::LoadRequest &req) {
 
         json11::Json::object jo;
-        jo["pluginKey"] = req.pluginKey;
+        jo["key"] = req.pluginKey;
         jo["inputSampleRate"] = req.inputSampleRate;
         jo["adapterFlags"] = fromAdapterFlags(req.adapterFlags);
         return json11::Json(jo);
@@ -812,14 +812,14 @@
     toLoadRequest(json11::Json j, std::string &err) {
         
         if (!j.has_shape({
-                    { "pluginKey", json11::Json::STRING },
+                    { "key", json11::Json::STRING },
                     { "inputSampleRate", json11::Json::NUMBER } }, err)) {
             err = "malformed load request: " + err;
             return {};
         }
     
         Vamp::HostExt::LoadRequest req;
-        req.pluginKey = j["pluginKey"].string_value();
+        req.pluginKey = j["key"].string_value();
         req.inputSampleRate = j["inputSampleRate"].number_value();
         if (!j["adapterFlags"].is_null()) {
             req.adapterFlags = toAdapterFlags(j["adapterFlags"], err);
@@ -833,7 +833,7 @@
                      const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
-        jo["pluginHandle"] = double(pmapper.pluginToHandle(resp.plugin));
+        jo["handle"] = double(pmapper.pluginToHandle(resp.plugin));
         jo["staticData"] = fromPluginStaticData(resp.staticData);
         jo["defaultConfiguration"] =
             fromPluginConfiguration(resp.defaultConfiguration);
@@ -845,7 +845,7 @@
                    const PluginHandleMapper &pmapper, std::string &err) {
 
         if (!j.has_shape({
-                    { "pluginHandle", json11::Json::NUMBER },
+                    { "handle", json11::Json::NUMBER },
                     { "staticData", json11::Json::OBJECT },
                     { "defaultConfiguration", json11::Json::OBJECT } }, err)) {
             err = "malformed load response: " + err;
@@ -853,7 +853,7 @@
         }
 
         Vamp::HostExt::LoadResponse resp;
-        resp.plugin = pmapper.handleToPlugin(j["pluginHandle"].int_value());
+        resp.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         resp.staticData = toPluginStaticData(j["staticData"], err);
         if (failed(err)) return {};
         resp.defaultConfiguration = toPluginConfiguration(j["defaultConfiguration"],
@@ -868,7 +868,7 @@
 
         json11::Json::object jo;
 
-        jo["pluginHandle"] = pmapper.pluginToHandle(cr.plugin);
+        jo["handle"] = pmapper.pluginToHandle(cr.plugin);
         jo["configuration"] = fromPluginConfiguration(cr.configuration);
         
         return json11::Json(jo);
@@ -879,14 +879,14 @@
                            const PluginHandleMapper &pmapper, std::string &err) {
 
         if (!j.has_shape({
-                    { "pluginHandle", json11::Json::NUMBER },
+                    { "handle", json11::Json::NUMBER },
                     { "configuration", json11::Json::OBJECT } }, err)) {
             err = "malformed configuration request: " + err;
             return {};
         }
 
         Vamp::HostExt::ConfigurationRequest cr;
-        cr.plugin = pmapper.handleToPlugin(j["pluginHandle"].int_value());
+        cr.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         cr.configuration = toPluginConfiguration(j["configuration"], err);
         if (failed(err)) return {};
         return cr;
@@ -898,7 +898,7 @@
 
         json11::Json::object jo;
 
-        jo["pluginHandle"] = pmapper.pluginToHandle(cr.plugin);
+        jo["handle"] = pmapper.pluginToHandle(cr.plugin);
         
         json11::Json::array outs;
         for (auto &d: cr.outputs) {
@@ -915,7 +915,7 @@
         
         Vamp::HostExt::ConfigurationResponse cr;
 
-        cr.plugin = pmapper.handleToPlugin(j["pluginHandle"].int_value());
+        cr.plugin = pmapper.handleToPlugin(j["handle"].int_value());
         
         if (!j["outputList"].is_array()) {
             err = "array expected for output list";
@@ -936,7 +936,7 @@
                        BufferSerialisation serialisation) {
 
         json11::Json::object jo;
-        jo["pluginHandle"] = pmapper.pluginToHandle(r.plugin);
+        jo["handle"] = pmapper.pluginToHandle(r.plugin);
 
         json11::Json::object io;
         io["timestamp"] = fromRealTime(r.timestamp);
@@ -963,7 +963,7 @@
                      BufferSerialisation &serialisation, std::string &err) {
 
         if (!j.has_shape({
-                    { "pluginHandle", json11::Json::NUMBER },
+                    { "handle", json11::Json::NUMBER },
                     { "processInput", json11::Json::OBJECT } }, err)) {
             err = "malformed process request: " + err;
             return {};
@@ -979,7 +979,7 @@
         }
 
         Vamp::HostExt::ProcessRequest r;
-        r.plugin = pmapper.handleToPlugin(j["pluginHandle"].int_value());
+        r.plugin = pmapper.handleToPlugin(j["handle"].int_value());
 
         r.timestamp = toRealTime(input["timestamp"], err);
         if (failed(err)) return {};
@@ -1041,7 +1041,7 @@
 public:
 
     static json11::Json
-    fromVampRequest_List() {
+    fromRpcRequest_List() {
 
         json11::Json::object jo;
         markRPC(jo);
@@ -1051,7 +1051,7 @@
     }
 
     static json11::Json
-    fromVampResponse_List(const Vamp::HostExt::ListResponse &resp) {
+    fromRpcResponse_List(const Vamp::HostExt::ListResponse &resp) {
 
         json11::Json::object jo;
         markRPC(jo);
@@ -1061,7 +1061,7 @@
             arr.push_back(fromPluginStaticData(a));
         }
         json11::Json::object po;
-        po["plugins"] = arr;
+        po["available"] = arr;
 
         jo["method"] = "list";
         jo["result"] = po;
@@ -1069,7 +1069,7 @@
     }
     
     static json11::Json
-    fromVampRequest_Load(const Vamp::HostExt::LoadRequest &req) {
+    fromRpcRequest_Load(const Vamp::HostExt::LoadRequest &req) {
 
         json11::Json::object jo;
         markRPC(jo);
@@ -1080,7 +1080,7 @@
     }    
 
     static json11::Json
-    fromVampResponse_Load(const Vamp::HostExt::LoadResponse &resp,
+    fromRpcResponse_Load(const Vamp::HostExt::LoadResponse &resp,
                           const PluginHandleMapper &pmapper) {
 
         if (resp.plugin) {
@@ -1098,7 +1098,7 @@
     }
 
     static json11::Json
-    fromVampRequest_Configure(const Vamp::HostExt::ConfigurationRequest &req,
+    fromRpcRequest_Configure(const Vamp::HostExt::ConfigurationRequest &req,
                               const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
@@ -1110,7 +1110,7 @@
     }    
 
     static json11::Json
-    fromVampResponse_Configure(const Vamp::HostExt::ConfigurationResponse &resp,
+    fromRpcResponse_Configure(const Vamp::HostExt::ConfigurationResponse &resp,
                                const PluginHandleMapper &pmapper) {
 
         if (!resp.outputs.empty()) {
@@ -1128,7 +1128,7 @@
     }
     
     static json11::Json
-    fromVampRequest_Process(const Vamp::HostExt::ProcessRequest &req,
+    fromRpcRequest_Process(const Vamp::HostExt::ProcessRequest &req,
                             const PluginHandleMapper &pmapper,
                             BufferSerialisation serialisation) {
 
@@ -1141,7 +1141,7 @@
     }    
 
     static json11::Json
-    fromVampResponse_Process(const Vamp::HostExt::ProcessResponse &resp,
+    fromRpcResponse_Process(const Vamp::HostExt::ProcessResponse &resp,
                              const PluginHandleMapper &pmapper,
                              BufferSerialisation serialisation) {
         
@@ -1149,7 +1149,7 @@
         markRPC(jo);
 
         json11::Json::object po;
-        po["pluginHandle"] = pmapper.pluginToHandle(resp.plugin);
+        po["handle"] = pmapper.pluginToHandle(resp.plugin);
         po["features"] = fromFeatureSet(resp.features,
                                         *pmapper.pluginToOutputIdMapper(resp.plugin),
                                         serialisation);
@@ -1159,14 +1159,14 @@
     }
     
     static json11::Json
-    fromVampRequest_Finish(const Vamp::HostExt::FinishRequest &req,
+    fromRpcRequest_Finish(const Vamp::HostExt::FinishRequest &req,
                            const PluginHandleMapper &pmapper) {
 
         json11::Json::object jo;
         markRPC(jo);
 
         json11::Json::object fo;
-        fo["pluginHandle"] = pmapper.pluginToHandle(req.plugin);
+        fo["handle"] = pmapper.pluginToHandle(req.plugin);
 
         jo["method"] = "finish";
         jo["params"] = fo;
@@ -1174,7 +1174,7 @@
     }    
     
     static json11::Json
-    fromVampResponse_Finish(const Vamp::HostExt::ProcessResponse &resp,
+    fromRpcResponse_Finish(const Vamp::HostExt::ProcessResponse &resp,
                             const PluginHandleMapper &pmapper,
                             BufferSerialisation serialisation) {
 
@@ -1182,7 +1182,7 @@
         markRPC(jo);
 
         json11::Json::object po;
-        po["pluginHandle"] = pmapper.pluginToHandle(resp.plugin);
+        po["handle"] = pmapper.pluginToHandle(resp.plugin);
         po["features"] = fromFeatureSet(resp.features,
                                         *pmapper.pluginToOutputIdMapper(resp.plugin),
                                         serialisation);
@@ -1240,16 +1240,16 @@
     }
 
     static void
-    toVampRequest_List(json11::Json j, std::string &err) {
+    toRpcRequest_List(json11::Json j, std::string &err) {
         checkTypeField(j, "list", err);
     }
 
     static Vamp::HostExt::ListResponse
-    toVampResponse_List(json11::Json j, std::string &err) {
+    toRpcResponse_List(json11::Json j, std::string &err) {
 
         Vamp::HostExt::ListResponse resp;
         if (successful(j, err) && !failed(err)) {
-            for (const auto &a: j["result"]["plugins"].array_items()) {
+            for (const auto &a: j["result"]["available"].array_items()) {
                 resp.plugins.push_back(toPluginStaticData(a, err));
                 if (failed(err)) return {};
             }
@@ -1259,7 +1259,7 @@
     }
 
     static Vamp::HostExt::LoadRequest
-    toVampRequest_Load(json11::Json j, std::string &err) {
+    toRpcRequest_Load(json11::Json j, std::string &err) {
         
         checkTypeField(j, "load", err);
         if (failed(err)) return {};
@@ -1267,7 +1267,7 @@
     }
     
     static Vamp::HostExt::LoadResponse
-    toVampResponse_Load(json11::Json j,
+    toRpcResponse_Load(json11::Json j,
                         const PluginHandleMapper &pmapper,
                         std::string &err) {
         
@@ -1279,7 +1279,7 @@
     }
     
     static Vamp::HostExt::ConfigurationRequest
-    toVampRequest_Configure(json11::Json j,
+    toRpcRequest_Configure(json11::Json j,
                             const PluginHandleMapper &pmapper,
                             std::string &err) {
         
@@ -1289,7 +1289,7 @@
     }
     
     static Vamp::HostExt::ConfigurationResponse
-    toVampResponse_Configure(json11::Json j,
+    toRpcResponse_Configure(json11::Json j,
                              const PluginHandleMapper &pmapper,
                              std::string &err) {
         
@@ -1301,7 +1301,7 @@
     }
     
     static Vamp::HostExt::ProcessRequest
-    toVampRequest_Process(json11::Json j, const PluginHandleMapper &pmapper,
+    toRpcRequest_Process(json11::Json j, const PluginHandleMapper &pmapper,
                           BufferSerialisation &serialisation, std::string &err) {
         
         checkTypeField(j, "process", err);
@@ -1310,14 +1310,14 @@
     }
     
     static Vamp::HostExt::ProcessResponse
-    toVampResponse_Process(json11::Json j,
+    toRpcResponse_Process(json11::Json j,
                            const PluginHandleMapper &pmapper,
                            BufferSerialisation &serialisation, std::string &err) {
         
         Vamp::HostExt::ProcessResponse resp;
         if (successful(j, err) && !failed(err)) {
             auto jc = j["result"];
-            auto h = jc["pluginHandle"].int_value();
+            auto h = jc["handle"].int_value();
             resp.plugin = pmapper.handleToPlugin(h);
             resp.features = toFeatureSet(jc["features"],
                                          *pmapper.handleToOutputIdMapper(h),
@@ -1327,26 +1327,26 @@
     }
     
     static Vamp::HostExt::FinishRequest
-    toVampRequest_Finish(json11::Json j, const PluginHandleMapper &pmapper,
+    toRpcRequest_Finish(json11::Json j, const PluginHandleMapper &pmapper,
                          std::string &err) {
         
         checkTypeField(j, "finish", err);
         if (failed(err)) return {};
         Vamp::HostExt::FinishRequest req;
         req.plugin = pmapper.handleToPlugin
-            (j["params"]["pluginHandle"].int_value());
+            (j["params"]["handle"].int_value());
         return req;
     }
     
     static Vamp::HostExt::ProcessResponse
-    toVampResponse_Finish(json11::Json j,
+    toRpcResponse_Finish(json11::Json j,
                           const PluginHandleMapper &pmapper,
                           BufferSerialisation &serialisation, std::string &err) {
         
         Vamp::HostExt::ProcessResponse resp;
         if (successful(j, err) && !failed(err)) {
             auto jc = j["result"];
-            auto h = jc["pluginHandle"].int_value();
+            auto h = jc["handle"].int_value();
             resp.plugin = pmapper.handleToPlugin(h);
             resp.features = toFeatureSet(jc["features"],
                                          *pmapper.handleToOutputIdMapper(h),
--- a/test/test-vampipe-server.sh	Wed Oct 05 13:53:08 2016 +0100
+++ b/test/test-vampipe-server.sh	Thu Oct 06 14:32:58 2016 +0100
@@ -19,13 +19,13 @@
 validate_request() {
     local json="$1"
     echo "$json" > "$reqfile"
-    validate "$reqfile" "request"
+    validate "$reqfile" "rpcrequest"
 }
 
 validate_response() {
     local json="$1"
     echo "$json" > "$respfile"
-    validate "$respfile" "response"
+    validate "$respfile" "rpcresponse"
 }
 
 ( while read request ; do
@@ -40,8 +40,8 @@
       done
 ) <<EOF
 {"method":"list"}
-{"method":"load","params": {"pluginKey":"vamp-example-plugins:percussiononsets","inputSampleRate":44100,"adapterFlags":["AdaptInputDomain","AdaptBufferSize"]}}
-{"method":"configure","params":{"pluginHandle":1,"configuration":{"blockSize": 8, "channelCount": 1, "parameterValues": {"sensitivity": 40, "threshold": 3}, "stepSize": 8}}}
-{"method":"process","params": {"pluginHandle": 1, "processInput": { "timestamp": {"s": 0, "n": 0}, "inputBuffers": [ [1,2,3,4,5,6,7,8] ]}}}
-{"method":"finish","params": {"pluginHandle": 1}}
+{"method":"load","params": {"key":"vamp-example-plugins:percussiononsets","inputSampleRate":44100,"adapterFlags":["AdaptInputDomain","AdaptBufferSize"]}}
+{"method":"configure","params":{"handle":1,"configuration":{"blockSize": 8, "channelCount": 1, "parameterValues": {"sensitivity": 40, "threshold": 3}, "stepSize": 8}}}
+{"method":"process","params": {"handle": 1, "processInput": { "timestamp": {"s": 0, "n": 0}, "inputBuffers": [ [1,2,3,4,5,6,7,8] ]}}}
+{"method":"finish","params": {"handle": 1}}
 EOF
--- a/utilities/vampipe-convert.cpp	Wed Oct 05 13:53:08 2016 +0100
+++ b/utilities/vampipe-convert.cpp	Thu Oct 06 14:32:58 2016 +0100
@@ -104,19 +104,19 @@
     switch (rr.type) {
 
     case RRType::List:
-	VampJson::toVampRequest_List(j, err); // type check only
+	VampJson::toRpcRequest_List(j, err); // type check only
 	break;
     case RRType::Load:
-	rr.loadRequest = VampJson::toVampRequest_Load(j, err);
+	rr.loadRequest = VampJson::toRpcRequest_Load(j, err);
 	break;
     case RRType::Configure:
-	rr.configurationRequest = VampJson::toVampRequest_Configure(j, mapper, err);
+	rr.configurationRequest = VampJson::toRpcRequest_Configure(j, mapper, err);
 	break;
     case RRType::Process:
-	rr.processRequest = VampJson::toVampRequest_Process(j, mapper, serialisation, err);
+	rr.processRequest = VampJson::toRpcRequest_Process(j, mapper, serialisation, err);
 	break;
     case RRType::Finish:
-	rr.finishRequest = VampJson::toVampRequest_Finish(j, mapper, err);
+	rr.finishRequest = VampJson::toRpcRequest_Finish(j, mapper, err);
 	break;
     case RRType::NotValid:
 	break;
@@ -138,20 +138,20 @@
     switch (rr.type) {
 
     case RRType::List:
-	j = VampJson::fromVampRequest_List();
+	j = VampJson::fromRpcRequest_List();
 	break;
     case RRType::Load:
-	j = VampJson::fromVampRequest_Load(rr.loadRequest);
+	j = VampJson::fromRpcRequest_Load(rr.loadRequest);
 	break;
     case RRType::Configure:
-	j = VampJson::fromVampRequest_Configure(rr.configurationRequest, mapper);
+	j = VampJson::fromRpcRequest_Configure(rr.configurationRequest, mapper);
 	break;
     case RRType::Process:
-	j = VampJson::fromVampRequest_Process
+	j = VampJson::fromRpcRequest_Process
 	    (rr.processRequest, mapper, serialisation);
 	break;
     case RRType::Finish:
-	j = VampJson::fromVampRequest_Finish(rr.finishRequest, mapper);
+	j = VampJson::fromRpcRequest_Finish(rr.finishRequest, mapper);
 	break;
     case RRType::NotValid:
 	break;
@@ -188,19 +188,19 @@
     switch (rr.type) {
 
     case RRType::List:
-	rr.listResponse = VampJson::toVampResponse_List(j, err);
+	rr.listResponse = VampJson::toRpcResponse_List(j, err);
 	break;
     case RRType::Load:
-	rr.loadResponse = VampJson::toVampResponse_Load(j, mapper, err);
+	rr.loadResponse = VampJson::toRpcResponse_Load(j, mapper, err);
 	break;
     case RRType::Configure:
-	rr.configurationResponse = VampJson::toVampResponse_Configure(j, mapper, err);
+	rr.configurationResponse = VampJson::toRpcResponse_Configure(j, mapper, err);
 	break;
     case RRType::Process: 
-	rr.processResponse = VampJson::toVampResponse_Process(j, mapper, serialisation, err);
+	rr.processResponse = VampJson::toRpcResponse_Process(j, mapper, serialisation, err);
 	break;
     case RRType::Finish:
-	rr.finishResponse = VampJson::toVampResponse_Finish(j, mapper, serialisation, err);
+	rr.finishResponse = VampJson::toRpcResponse_Finish(j, mapper, serialisation, err);
 	break;
     case RRType::NotValid:
 	break;
@@ -228,21 +228,21 @@
 	switch (rr.type) {
 
 	case RRType::List:
-	    j = VampJson::fromVampResponse_List(rr.listResponse);
+	    j = VampJson::fromRpcResponse_List(rr.listResponse);
 	    break;
 	case RRType::Load:
-	    j = VampJson::fromVampResponse_Load(rr.loadResponse, mapper);
+	    j = VampJson::fromRpcResponse_Load(rr.loadResponse, mapper);
 	    break;
 	case RRType::Configure:
-	    j = VampJson::fromVampResponse_Configure(rr.configurationResponse,
+	    j = VampJson::fromRpcResponse_Configure(rr.configurationResponse,
                                                      mapper);
 	    break;
 	case RRType::Process:
-	    j = VampJson::fromVampResponse_Process
+	    j = VampJson::fromRpcResponse_Process
 		(rr.processResponse, mapper, serialisation);
 	    break;
 	case RRType::Finish:
-	    j = VampJson::fromVampResponse_Finish
+	    j = VampJson::fromRpcResponse_Finish
 		(rr.finishResponse, mapper, serialisation);
 	    break;
 	case RRType::NotValid:
@@ -260,27 +260,27 @@
     rr.direction = RequestOrResponse::Request;
 
     ::capnp::InputStreamMessageReader message(buffered);
-    VampRequest::Reader reader = message.getRoot<VampRequest>();
+    RpcRequest::Reader reader = message.getRoot<RpcRequest>();
     
     rr.type = VampnProto::getRequestResponseType(reader);
 
     switch (rr.type) {
 
     case RRType::List:
-	VampnProto::readVampRequest_List(reader); // type check only
+	VampnProto::readRpcRequest_List(reader); // type check only
 	break;
     case RRType::Load:
-	VampnProto::readVampRequest_Load(rr.loadRequest, reader);
+	VampnProto::readRpcRequest_Load(rr.loadRequest, reader);
 	break;
     case RRType::Configure:
-	VampnProto::readVampRequest_Configure(rr.configurationRequest,
+	VampnProto::readRpcRequest_Configure(rr.configurationRequest,
 					      reader, mapper);
 	break;
     case RRType::Process:
-	VampnProto::readVampRequest_Process(rr.processRequest, reader, mapper);
+	VampnProto::readRpcRequest_Process(rr.processRequest, reader, mapper);
 	break;
     case RRType::Finish:
-	VampnProto::readVampRequest_Finish(rr.finishRequest, reader, mapper);
+	VampnProto::readRpcRequest_Finish(rr.finishRequest, reader, mapper);
 	break;
     case RRType::NotValid:
 	break;
@@ -293,25 +293,25 @@
 writeRequestCapnp(RequestOrResponse &rr)
 {
     ::capnp::MallocMessageBuilder message;
-    VampRequest::Builder builder = message.initRoot<VampRequest>();
+    RpcRequest::Builder builder = message.initRoot<RpcRequest>();
 
     switch (rr.type) {
 
     case RRType::List:
-	VampnProto::buildVampRequest_List(builder);
+	VampnProto::buildRpcRequest_List(builder);
 	break;
     case RRType::Load:
-	VampnProto::buildVampRequest_Load(builder, rr.loadRequest);
+	VampnProto::buildRpcRequest_Load(builder, rr.loadRequest);
 	break;
     case RRType::Configure:
-	VampnProto::buildVampRequest_Configure(builder,
-					       rr.configurationRequest, mapper);
+	VampnProto::buildRpcRequest_Configure(builder,
+                                              rr.configurationRequest, mapper);
 	break;
     case RRType::Process:
-	VampnProto::buildVampRequest_Process(builder, rr.processRequest, mapper);
+	VampnProto::buildRpcRequest_Process(builder, rr.processRequest, mapper);
 	break;
     case RRType::Finish:
-	VampnProto::buildVampRequest_Finish(builder, rr.finishRequest, mapper);
+	VampnProto::buildRpcRequest_Finish(builder, rr.finishRequest, mapper);
 	break;
     case RRType::NotValid:
 	break;
@@ -327,31 +327,35 @@
     rr.direction = RequestOrResponse::Response;
 
     ::capnp::InputStreamMessageReader message(buffered);
-    VampResponse::Reader reader = message.getRoot<VampResponse>();
+    RpcResponse::Reader reader = message.getRoot<RpcResponse>();
     
     rr.type = VampnProto::getRequestResponseType(reader);
-    rr.success = reader.getSuccess();
-    rr.errorText = reader.getErrorText();
+    rr.success = true;
+    rr.errorText = "";
+    int errorCode = 0;
 
     switch (rr.type) {
 
     case RRType::List:
-	VampnProto::readVampResponse_List(rr.listResponse, reader);
+	VampnProto::readRpcResponse_List(rr.listResponse, reader);
 	break;
     case RRType::Load:
-	VampnProto::readVampResponse_Load(rr.loadResponse, reader, mapper);
+	VampnProto::readRpcResponse_Load(rr.loadResponse, reader, mapper);
 	break;
     case RRType::Configure:
-	VampnProto::readVampResponse_Configure(rr.configurationResponse,
+	VampnProto::readRpcResponse_Configure(rr.configurationResponse,
 					       reader, mapper);
 	break;
     case RRType::Process:
-	VampnProto::readVampResponse_Process(rr.processResponse, reader, mapper);
+	VampnProto::readRpcResponse_Process(rr.processResponse, reader, mapper);
 	break;
     case RRType::Finish:
-	VampnProto::readVampResponse_Finish(rr.finishResponse, reader, mapper);
+	VampnProto::readRpcResponse_Finish(rr.finishResponse, reader, mapper);
 	break;
     case RRType::NotValid:
+        // error
+        rr.success = false;
+        VampnProto::readRpcResponse_Error(errorCode, rr.errorText, reader);
 	break;
     }
 
@@ -362,30 +366,30 @@
 writeResponseCapnp(RequestOrResponse &rr)
 {
     ::capnp::MallocMessageBuilder message;
-    VampResponse::Builder builder = message.initRoot<VampResponse>();
+    RpcResponse::Builder builder = message.initRoot<RpcResponse>();
 
     if (!rr.success) {
 
-	VampnProto::buildVampResponse_Error(builder, rr.errorText, rr.type);
+	VampnProto::buildRpcResponse_Error(builder, rr.errorText, rr.type);
 
     } else {
 	
 	switch (rr.type) {
 
 	case RRType::List:
-	    VampnProto::buildVampResponse_List(builder, rr.listResponse);
+	    VampnProto::buildRpcResponse_List(builder, rr.listResponse);
 	    break;
 	case RRType::Load:
-	    VampnProto::buildVampResponse_Load(builder, rr.loadResponse, mapper);
+	    VampnProto::buildRpcResponse_Load(builder, rr.loadResponse, mapper);
 	    break;
 	case RRType::Configure:
-	    VampnProto::buildVampResponse_Configure(builder, rr.configurationResponse, mapper);
+	    VampnProto::buildRpcResponse_Configure(builder, rr.configurationResponse, mapper);
 	    break;
 	case RRType::Process:
-	    VampnProto::buildVampResponse_Process(builder, rr.processResponse, mapper);
+	    VampnProto::buildRpcResponse_Process(builder, rr.processResponse, mapper);
 	    break;
 	case RRType::Finish:
-	    VampnProto::buildVampResponse_Finish(builder, rr.finishResponse, mapper);
+	    VampnProto::buildRpcResponse_Finish(builder, rr.finishResponse, mapper);
 	    break;
 	case RRType::NotValid:
 	    break;
--- a/utilities/vampipe-server.cpp	Wed Oct 05 13:53:08 2016 +0100
+++ b/utilities/vampipe-server.cpp	Thu Oct 06 14:32:58 2016 +0100
@@ -45,27 +45,27 @@
     }
 
     ::capnp::InputStreamMessageReader message(buffered);
-    VampRequest::Reader reader = message.getRoot<VampRequest>();
+    RpcRequest::Reader reader = message.getRoot<RpcRequest>();
     
     rr.type = VampnProto::getRequestResponseType(reader);
 
     switch (rr.type) {
 
     case RRType::List:
-	VampnProto::readVampRequest_List(reader); // type check only
+	VampnProto::readRpcRequest_List(reader); // type check only
 	break;
     case RRType::Load:
-	VampnProto::readVampRequest_Load(rr.loadRequest, reader);
+	VampnProto::readRpcRequest_Load(rr.loadRequest, reader);
 	break;
     case RRType::Configure:
-	VampnProto::readVampRequest_Configure(rr.configurationRequest,
+	VampnProto::readRpcRequest_Configure(rr.configurationRequest,
 					      reader, mapper);
 	break;
     case RRType::Process:
-	VampnProto::readVampRequest_Process(rr.processRequest, reader, mapper);
+	VampnProto::readRpcRequest_Process(rr.processRequest, reader, mapper);
 	break;
     case RRType::Finish:
-	VampnProto::readVampRequest_Finish(rr.finishRequest, reader, mapper);
+	VampnProto::readRpcRequest_Finish(rr.finishRequest, reader, mapper);
 	break;
     case RRType::NotValid:
 	break;
@@ -78,30 +78,30 @@
 writeResponseCapnp(RequestOrResponse &rr)
 {
     ::capnp::MallocMessageBuilder message;
-    VampResponse::Builder builder = message.initRoot<VampResponse>();
+    RpcResponse::Builder builder = message.initRoot<RpcResponse>();
 
     if (!rr.success) {
 
-	VampnProto::buildVampResponse_Error(builder, rr.errorText, rr.type);
+	VampnProto::buildRpcResponse_Error(builder, rr.errorText, rr.type);
 
     } else {
 	
 	switch (rr.type) {
 
 	case RRType::List:
-	    VampnProto::buildVampResponse_List(builder, rr.listResponse);
+	    VampnProto::buildRpcResponse_List(builder, rr.listResponse);
 	    break;
 	case RRType::Load:
-	    VampnProto::buildVampResponse_Load(builder, rr.loadResponse, mapper);
+	    VampnProto::buildRpcResponse_Load(builder, rr.loadResponse, mapper);
 	    break;
 	case RRType::Configure:
-	    VampnProto::buildVampResponse_Configure(builder, rr.configurationResponse, mapper);
+	    VampnProto::buildRpcResponse_Configure(builder, rr.configurationResponse, mapper);
 	    break;
 	case RRType::Process:
-	    VampnProto::buildVampResponse_Process(builder, rr.processResponse, mapper);
+	    VampnProto::buildRpcResponse_Process(builder, rr.processResponse, mapper);
 	    break;
 	case RRType::Finish:
-	    VampnProto::buildVampResponse_Finish(builder, rr.finishResponse, mapper);
+	    VampnProto::buildRpcResponse_Finish(builder, rr.finishResponse, mapper);
 	    break;
 	case RRType::NotValid:
 	    break;
@@ -115,8 +115,8 @@
 writeExceptionCapnp(const std::exception &e, RRType type)
 {
     ::capnp::MallocMessageBuilder message;
-    VampResponse::Builder builder = message.initRoot<VampResponse>();
-    VampnProto::buildVampResponse_Exception(builder, e, type);
+    RpcResponse::Builder builder = message.initRoot<RpcResponse>();
+    VampnProto::buildRpcResponse_Exception(builder, e, type);
     
     writeMessageToFd(1, message);
 }