comparison vamp-capnp/VampnProto.h @ 97:427c4c725085

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

 #include <capnp/message.h>
 //#include <capnp/serialize-packed.h>
 
 #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 Cap'n
  * Proto structures (and back again).

     static void readValueExtents(T &t, const M &m) {
         t.minValue = m.getMinValue();
         t.maxValue = m.getMaxValue();
     }
 
-    static void buildRealTime(RealTime::Builder &b, const Vamp::RealTime &t) {
+    static void buildRealTime(piper::RealTime::Builder &b,
+                              const Vamp::RealTime &t) {
         b.setSec(t.sec);
         b.setNsec(t.nsec);
     }
 
-    static void readRealTime(Vamp::RealTime &t, const RealTime::Reader &r) {
+    static void readRealTime(Vamp::RealTime &t,
+                             const piper::RealTime::Reader &r) {
         t.sec = r.getSec();
         t.nsec = r.getNsec();
     }
 
-    static SampleType
+    static piper::SampleType
     fromSampleType(Vamp::Plugin::OutputDescriptor::SampleType t) {
         switch (t) {
         case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
-            return SampleType::ONE_SAMPLE_PER_STEP;
+            return piper::SampleType::ONE_SAMPLE_PER_STEP;
         case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
-            return SampleType::FIXED_SAMPLE_RATE;
+            return piper::SampleType::FIXED_SAMPLE_RATE;
         case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
-            return SampleType::VARIABLE_SAMPLE_RATE;
+            return piper::SampleType::VARIABLE_SAMPLE_RATE;
         }
         throw std::logic_error("unexpected Vamp SampleType enum value");
     }
 
     static Vamp::Plugin::OutputDescriptor::SampleType
-    toSampleType(SampleType t) {
+    toSampleType(piper::SampleType t) {
         switch (t) {
-        case SampleType::ONE_SAMPLE_PER_STEP:
+        case piper::SampleType::ONE_SAMPLE_PER_STEP:
             return Vamp::Plugin::OutputDescriptor::OneSamplePerStep;
-        case SampleType::FIXED_SAMPLE_RATE:
+        case piper::SampleType::FIXED_SAMPLE_RATE:
             return Vamp::Plugin::OutputDescriptor::FixedSampleRate;
-        case SampleType::VARIABLE_SAMPLE_RATE:
+        case piper::SampleType::VARIABLE_SAMPLE_RATE:
             return Vamp::Plugin::OutputDescriptor::VariableSampleRate;
         }
         throw std::logic_error("unexpected Capnp SampleType enum value");
     }
 
     static void
-    buildConfiguredOutputDescriptor(ConfiguredOutputDescriptor::Builder &b,
+    buildConfiguredOutputDescriptor(piper::ConfiguredOutputDescriptor::Builder &b,
                                     const Vamp::Plugin::OutputDescriptor &od) {
 
         b.setUnit(od.unit);
 
         b.setSampleType(fromSampleType(od.sampleType));

             b.setQuantizeStep(od.quantizeStep);
         }
     }
 
     static void
-    buildOutputDescriptor(OutputDescriptor::Builder &b,
+    buildOutputDescriptor(piper::OutputDescriptor::Builder &b,
                           const Vamp::Plugin::OutputDescriptor &od) {
 
         auto basic = b.initBasic();
         buildBasicDescriptor(basic, od);
 

         buildConfiguredOutputDescriptor(configured, od);
     }
     
     static void
     readConfiguredOutputDescriptor(Vamp::Plugin::OutputDescriptor &od,
-                                   const ConfiguredOutputDescriptor::Reader &r) {
+                                   const piper::ConfiguredOutputDescriptor::Reader &r) {
 
         od.unit = r.getUnit();
 
         od.sampleType = toSampleType(r.getSampleType());
         od.sampleRate = r.getSampleRate();

         }
     }
 
     static void
     readOutputDescriptor(Vamp::Plugin::OutputDescriptor &od,
-                         const OutputDescriptor::Reader &r) {
+                         const piper::OutputDescriptor::Reader &r) {
 
         readBasicDescriptor(od, r.getBasic());
         readConfiguredOutputDescriptor(od, r.getConfigured());
     }
 
     static void
-    buildParameterDescriptor(ParameterDescriptor::Builder &b,
+    buildParameterDescriptor(piper::ParameterDescriptor::Builder &b,
                              const Vamp::Plugin::ParameterDescriptor &pd) {
 
         auto basic = b.initBasic();
         buildBasicDescriptor(basic, pd);
 

         }
     }
 
     static void
     readParameterDescriptor(Vamp::Plugin::ParameterDescriptor &pd,
-                            const ParameterDescriptor::Reader &r) {
+                            const piper::ParameterDescriptor::Reader &r) {
 
         readBasicDescriptor(pd, r.getBasic());
 
         pd.unit = r.getUnit();
 

             pd.valueNames.push_back(n);
         }
     }
     
     static void
-    buildFeature(Feature::Builder &b,
+    buildFeature(piper::Feature::Builder &b,
                  const Vamp::Plugin::Feature &f) {
 
         b.setHasTimestamp(f.hasTimestamp);
         if (f.hasTimestamp) {
             auto timestamp = b.initTimestamp();

         }
     }
 
     static void
     readFeature(Vamp::Plugin::Feature &f,
-                const Feature::Reader &r) {
+                const piper::Feature::Reader &r) {
 
         f.hasTimestamp = r.getHasTimestamp();
         if (f.hasTimestamp) {
             readRealTime(f.timestamp, r.getTimestamp());
         }

             f.values.push_back(v);
         }
     }
     
     static void
-    buildFeatureSet(FeatureSet::Builder &b,
+    buildFeatureSet(piper::FeatureSet::Builder &b,
                     const Vamp::Plugin::FeatureSet &fs,
                     const PluginOutputIdMapper &omapper) {
 
         auto featureset = b.initFeaturePairs(fs.size());
         int ix = 0;

         }
     }
 
     static void
     readFeatureSet(Vamp::Plugin::FeatureSet &fs,
-                   const FeatureSet::Reader &r,
+                   const piper::FeatureSet::Reader &r,
                    const PluginOutputIdMapper &omapper) {
 
         fs.clear();
         auto pp = r.getFeaturePairs();
         for (const auto &p: pp) {

             }
             fs[omapper.idToIndex(p.getOutput())] = vfl;
         }
     }
     
-    static InputDomain
+    static piper::InputDomain
     fromInputDomain(Vamp::Plugin::InputDomain d) {
         switch(d) {
         case Vamp::Plugin::TimeDomain:
-            return InputDomain::TIME_DOMAIN;
+            return piper::InputDomain::TIME_DOMAIN;
         case Vamp::Plugin::FrequencyDomain:
-            return InputDomain::FREQUENCY_DOMAIN;
+            return piper::InputDomain::FREQUENCY_DOMAIN;
         default:
             throw std::logic_error("unexpected Vamp InputDomain enum value");
         }
     }
 
     static Vamp::Plugin::InputDomain
-    toInputDomain(InputDomain d) {
+    toInputDomain(piper::InputDomain d) {
         switch(d) {
-        case InputDomain::TIME_DOMAIN:
+        case piper::InputDomain::TIME_DOMAIN:
             return Vamp::Plugin::TimeDomain;
-        case InputDomain::FREQUENCY_DOMAIN:
+        case piper::InputDomain::FREQUENCY_DOMAIN:
             return Vamp::Plugin::FrequencyDomain;
         default:
             throw std::logic_error("unexpected Capnp InputDomain enum value");
         }
     }
     
     static void
-    buildExtractorStaticData(ExtractorStaticData::Builder &b,
-                             const Vamp::HostExt::PluginStaticData &d) {
+    buildExtractorStaticData(piper::ExtractorStaticData::Builder &b,
+                             const PluginStaticData &d) {
 
         b.setKey(d.pluginKey);
 
         auto basic = b.initBasic();
         buildBasicDescriptor(basic, d.basic);

             buildBasicDescriptor(od, vouts[i]);
         }
     }
 
     static void
-    readExtractorStaticData(Vamp::HostExt::PluginStaticData &d,
-                            const ExtractorStaticData::Reader &r) {
+    readExtractorStaticData(PluginStaticData &d,
+                            const piper::ExtractorStaticData::Reader &r) {
         
         d.pluginKey = r.getKey();
 
         readBasicDescriptor(d.basic, r.getBasic());
 

         d.inputDomain = toInputDomain(r.getInputDomain());
 
         d.basicOutputInfo.clear();
         auto oo = r.getBasicOutputInfo();
         for (auto o: oo) {
-            Vamp::HostExt::PluginStaticData::Basic b;
+            PluginStaticData::Basic b;
             readBasicDescriptor(b, o);
             d.basicOutputInfo.push_back(b);
         }
     }
 
     static void
-    buildConfiguration(Configuration::Builder &b,
-                       const Vamp::HostExt::PluginConfiguration &c) {
+    buildConfiguration(piper::Configuration::Builder &b,
+                       const PluginConfiguration &c) {
 
         const auto &vparams = c.parameterValues;
         auto params = b.initParameterValues(vparams.size());
         int i = 0;
         for (const auto &pp : vparams) {

         b.setStepSize(c.stepSize);
         b.setBlockSize(c.blockSize);
     }
 
     static void
-    readConfiguration(Vamp::HostExt::PluginConfiguration &c,
-                      const Configuration::Reader &r) {
+    readConfiguration(PluginConfiguration &c,
+                      const piper::Configuration::Reader &r) {
 
         auto pp = r.getParameterValues();
         for (const auto &p: pp) {
             c.parameterValues[p.getParameter()] = p.getValue();
         }

         c.stepSize = r.getStepSize();
         c.blockSize = r.getBlockSize();
     }
 
     static void
-    readListResponse(Vamp::HostExt::ListResponse &lr,
-                     const ListResponse::Reader &r) {
+    readListResponse(ListResponse &lr,
+                     const piper::ListResponse::Reader &r) {
 
         lr.available.clear();
         auto pp = r.getAvailable();
         for (const auto &p: pp) {
-            Vamp::HostExt::PluginStaticData psd;
+            PluginStaticData psd;
             readExtractorStaticData(psd, p);
             lr.available.push_back(psd);
         }
     }
 
     static void
-    buildLoadRequest(LoadRequest::Builder &r,
-                     const Vamp::HostExt::LoadRequest &req) {
+    buildLoadRequest(piper::LoadRequest::Builder &r,
+                     const LoadRequest &req) {
 
         r.setKey(req.pluginKey);
         r.setInputSampleRate(req.inputSampleRate);
 
-        std::vector<AdapterFlag> flags;
+        std::vector<piper::AdapterFlag> flags;
         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN) {
-            flags.push_back(AdapterFlag::ADAPT_INPUT_DOMAIN);
+            flags.push_back(piper::AdapterFlag::ADAPT_INPUT_DOMAIN);
         }
         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT) {
-            flags.push_back(AdapterFlag::ADAPT_CHANNEL_COUNT);
+            flags.push_back(piper::AdapterFlag::ADAPT_CHANNEL_COUNT);
         }
         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE) {
-            flags.push_back(AdapterFlag::ADAPT_BUFFER_SIZE);
+            flags.push_back(piper::AdapterFlag::ADAPT_BUFFER_SIZE);
         }
 
         auto f = r.initAdapterFlags(flags.size());
         for (size_t i = 0; i < flags.size(); ++i) {
             f.set(i, flags[i]);
         }
     }
 
     static void
-    readLoadRequest(Vamp::HostExt::LoadRequest &req,
-                    const LoadRequest::Reader &r) {
+    readLoadRequest(LoadRequest &req,
+                    const piper::LoadRequest::Reader &r) {
 
         req.pluginKey = r.getKey();
         req.inputSampleRate = r.getInputSampleRate();
 
         int flags = 0;
         auto aa = r.getAdapterFlags();
         for (auto a: aa) {
-            if (a == AdapterFlag::ADAPT_INPUT_DOMAIN) {
+            if (a == piper::AdapterFlag::ADAPT_INPUT_DOMAIN) {
                 flags |= Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN;
             }
-            if (a == AdapterFlag::ADAPT_CHANNEL_COUNT) {
+            if (a == piper::AdapterFlag::ADAPT_CHANNEL_COUNT) {
                 flags |= Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT;
             }
-            if (a == AdapterFlag::ADAPT_BUFFER_SIZE) {
+            if (a == piper::AdapterFlag::ADAPT_BUFFER_SIZE) {
                 flags |= Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE;
             }
         }
         req.adapterFlags = flags;
     }
 
     static void
-    buildLoadResponse(LoadResponse::Builder &b,
-                      const Vamp::HostExt::LoadResponse &resp,
+    buildLoadResponse(piper::LoadResponse::Builder &b,
+                      const LoadResponse &resp,
                       const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(resp.plugin));
         auto sd = b.initStaticData();
         buildExtractorStaticData(sd, resp.staticData);
         auto conf = b.initDefaultConfiguration();
         buildConfiguration(conf, resp.defaultConfiguration);
     }
 
     static void
-    readLoadResponse(Vamp::HostExt::LoadResponse &resp,
-                     const LoadResponse::Reader &r,
+    readLoadResponse(LoadResponse &resp,
+                     const piper::LoadResponse::Reader &r,
                      const PluginHandleMapper &pmapper) {
 
         resp.plugin = pmapper.handleToPlugin(r.getHandle());
         readExtractorStaticData(resp.staticData, r.getStaticData());
         readConfiguration(resp.defaultConfiguration,
                           r.getDefaultConfiguration());
     }
 
     static void
-    buildConfigurationRequest(ConfigurationRequest::Builder &b,
-                              const Vamp::HostExt::ConfigurationRequest &cr,
+    buildConfigurationRequest(piper::ConfigurationRequest::Builder &b,
+                              const ConfigurationRequest &cr,
                               const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(cr.plugin));
         auto c = b.initConfiguration();
         buildConfiguration(c, cr.configuration);
     }
 
     static void
-    readConfigurationRequest(Vamp::HostExt::ConfigurationRequest &cr,
-                             const ConfigurationRequest::Reader &r,
+    readConfigurationRequest(ConfigurationRequest &cr,
+                             const piper::ConfigurationRequest::Reader &r,
                              const PluginHandleMapper &pmapper) {
 
         auto h = r.getHandle();
         cr.plugin = pmapper.handleToPlugin(h);
         auto c = r.getConfiguration();
         readConfiguration(cr.configuration, c);
     }
 
     static void
-    buildConfigurationResponse(ConfigurationResponse::Builder &b,
-                               const Vamp::HostExt::ConfigurationResponse &cr,
+    buildConfigurationResponse(piper::ConfigurationResponse::Builder &b,
+                               const ConfigurationResponse &cr,
                                const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(cr.plugin));
         auto olist = b.initOutputs(cr.outputs.size());
         for (size_t i = 0; i < cr.outputs.size(); ++i) {

             buildOutputDescriptor(od, cr.outputs[i]);
         }
     }
 
     static void
-    readConfigurationResponse(Vamp::HostExt::ConfigurationResponse &cr,
-                              const ConfigurationResponse::Reader &r,
+    readConfigurationResponse(ConfigurationResponse &cr,
+                              const piper::ConfigurationResponse::Reader &r,
                               const PluginHandleMapper &pmapper) {
 
         cr.plugin = pmapper.handleToPlugin(r.getHandle());
         cr.outputs.clear();
         auto oo = r.getOutputs();

             cr.outputs.push_back(desc);
         }
     }
 
     static void
-    buildProcessInput(ProcessInput::Builder &b,
+    buildProcessInput(piper::ProcessInput::Builder &b,
                       Vamp::RealTime timestamp,
                       const std::vector<std::vector<float> > &buffers) {
 
         auto t = b.initTimestamp();
         buildRealTime(t, timestamp);

     }
     
     static void
     readProcessInput(Vamp::RealTime &timestamp,
                      std::vector<std::vector<float> > &buffers,
-                     const ProcessInput::Reader &b) {
+                     const piper::ProcessInput::Reader &b) {
 
         readRealTime(timestamp, b.getTimestamp());
         buffers.clear();
         auto vv = b.getInputBuffers();
         for (const auto &v: vv) {

             buffers.push_back(buf);
         }
     }
     
     static void
-    buildProcessRequest(ProcessRequest::Builder &b,
-                        const Vamp::HostExt::ProcessRequest &pr,
+    buildProcessRequest(piper::ProcessRequest::Builder &b,
+                        const ProcessRequest &pr,
                         const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(pr.plugin));
         auto input = b.initProcessInput();
         buildProcessInput(input, pr.timestamp, pr.inputBuffers);
     }
 
     static void
-    readProcessRequest(Vamp::HostExt::ProcessRequest &pr,
-                       const ProcessRequest::Reader &r,
+    readProcessRequest(ProcessRequest &pr,
+                       const piper::ProcessRequest::Reader &r,
                        const PluginHandleMapper &pmapper) {
 
         auto h = r.getHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readProcessInput(pr.timestamp, pr.inputBuffers, r.getProcessInput());
     }
 
     static void
-    buildProcessResponse(ProcessResponse::Builder &b,
-                         const Vamp::HostExt::ProcessResponse &pr,
+    buildProcessResponse(piper::ProcessResponse::Builder &b,
+                         const ProcessResponse &pr,
                          const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(pr.plugin));
         auto f = b.initFeatures();
         buildFeatureSet(f, pr.features,
                         *pmapper.pluginToOutputIdMapper(pr.plugin));
     }
     
     static void
-    readProcessResponse(Vamp::HostExt::ProcessResponse &pr,
-                        const ProcessResponse::Reader &r,
+    readProcessResponse(ProcessResponse &pr,
+                        const piper::ProcessResponse::Reader &r,
                         const PluginHandleMapper &pmapper) {
 
         auto h = r.getHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readFeatureSet(pr.features, r.getFeatures(),
                        *pmapper.handleToOutputIdMapper(r.getHandle()));
     }
 
     static void
-    buildFinishResponse(FinishResponse::Builder &b,
-                        const Vamp::HostExt::ProcessResponse &pr,
+    buildFinishResponse(piper::FinishResponse::Builder &b,
+                        const FinishResponse &pr,
                         const PluginHandleMapper &pmapper) {
 
         b.setHandle(pmapper.pluginToHandle(pr.plugin));
         auto f = b.initFeatures();
         buildFeatureSet(f, pr.features,
                         *pmapper.pluginToOutputIdMapper(pr.plugin));
     }
     
     static void
-    readFinishResponse(Vamp::HostExt::ProcessResponse &pr,
-                       const FinishResponse::Reader &r,
+    readFinishResponse(FinishResponse &pr,
+                       const piper::FinishResponse::Reader &r,
                        const PluginHandleMapper &pmapper) {
 
         auto h = r.getHandle();
         pr.plugin = pmapper.handleToPlugin(h);
         readFeatureSet(pr.features, r.getFeatures(),
                        *pmapper.handleToOutputIdMapper(r.getHandle()));
     }
 
     static void
-    buildRpcRequest_List(RpcRequest::Builder &b) {
+    buildRpcRequest_List(piper::RpcRequest::Builder &b) {
         b.getRequest().initList();
     }
 
     static void
-    buildRpcResponse_List(RpcResponse::Builder &b,
-                          const Vamp::HostExt::ListResponse &resp) {
+    buildRpcResponse_List(piper::RpcResponse::Builder &b,
+                          const ListResponse &resp) {
 
         auto r = b.getResponse().initList();
         auto p = r.initAvailable(resp.available.size());
         for (size_t i = 0; i < resp.available.size(); ++i) {
             auto pd = p[i];
             buildExtractorStaticData(pd, resp.available[i]);
         }
     }
     
     static void
-    buildRpcRequest_Load(RpcRequest::Builder &b,
-                         const Vamp::HostExt::LoadRequest &req) {
+    buildRpcRequest_Load(piper::RpcRequest::Builder &b,
+                         const LoadRequest &req) {
         auto u = b.getRequest().initLoad();
         buildLoadRequest(u, req);
     }
 
     static void
-    buildRpcResponse_Load(RpcResponse::Builder &b,
-                          const Vamp::HostExt::LoadResponse &resp,
+    buildRpcResponse_Load(piper::RpcResponse::Builder &b,
+                          const LoadResponse &resp,
                           const PluginHandleMapper &pmapper) {
 
         if (resp.plugin) {
             auto u = b.getResponse().initLoad();
             buildLoadResponse(u, resp, pmapper);

             buildRpcResponse_Error(b, "Failed to load plugin", RRType::Load);
         }
     }
 
     static void
-    buildRpcRequest_Configure(RpcRequest::Builder &b,
-                              const Vamp::HostExt::ConfigurationRequest &cr,
+    buildRpcRequest_Configure(piper::RpcRequest::Builder &b,
+                              const ConfigurationRequest &cr,
                               const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initConfigure();
         buildConfigurationRequest(u, cr, pmapper);
     }
 
     static void
-    buildRpcResponse_Configure(RpcResponse::Builder &b,
-                               const Vamp::HostExt::ConfigurationResponse &cr,
+    buildRpcResponse_Configure(piper::RpcResponse::Builder &b,
+                               const ConfigurationResponse &cr,
                                const PluginHandleMapper &pmapper) {
 
         if (!cr.outputs.empty()) {
             auto u = b.getResponse().initConfigure();
             buildConfigurationResponse(u, cr, pmapper);

                                    RRType::Configure);
         }
     }
     
     static void
-    buildRpcRequest_Process(RpcRequest::Builder &b,
-                            const Vamp::HostExt::ProcessRequest &pr,
+    buildRpcRequest_Process(piper::RpcRequest::Builder &b,
+                            const ProcessRequest &pr,
                             const PluginHandleMapper &pmapper) {
         auto u = b.getRequest().initProcess();
         buildProcessRequest(u, pr, pmapper);
     }
     
     static void
-    buildRpcResponse_Process(RpcResponse::Builder &b,
-                             const Vamp::HostExt::ProcessResponse &pr,
+    buildRpcResponse_Process(piper::RpcResponse::Builder &b,
+                             const ProcessResponse &pr,
                              const PluginHandleMapper &pmapper) {
 
         auto u = b.getResponse().initProcess();
         buildProcessResponse(u, pr, pmapper);
     }
     
     static void
-    buildRpcRequest_Finish(RpcRequest::Builder &b,
-                           const Vamp::HostExt::FinishRequest &req,
+    buildRpcRequest_Finish(piper::RpcRequest::Builder &b,
+                           const FinishRequest &req,
                            const PluginHandleMapper &pmapper) {
 
         auto u = b.getRequest().initFinish();
         u.setHandle(pmapper.pluginToHandle(req.plugin));
     }
     
     static void
-    buildRpcResponse_Finish(RpcResponse::Builder &b,
-                            const Vamp::HostExt::ProcessResponse &pr,
+    buildRpcResponse_Finish(piper::RpcResponse::Builder &b,
+                            const FinishResponse &pr,
                             const PluginHandleMapper &pmapper) {
 
         auto u = b.getResponse().initFinish();
         buildFinishResponse(u, pr, pmapper);
     }
 
     static void
-    buildRpcResponse_Error(RpcResponse::Builder &b,
+    buildRpcResponse_Error(piper::RpcResponse::Builder &b,
                            const std::string &errorText,
                            RRType responseType)
     {
         std::string type;
 

         e.setCode(0);
         e.setMessage(std::string("error in ") + type + " request: " + errorText);
     }
 
     static void
-    buildRpcResponse_Exception(RpcResponse::Builder &b,
+    buildRpcResponse_Exception(piper::RpcResponse::Builder &b,
                                const std::exception &e,
                                RRType responseType)
     {
         return buildRpcResponse_Error(b, e.what(), responseType);
     }
     
     static RRType
-    getRequestResponseType(const RpcRequest::Reader &r) {
+    getRequestResponseType(const piper::RpcRequest::Reader &r) {
         switch (r.getRequest().which()) {
-        case RpcRequest::Request::Which::LIST:
+        case piper::RpcRequest::Request::Which::LIST:
             return RRType::List;
-        case RpcRequest::Request::Which::LOAD:
+        case piper::RpcRequest::Request::Which::LOAD:
             return RRType::Load;
-        case RpcRequest::Request::Which::CONFIGURE:
+        case piper::RpcRequest::Request::Which::CONFIGURE:
             return RRType::Configure;
-        case RpcRequest::Request::Which::PROCESS:
+        case piper::RpcRequest::Request::Which::PROCESS:
             return RRType::Process;
-        case RpcRequest::Request::Which::FINISH:
+        case piper::RpcRequest::Request::Which::FINISH:
             return RRType::Finish;
         }
         return RRType::NotValid;
     }
 
     static RRType
-    getRequestResponseType(const RpcResponse::Reader &r) {
+    getRequestResponseType(const piper::RpcResponse::Reader &r) {
         switch (r.getResponse().which()) {
-        case RpcResponse::Response::Which::ERROR:
+        case piper::RpcResponse::Response::Which::ERROR:
             return RRType::NotValid; //!!! or error type? test this
-        case RpcResponse::Response::Which::LIST:
+        case piper::RpcResponse::Response::Which::LIST:
             return RRType::List;
-        case RpcResponse::Response::Which::LOAD:
+        case piper::RpcResponse::Response::Which::LOAD:
             return RRType::Load;
-        case RpcResponse::Response::Which::CONFIGURE:
+        case piper::RpcResponse::Response::Which::CONFIGURE:
             return RRType::Configure;
-        case RpcResponse::Response::Which::PROCESS:
+        case piper::RpcResponse::Response::Which::PROCESS:
             return RRType::Process;
-        case RpcResponse::Response::Which::FINISH:
+        case piper::RpcResponse::Response::Which::FINISH:
             return RRType::Finish;
         }
         return RRType::NotValid;
     }
     
     static void
     readRpcResponse_Error(int &code,
                           std::string &message,
-                          const RpcResponse::Reader &r) {
+                          const piper::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) {
+    readRpcRequest_List(const piper::RpcRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list request");
         }
     }
 
     static void
-    readRpcResponse_List(Vamp::HostExt::ListResponse &resp,
-                         const RpcResponse::Reader &r) {
+    readRpcResponse_List(ListResponse &resp,
+                         const piper::RpcResponse::Reader &r) {
         if (getRequestResponseType(r) != RRType::List) {
             throw std::logic_error("not a list response");
         }
         readListResponse(resp, r.getResponse().getList());
     }
     
     static void
-    readRpcRequest_Load(Vamp::HostExt::LoadRequest &req,
-                        const RpcRequest::Reader &r) {
+    readRpcRequest_Load(LoadRequest &req,
+                        const piper::RpcRequest::Reader &r) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load request");
         }
         readLoadRequest(req, r.getRequest().getLoad());
     }
 
     static void
-    readRpcResponse_Load(Vamp::HostExt::LoadResponse &resp,
-                         const RpcResponse::Reader &r,
+    readRpcResponse_Load(LoadResponse &resp,
+                         const piper::RpcResponse::Reader &r,
                          const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Load) {
             throw std::logic_error("not a load response");
         }
         resp = {};
         readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
     }
     
     static void
-    readRpcRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
-                             const RpcRequest::Reader &r,
+    readRpcRequest_Configure(ConfigurationRequest &req,
+                             const piper::RpcRequest::Reader &r,
                              const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration request");
         }
         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
     }
 
     static void
-    readRpcResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
-                              const RpcResponse::Reader &r,
+    readRpcResponse_Configure(ConfigurationResponse &resp,
+                              const piper::RpcResponse::Reader &r,
                               const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Configure) {
             throw std::logic_error("not a configuration response");
         }
         resp = {};

                                   r.getResponse().getConfigure(),
                                   pmapper);
     }
     
     static void
-    readRpcRequest_Process(Vamp::HostExt::ProcessRequest &req,
-                           const RpcRequest::Reader &r,
+    readRpcRequest_Process(ProcessRequest &req,
+                           const piper::RpcRequest::Reader &r,
                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process request");
         }
         readProcessRequest(req, r.getRequest().getProcess(), pmapper);
     }
 
     static void
-    readRpcResponse_Process(Vamp::HostExt::ProcessResponse &resp,
-                            const RpcResponse::Reader &r,
+    readRpcResponse_Process(ProcessResponse &resp,
+                            const piper::RpcResponse::Reader &r,
                             const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Process) {
             throw std::logic_error("not a process response");
         }
         resp = {};
         readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
     }
     
     static void
-    readRpcRequest_Finish(Vamp::HostExt::FinishRequest &req,
-                          const RpcRequest::Reader &r,
+    readRpcRequest_Finish(FinishRequest &req,
+                          const piper::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().getHandle());
     }
 
     static void
-    readRpcResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
-                           const RpcResponse::Reader &r,
+    readRpcResponse_Finish(FinishResponse &resp,
+                           const piper::RpcResponse::Reader &r,
                            const PluginHandleMapper &pmapper) {
         if (getRequestResponseType(r) != RRType::Finish) {
             throw std::logic_error("not a finish response");
         }
         resp = {};