c@5: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
c@5: 
c@18: /*
c@18:     VamPipe
c@18: 
c@18:     Centre for Digital Music, Queen Mary, University of London.
c@18:     Copyright 2015-2016 QMUL.
c@18:   
c@18:     Permission is hereby granted, free of charge, to any person
c@18:     obtaining a copy of this software and associated documentation
c@18:     files (the "Software"), to deal in the Software without
c@18:     restriction, including without limitation the rights to use, copy,
c@18:     modify, merge, publish, distribute, sublicense, and/or sell copies
c@18:     of the Software, and to permit persons to whom the Software is
c@18:     furnished to do so, subject to the following conditions:
c@18: 
c@18:     The above copyright notice and this permission notice shall be
c@18:     included in all copies or substantial portions of the Software.
c@18: 
c@18:     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
c@18:     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
c@18:     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
c@18:     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
c@18:     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
c@18:     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
c@18:     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
c@18: 
c@18:     Except as contained in this notice, the names of the Centre for
c@18:     Digital Music; Queen Mary, University of London; and Chris Cannam
c@18:     shall not be used in advertising or otherwise to promote the sale,
c@18:     use or other dealings in this Software without prior written
c@18:     authorization.
c@18: */
c@18: 
c@5: #include "vamp.capnp.h"
c@5: 
c@5: #include <capnp/message.h>
c@5: #include <capnp/serialize-packed.h>
c@5: 
c@5: #include <vamp-hostsdk/Plugin.h>
c@5: #include <vamp-hostsdk/PluginLoader.h>
c@5: #include <vamp-hostsdk/PluginStaticData.h>
c@5: 
c@10: #include "bits/PluginHandleMapper.h"
c@49: #include "bits/PluginOutputIdMapper.h"
c@26: #include "bits/RequestResponseType.h"
c@10: 
c@5: namespace vampipe
c@5: {
c@5: 
c@5: /**
c@5:  * Convert the structures laid out in the Vamp SDK classes into Cap'n
c@6:  * Proto structures (and back again).
c@5:  * 
c@6:  * At least some of this will be necessary for any implementation
c@6:  * using Cap'n Proto that uses the C++ Vamp SDK to provide its
c@6:  * reference structures. An implementation could alternatively use the
c@6:  * Cap'n Proto structures directly, and interact with Vamp plugins
c@6:  * using the Vamp C API, without using the C++ Vamp SDK classes at
c@18:  * all. That would avoid a lot of copying (in Cap'n Proto style).
c@5:  */
c@6: class VampnProto
c@5: {
c@5: public:
c@5:     typedef ::capnp::MallocMessageBuilder MsgBuilder;
c@5: 
c@5:     template <typename T, typename B>
c@5:     static void buildBasicDescriptor(B &basic, const T &t) {
c@5:         basic.setIdentifier(t.identifier);
c@5:         basic.setName(t.name);
c@5:         basic.setDescription(t.description);
c@5:     }
c@5: 
c@5:     template <typename T, typename B>
c@5:     static void readBasicDescriptor(T &t, const B &basic) {
c@5:         t.identifier = basic.getIdentifier();
c@5:         t.name = basic.getName();
c@5:         t.description = basic.getDescription();
c@5:     }
c@5: 
c@5:     template <typename T, typename M>
c@5:     static void buildValueExtents(M &m, const T &t) {
c@5:         m.setMinValue(t.minValue);
c@5:         m.setMaxValue(t.maxValue);
c@5:     }
c@5: 
c@5:     template <typename T, typename M>
c@5:     static void readValueExtents(T &t, const M &m) {
c@5:         t.minValue = m.getMinValue();
c@5:         t.maxValue = m.getMaxValue();
c@5:     }
c@5: 
c@5:     static void buildRealTime(RealTime::Builder &b, const Vamp::RealTime &t) {
c@5:         b.setSec(t.sec);
c@5:         b.setNsec(t.nsec);
c@5:     }
c@5: 
c@5:     static void readRealTime(Vamp::RealTime &t, const RealTime::Reader &r) {
c@5:         t.sec = r.getSec();
c@5:         t.nsec = r.getNsec();
c@5:     }
c@5: 
c@5:     static SampleType
c@5:     fromSampleType(Vamp::Plugin::OutputDescriptor::SampleType t) {
c@5:         switch (t) {
c@5:         case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
c@5:             return SampleType::ONE_SAMPLE_PER_STEP;
c@5:         case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
c@5:             return SampleType::FIXED_SAMPLE_RATE;
c@5:         case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
c@5:             return SampleType::VARIABLE_SAMPLE_RATE;
c@5:         }
c@5:         throw std::logic_error("unexpected Vamp SampleType enum value");
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::OutputDescriptor::SampleType
c@5:     toSampleType(SampleType t) {
c@5:         switch (t) {
c@5:         case SampleType::ONE_SAMPLE_PER_STEP:
c@5:             return Vamp::Plugin::OutputDescriptor::OneSamplePerStep;
c@5:         case SampleType::FIXED_SAMPLE_RATE:
c@5:             return Vamp::Plugin::OutputDescriptor::FixedSampleRate;
c@5:         case SampleType::VARIABLE_SAMPLE_RATE:
c@5:             return Vamp::Plugin::OutputDescriptor::VariableSampleRate;
c@5:         }
c@5:         throw std::logic_error("unexpected Capnp SampleType enum value");
c@5:     }
c@5: 
c@5:     static void
c@5:     buildOutputDescriptor(OutputDescriptor::Builder &b,
c@5:                           const Vamp::Plugin::OutputDescriptor &od) {
c@5: 
c@5:         auto basic = b.initBasic();
c@5:         buildBasicDescriptor(basic, od);
c@5: 
c@5:         b.setUnit(od.unit);
c@5: 
c@5:         b.setSampleType(fromSampleType(od.sampleType));
c@5:         b.setSampleRate(od.sampleRate);
c@5:         b.setHasDuration(od.hasDuration);
c@5: 
c@5:         b.setHasFixedBinCount(od.hasFixedBinCount);
c@5:         if (od.hasFixedBinCount) {
c@5:             b.setBinCount(od.binCount);
c@5:             if (od.binNames.size() > 0) {
c@5:                 auto binNames = b.initBinNames(od.binNames.size());
c@5:                 for (size_t i = 0; i < od.binNames.size(); ++i) {
c@5:                     binNames.set(i, od.binNames[i]);
c@5:                 }
c@5:             }
c@5:         }
c@5: 
c@5:         b.setHasKnownExtents(od.hasKnownExtents);
c@5:         if (od.hasKnownExtents) {
c@5:             buildValueExtents(b, od);
c@5:         }
c@5: 
c@5:         b.setIsQuantized(od.isQuantized);
c@5:         if (od.isQuantized) {
c@5:             b.setQuantizeStep(od.quantizeStep);
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readOutputDescriptor(Vamp::Plugin::OutputDescriptor &od,
c@5:                          const OutputDescriptor::Reader &r) {
c@5: 
c@5:         readBasicDescriptor(od, r.getBasic());
c@5: 
c@5:         od.unit = r.getUnit();
c@5: 
c@5:         od.sampleType = toSampleType(r.getSampleType());
c@5:         od.sampleRate = r.getSampleRate();
c@5:         od.hasDuration = r.getHasDuration();
c@5: 
c@5:         od.hasFixedBinCount = r.getHasFixedBinCount();
c@5:         if (od.hasFixedBinCount) {
c@5:             od.binCount = r.getBinCount();
c@13:             od.binNames.clear();
c@28:             auto nn = r.getBinNames();
c@28:             for (const auto &n: nn) {
c@5:                 od.binNames.push_back(n);
c@5:             }
c@5:         }
c@5: 
c@5:         od.hasKnownExtents = r.getHasKnownExtents();
c@5:         if (od.hasKnownExtents) {
c@5:             readValueExtents(od, r);
c@5:         }
c@5: 
c@5:         od.isQuantized = r.getIsQuantized();
c@5:         if (od.isQuantized) {
c@5:             od.quantizeStep = r.getQuantizeStep();
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     buildParameterDescriptor(ParameterDescriptor::Builder &b,
c@5:                              const Vamp::Plugin::ParameterDescriptor &pd) {
c@5: 
c@5:         auto basic = b.initBasic();
c@5:         buildBasicDescriptor(basic, pd);
c@5: 
c@5:         b.setUnit(pd.unit);
c@5: 
c@5:         buildValueExtents(b, pd);
c@5: 
c@5:         b.setDefaultValue(pd.defaultValue);
c@5: 
c@5:         b.setIsQuantized(pd.isQuantized);
c@5:         if (pd.isQuantized) {
c@5:             b.setQuantizeStep(pd.quantizeStep);
c@5:         }
c@5:         
c@5:         if (pd.valueNames.size() > 0) {
c@5:             auto valueNames = b.initValueNames(pd.valueNames.size());
c@5:             for (size_t i = 0; i < pd.valueNames.size(); ++i) {
c@5:                 valueNames.set(i, pd.valueNames[i]);
c@5:             }
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readParameterDescriptor(Vamp::Plugin::ParameterDescriptor &pd,
c@5:                             const ParameterDescriptor::Reader &r) {
c@5: 
c@5:         readBasicDescriptor(pd, r.getBasic());
c@5: 
c@5:         pd.unit = r.getUnit();
c@5: 
c@5:         readValueExtents(pd, r);
c@5: 
c@5:         pd.defaultValue = r.getDefaultValue();
c@5: 
c@5:         pd.isQuantized = r.getIsQuantized();
c@5:         if (pd.isQuantized) {
c@5:             pd.quantizeStep = r.getQuantizeStep();
c@5:         }
c@5: 
c@13:         pd.valueNames.clear();
c@28:         auto nn = r.getValueNames();
c@28:         for (const auto &n: nn) {
c@5:             pd.valueNames.push_back(n);
c@5:         }
c@5:     }
c@5:     
c@5:     static void
c@5:     buildFeature(Feature::Builder &b,
c@5:                  const Vamp::Plugin::Feature &f) {
c@5: 
c@5:         b.setHasTimestamp(f.hasTimestamp);
c@5:         if (f.hasTimestamp) {
c@5:             auto timestamp = b.initTimestamp();
c@5:             buildRealTime(timestamp, f.timestamp);
c@5:         }
c@5: 
c@5:         b.setHasDuration(f.hasDuration);
c@5:         if (f.hasDuration) {
c@5:             auto duration = b.initDuration();
c@5:             buildRealTime(duration, f.duration);
c@5:         }
c@5: 
c@5:         b.setLabel(f.label);
c@5: 
c@5:         if (f.values.size() > 0) {
c@5:             auto values = b.initValues(f.values.size());
c@5:             for (size_t i = 0; i < f.values.size(); ++i) {
c@5:                 values.set(i, f.values[i]);
c@5:             }
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readFeature(Vamp::Plugin::Feature &f,
c@5:                 const Feature::Reader &r) {
c@5: 
c@5:         f.hasTimestamp = r.getHasTimestamp();
c@5:         if (f.hasTimestamp) {
c@5:             readRealTime(f.timestamp, r.getTimestamp());
c@5:         }
c@5: 
c@5:         f.hasDuration = r.getHasDuration();
c@5:         if (f.hasDuration) {
c@5:             readRealTime(f.duration, r.getDuration());
c@5:         }
c@5: 
c@5:         f.label = r.getLabel();
c@5: 
c@13:         f.values.clear();
c@28:         auto vv = r.getValues();
c@28:         for (auto v: vv) {
c@5:             f.values.push_back(v);
c@5:         }
c@5:     }
c@5:     
c@5:     static void
c@5:     buildFeatureSet(FeatureSet::Builder &b,
c@49:                     const Vamp::Plugin::FeatureSet &fs,
c@49:                     const PluginOutputIdMapper &omapper) {
c@5: 
c@5:         auto featureset = b.initFeaturePairs(fs.size());
c@5:         int ix = 0;
c@5:         for (const auto &fsi : fs) {
c@5:             auto fspair = featureset[ix];
c@49:             fspair.setOutput(omapper.indexToId(fsi.first));
c@5:             auto featurelist = fspair.initFeatures(fsi.second.size());
c@5:             for (size_t j = 0; j < fsi.second.size(); ++j) {
c@5:                 auto feature = featurelist[j];
c@5:                 buildFeature(feature, fsi.second[j]);
c@5:             }
c@5:             ++ix;
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readFeatureSet(Vamp::Plugin::FeatureSet &fs,
c@49:                    const FeatureSet::Reader &r,
c@49:                    const PluginOutputIdMapper &omapper) {
c@5: 
c@13:         fs.clear();
c@28:         auto pp = r.getFeaturePairs();
c@28:         for (const auto &p: pp) {
c@5:             Vamp::Plugin::FeatureList vfl;
c@28:             auto ff = p.getFeatures();
c@28:             for (const auto &f: ff) {
c@5:                 Vamp::Plugin::Feature vf;
c@5:                 readFeature(vf, f);
c@5:                 vfl.push_back(vf);
c@5:             }
c@49:             fs[omapper.idToIndex(p.getOutput())] = vfl;
c@5:         }
c@5:     }
c@5:     
c@5:     static InputDomain
c@5:     fromInputDomain(Vamp::Plugin::InputDomain d) {
c@5:         switch(d) {
c@5:         case Vamp::Plugin::TimeDomain:
c@5:             return InputDomain::TIME_DOMAIN;
c@5:         case Vamp::Plugin::FrequencyDomain:
c@5:             return InputDomain::FREQUENCY_DOMAIN;
c@5:         default:
c@5:             throw std::logic_error("unexpected Vamp InputDomain enum value");
c@5:         }
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::InputDomain
c@5:     toInputDomain(InputDomain d) {
c@5:         switch(d) {
c@5:         case InputDomain::TIME_DOMAIN:
c@5:             return Vamp::Plugin::TimeDomain;
c@5:         case InputDomain::FREQUENCY_DOMAIN:
c@5:             return Vamp::Plugin::FrequencyDomain;
c@5:         default:
c@5:             throw std::logic_error("unexpected Capnp InputDomain enum value");
c@5:         }
c@5:     }
c@5:     
c@5:     static void
c@5:     buildPluginStaticData(PluginStaticData::Builder &b,
c@5:                           const Vamp::HostExt::PluginStaticData &d) {
c@5: 
c@5:         b.setPluginKey(d.pluginKey);
c@5: 
c@5:         auto basic = b.initBasic();
c@5:         buildBasicDescriptor(basic, d.basic);
c@5: 
c@5:         b.setMaker(d.maker);
c@5:         b.setCopyright(d.copyright);
c@5:         b.setPluginVersion(d.pluginVersion);
c@5: 
c@5:         auto clist = b.initCategory(d.category.size());
c@5:         for (size_t i = 0; i < d.category.size(); ++i) {
c@5:             clist.set(i, d.category[i]);
c@5:         }
c@5: 
c@5:         b.setMinChannelCount(d.minChannelCount);
c@5:         b.setMaxChannelCount(d.maxChannelCount);
c@5: 
c@5:         const auto &vparams = d.parameters;
c@5:         auto plist = b.initParameters(vparams.size());
c@5:         for (size_t i = 0; i < vparams.size(); ++i) {
c@5:             auto pd = plist[i];
c@5:             buildParameterDescriptor(pd, vparams[i]);
c@5:         }
c@5:         
c@5:         const auto &vprogs = d.programs;
c@5:         auto pglist = b.initPrograms(vprogs.size());
c@5:         for (size_t i = 0; i < vprogs.size(); ++i) {
c@5:             pglist.set(i, vprogs[i]);
c@5:         }
c@5: 
c@5:         b.setInputDomain(fromInputDomain(d.inputDomain));
c@5: 
c@5:         const auto &vouts = d.basicOutputInfo;
c@5:         auto olist = b.initBasicOutputInfo(vouts.size());
c@5:         for (size_t i = 0; i < vouts.size(); ++i) {
c@5:             auto od = olist[i];
c@5:             buildBasicDescriptor(od, vouts[i]);
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readPluginStaticData(Vamp::HostExt::PluginStaticData &d,
c@5:                          const PluginStaticData::Reader &r) {
c@5:         
c@5:         d.pluginKey = r.getPluginKey();
c@5: 
c@5:         readBasicDescriptor(d.basic, r.getBasic());
c@5: 
c@5:         d.maker = r.getMaker();
c@5:         d.copyright = r.getCopyright();
c@5:         d.pluginVersion = r.getPluginVersion();
c@5: 
c@13:         d.category.clear();
c@28:         auto cc = r.getCategory();
c@28:         for (auto c: cc) {
c@5:             d.category.push_back(c);
c@5:         }
c@5: 
c@5:         d.minChannelCount = r.getMinChannelCount();
c@5:         d.maxChannelCount = r.getMaxChannelCount();
c@5: 
c@13:         d.parameters.clear();
c@28:         auto pp = r.getParameters();
c@28:         for (auto p: pp) {
c@5:             Vamp::Plugin::ParameterDescriptor pd;
c@5:             readParameterDescriptor(pd, p);
c@5:             d.parameters.push_back(pd);
c@5:         }
c@5: 
c@13:         d.programs.clear();
c@28:         auto prp = r.getPrograms();
c@28:         for (auto p: prp) {
c@5:             d.programs.push_back(p);
c@5:         }
c@5: 
c@5:         d.inputDomain = toInputDomain(r.getInputDomain());
c@5: 
c@13:         d.basicOutputInfo.clear();
c@28:         auto oo = r.getBasicOutputInfo();
c@28:         for (auto o: oo) {
c@5:             Vamp::HostExt::PluginStaticData::Basic b;
c@5:             readBasicDescriptor(b, o);
c@5:             d.basicOutputInfo.push_back(b);
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     buildPluginConfiguration(PluginConfiguration::Builder &b,
c@5:                              const Vamp::HostExt::PluginConfiguration &c) {
c@5: 
c@5:         const auto &vparams = c.parameterValues;
c@5:         auto params = b.initParameterValues(vparams.size());
c@5:         int i = 0;
c@5:         for (const auto &pp : vparams) {
c@5:             auto param = params[i++];
c@5:             param.setParameter(pp.first);
c@5:             param.setValue(pp.second);
c@5:         }
c@5: 
c@5:         b.setCurrentProgram(c.currentProgram);
c@5:         b.setChannelCount(c.channelCount);
c@5:         b.setStepSize(c.stepSize);
c@5:         b.setBlockSize(c.blockSize);
c@5:     }
c@5: 
c@5:     static void
c@5:     readPluginConfiguration(Vamp::HostExt::PluginConfiguration &c,
c@5:                             const PluginConfiguration::Reader &r) {
c@5: 
c@28:         auto pp = r.getParameterValues();
c@28:         for (const auto &p: pp) {
c@28:             c.parameterValues[p.getParameter()] = p.getValue();
c@5:         }
c@5: 
c@5:         c.currentProgram = r.getCurrentProgram();
c@5:         c.channelCount = r.getChannelCount();
c@5:         c.stepSize = r.getStepSize();
c@5:         c.blockSize = r.getBlockSize();
c@5:     }
c@5: 
c@5:     static void
c@5:     buildLoadRequest(LoadRequest::Builder &r,
c@5:                      const Vamp::HostExt::LoadRequest &req) {
c@5: 
c@5:         r.setPluginKey(req.pluginKey);
c@5:         r.setInputSampleRate(req.inputSampleRate);
c@5: 
c@5:         std::vector<AdapterFlag> flags;
c@5:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN) {
c@5:             flags.push_back(AdapterFlag::ADAPT_INPUT_DOMAIN);
c@5:         }
c@5:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT) {
c@5:             flags.push_back(AdapterFlag::ADAPT_CHANNEL_COUNT);
c@5:         }
c@5:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE) {
c@5:             flags.push_back(AdapterFlag::ADAPT_BUFFER_SIZE);
c@5:         }
c@5: 
c@5:         auto f = r.initAdapterFlags(flags.size());
c@5:         for (size_t i = 0; i < flags.size(); ++i) {
c@5:             f.set(i, flags[i]);
c@5:         }
c@5:     }
c@5: 
c@5:     static void
c@5:     readLoadRequest(Vamp::HostExt::LoadRequest &req,
c@5:                     const LoadRequest::Reader &r) {
c@5: 
c@5:         req.pluginKey = r.getPluginKey();
c@5:         req.inputSampleRate = r.getInputSampleRate();
c@5: 
c@5:         int flags = 0;
c@28:         auto aa = r.getAdapterFlags();
c@28:         for (auto a: aa) {
c@5:             if (a == AdapterFlag::ADAPT_INPUT_DOMAIN) {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN;
c@5:             }
c@5:             if (a == AdapterFlag::ADAPT_CHANNEL_COUNT) {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT;
c@5:             }
c@5:             if (a == AdapterFlag::ADAPT_BUFFER_SIZE) {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE;
c@5:             }
c@5:         }
c@5:         req.adapterFlags = flags;
c@5:     }
c@10: 
c@10:     static void
c@10:     buildLoadResponse(LoadResponse::Builder &b,
c@10:                       const Vamp::HostExt::LoadResponse &resp,
c@51:                       const PluginHandleMapper &pmapper) {
c@10: 
c@49:         b.setPluginHandle(pmapper.pluginToHandle(resp.plugin));
c@10:         auto sd = b.initStaticData();
c@10:         buildPluginStaticData(sd, resp.staticData);
c@10:         auto conf = b.initDefaultConfiguration();
c@10:         buildPluginConfiguration(conf, resp.defaultConfiguration);
c@10:     }
c@10: 
c@10:     static void
c@10:     readLoadResponse(Vamp::HostExt::LoadResponse &resp,
c@10:                      const LoadResponse::Reader &r,
c@51:                      const PluginHandleMapper &pmapper) {
c@10: 
c@49:         resp.plugin = pmapper.handleToPlugin(r.getPluginHandle());
c@10:         readPluginStaticData(resp.staticData, r.getStaticData());
c@10:         readPluginConfiguration(resp.defaultConfiguration,
c@10:                                 r.getDefaultConfiguration());
c@10:     }
c@13: 
c@13:     static void
c@13:     buildConfigurationRequest(ConfigurationRequest::Builder &b,
c@13:                               const Vamp::HostExt::ConfigurationRequest &cr,
c@51:                               const PluginHandleMapper &pmapper) {
c@13: 
c@49:         b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
c@13:         auto c = b.initConfiguration();
c@13:         buildPluginConfiguration(c, cr.configuration);
c@13:     }
c@13: 
c@13:     static void
c@13:     readConfigurationRequest(Vamp::HostExt::ConfigurationRequest &cr,
c@13:                              const ConfigurationRequest::Reader &r,
c@51:                              const PluginHandleMapper &pmapper) {
c@13: 
c@13:         auto h = r.getPluginHandle();
c@49:         cr.plugin = pmapper.handleToPlugin(h);
c@13:         auto c = r.getConfiguration();
c@13:         readPluginConfiguration(cr.configuration, c);
c@13:     }
c@13: 
c@13:     static void
c@13:     buildConfigurationResponse(ConfigurationResponse::Builder &b,
c@55:                                const Vamp::HostExt::ConfigurationResponse &cr,
c@55:                                const PluginHandleMapper &pmapper) {
c@13: 
c@55:         b.setPluginHandle(pmapper.pluginToHandle(cr.plugin));
c@13:         auto olist = b.initOutputs(cr.outputs.size());
c@13:         for (size_t i = 0; i < cr.outputs.size(); ++i) {
c@13:             auto od = olist[i];
c@13:             buildOutputDescriptor(od, cr.outputs[i]);
c@13:         }
c@13:     }
c@13: 
c@13:     static void
c@13:     readConfigurationResponse(Vamp::HostExt::ConfigurationResponse &cr,
c@55:                               const ConfigurationResponse::Reader &r,
c@55:                               const PluginHandleMapper &pmapper) {
c@13: 
c@55:         cr.plugin = pmapper.handleToPlugin(r.getPluginHandle());
c@13:         cr.outputs.clear();
c@28:         auto oo = r.getOutputs();
c@28:         for (const auto &o: oo) {
c@13:             Vamp::Plugin::OutputDescriptor desc;
c@13:             readOutputDescriptor(desc, o);
c@13:             cr.outputs.push_back(desc);
c@13:         }
c@13:     }
c@14: 
c@14:     static void
c@14:     buildProcessInput(ProcessInput::Builder &b,
c@14:                       Vamp::RealTime timestamp,
c@14:                       const std::vector<std::vector<float> > &buffers) {
c@14: 
c@14:         auto t = b.initTimestamp();
c@14:         buildRealTime(t, timestamp);
c@14:         auto vv = b.initInputBuffers(buffers.size());
c@14:         for (size_t ch = 0; ch < buffers.size(); ++ch) {
c@14:             const int n = int(buffers[ch].size());
c@14:             vv.init(ch, n);
c@14:             auto v = vv[ch];
c@14:             for (int i = 0; i < n; ++i) {
c@14:                 v.set(i, buffers[ch][i]);
c@14:             }
c@14:         }
c@14:     }
c@14:     
c@14:     static void
c@14:     readProcessInput(Vamp::RealTime &timestamp,
c@14:                      std::vector<std::vector<float> > &buffers,
c@14:                      const ProcessInput::Reader &b) {
c@14: 
c@14:         readRealTime(timestamp, b.getTimestamp());
c@14:         buffers.clear();
c@28:         auto vv = b.getInputBuffers();
c@28:         for (const auto &v: vv) {
c@14:             std::vector<float> buf;
c@14:             for (auto x: v) {
c@14:                 buf.push_back(x);
c@14:             }
c@14:             buffers.push_back(buf);
c@14:         }
c@14:     }
c@14:     
c@14:     static void
c@14:     buildProcessRequest(ProcessRequest::Builder &b,
c@14:                         const Vamp::HostExt::ProcessRequest &pr,
c@51:                         const PluginHandleMapper &pmapper) {
c@14: 
c@49:         b.setPluginHandle(pmapper.pluginToHandle(pr.plugin));
c@61:         auto input = b.initProcessInput();
c@14:         buildProcessInput(input, pr.timestamp, pr.inputBuffers);
c@14:     }
c@14: 
c@14:     static void
c@14:     readProcessRequest(Vamp::HostExt::ProcessRequest &pr,
c@14:                        const ProcessRequest::Reader &r,
c@51:                        const PluginHandleMapper &pmapper) {
c@14: 
c@14:         auto h = r.getPluginHandle();
c@49:         pr.plugin = pmapper.handleToPlugin(h);
c@61:         readProcessInput(pr.timestamp, pr.inputBuffers, r.getProcessInput());
c@14:     }
c@14: 
c@14:     static void
c@15:     buildProcessResponse(ProcessResponse::Builder &b,
c@49:                          const Vamp::HostExt::ProcessResponse &pr,
c@51:                          const PluginHandleMapper &pmapper) {
c@15: 
c@52:         b.setPluginHandle(pmapper.pluginToHandle(pr.plugin));
c@15:         auto f = b.initFeatures();
c@51:         buildFeatureSet(f, pr.features,
c@57:                         *pmapper.pluginToOutputIdMapper(pr.plugin));
c@15:     }
c@15:     
c@15:     static void
c@15:     readProcessResponse(Vamp::HostExt::ProcessResponse &pr,
c@49:                         const ProcessResponse::Reader &r,
c@51:                         const PluginHandleMapper &pmapper) {
c@15: 
c@52:         auto h = r.getPluginHandle();
c@52:         pr.plugin = pmapper.handleToPlugin(h);
c@51:         readFeatureSet(pr.features, r.getFeatures(),
c@57:                        *pmapper.handleToOutputIdMapper(r.getPluginHandle()));
c@15:     }
c@15: 
c@15:     static void
c@15:     buildVampRequest_List(VampRequest::Builder &b) {
c@14:         b.getRequest().setList();
c@14:     }
c@14: 
c@14:     static void
c@15:     buildVampResponse_List(VampResponse::Builder &b,
c@56:                            const Vamp::HostExt::ListResponse &resp) {
c@56:         b.setSuccess(true);
c@24:         auto r = b.getResponse().initList();
c@56:         auto p = r.initPlugins(resp.pluginData.size());
c@56:         for (size_t i = 0; i < resp.pluginData.size(); ++i) {
c@24:             auto pd = p[i];
c@56:             buildPluginStaticData(pd, resp.pluginData[i]);
c@15:         }
c@15:     }
c@15:     
c@15:     static void
c@15:     buildVampRequest_Load(VampRequest::Builder &b,
c@15:                           const Vamp::HostExt::LoadRequest &req) {
c@14:         auto u = b.getRequest().initLoad();
c@14:         buildLoadRequest(u, req);
c@14:     }
c@14: 
c@14:     static void
c@15:     buildVampResponse_Load(VampResponse::Builder &b,
c@15:                            const Vamp::HostExt::LoadResponse &resp,
c@51:                            const PluginHandleMapper &pmapper) {
c@17:         b.setSuccess(resp.plugin != 0);
c@15:         auto u = b.getResponse().initLoad();
c@49:         buildLoadResponse(u, resp, pmapper);
c@15:     }
c@15: 
c@15:     static void
c@15:     buildVampRequest_Configure(VampRequest::Builder &b,
c@15:                                const Vamp::HostExt::ConfigurationRequest &cr,
c@51:                                const PluginHandleMapper &pmapper) {
c@14:         auto u = b.getRequest().initConfigure();
c@49:         buildConfigurationRequest(u, cr, pmapper);
c@14:     }
c@14: 
c@14:     static void
c@15:     buildVampResponse_Configure(VampResponse::Builder &b,
c@55:                                 const Vamp::HostExt::ConfigurationResponse &cr,
c@55:                                 const PluginHandleMapper &pmapper) {
c@17:         b.setSuccess(!cr.outputs.empty());
c@15:         auto u = b.getResponse().initConfigure();
c@55:         buildConfigurationResponse(u, cr, pmapper);
c@15:     }
c@15:     
c@15:     static void
c@15:     buildVampRequest_Process(VampRequest::Builder &b,
c@15:                              const Vamp::HostExt::ProcessRequest &pr,
c@51:                              const PluginHandleMapper &pmapper) {
c@14:         auto u = b.getRequest().initProcess();
c@49:         buildProcessRequest(u, pr, pmapper);
c@14:     }
c@15:     
c@15:     static void
c@15:     buildVampResponse_Process(VampResponse::Builder &b,
c@49:                               const Vamp::HostExt::ProcessResponse &pr,
c@51:                               const PluginHandleMapper &pmapper) {
c@17:         b.setSuccess(true);
c@15:         auto u = b.getResponse().initProcess();
c@51:         buildProcessResponse(u, pr, pmapper);
c@15:     }
c@17:     
c@17:     static void
c@23:     buildVampRequest_Finish(VampRequest::Builder &b,
c@55:                             const Vamp::HostExt::FinishRequest &req,
c@51:                             const PluginHandleMapper &pmapper) {
c@17: 
c@23:         auto u = b.getRequest().initFinish();
c@55:         u.setPluginHandle(pmapper.pluginToHandle(req.plugin));
c@17:     }
c@17:     
c@17:     static void
c@17:     buildVampResponse_Finish(VampResponse::Builder &b,
c@49:                              const Vamp::HostExt::ProcessResponse &pr,
c@51:                              const PluginHandleMapper &pmapper) {
c@17: 
c@51:         buildVampResponse_Process(b, pr, pmapper);
c@17:     }
c@26: 
c@52:     static void
c@52:     buildVampResponse_Error(VampResponse::Builder &b,
c@52:                             const std::string &errorText,
c@52:                             RRType responseType)
c@52:     {
c@52:         std::string type;
c@52: 
c@52:         if (responseType == RRType::List) {
c@52:             type = "list";
c@52:             b.getResponse().initList();
c@52:         } else if (responseType == RRType::Load) {
c@52:             type = "load";
c@52:             b.getResponse().initLoad();
c@52:         } else if (responseType == RRType::Configure) {
c@52:             type = "configure";
c@52:             b.getResponse().initConfigure();
c@52:         } else if (responseType == RRType::Process) {
c@52:             type = "process";
c@52:             b.getResponse().initProcess();
c@52:         } else if (responseType == RRType::Finish) {
c@52:             type = "finish";
c@52:             b.getResponse().initFinish();
c@52:         } else {
c@52:             type = "invalid";
c@52:         }
c@52: 
c@52:         b.setSuccess(false);
c@52:         b.setErrorText(std::string("error in ") + type + " request: " + errorText);
c@52:     }
c@52: 
c@52:     static void
c@52:     buildVampResponse_Exception(VampResponse::Builder &b,
c@52:                                 const std::exception &e,
c@52:                                 RRType responseType)
c@52:     {
c@52:         return buildVampResponse_Error(b, e.what(), responseType);
c@52:     }
c@52:     
c@26:     static RRType
c@26:     getRequestResponseType(const VampRequest::Reader &r) {
c@26:         switch (r.getRequest().which()) {
c@26:         case VampRequest::Request::Which::LIST:
c@26:             return RRType::List;
c@26:         case VampRequest::Request::Which::LOAD:
c@26:             return RRType::Load;
c@26:         case VampRequest::Request::Which::CONFIGURE:
c@26:             return RRType::Configure;
c@26:         case VampRequest::Request::Which::PROCESS:
c@26:             return RRType::Process;
c@26:         case VampRequest::Request::Which::FINISH:
c@26:             return RRType::Finish;
c@26:         }
c@27:         return RRType::NotValid;
c@26:     }
c@26: 
c@26:     static RRType
c@26:     getRequestResponseType(const VampResponse::Reader &r) {
c@26:         switch (r.getResponse().which()) {
c@26:         case VampResponse::Response::Which::LIST:
c@26:             return RRType::List;
c@26:         case VampResponse::Response::Which::LOAD:
c@26:             return RRType::Load;
c@26:         case VampResponse::Response::Which::CONFIGURE:
c@26:             return RRType::Configure;
c@26:         case VampResponse::Response::Which::PROCESS:
c@26:             return RRType::Process;
c@26:         case VampResponse::Response::Which::FINISH:
c@26:             return RRType::Finish;
c@26:         }
c@27:         return RRType::NotValid;
c@26:     }
c@26:     
c@26:     static void
c@26:     readVampRequest_List(const VampRequest::Reader &r) {
c@26:         if (getRequestResponseType(r) != RRType::List) {
c@27:             throw std::logic_error("not a list request");
c@26:         }
c@26:     }
c@26: 
c@26:     static void
c@56:     readVampResponse_List(Vamp::HostExt::ListResponse &resp,
c@26:                           const VampResponse::Reader &r) {
c@26:         if (getRequestResponseType(r) != RRType::List) {
c@27:             throw std::logic_error("not a list response");
c@26:         }
c@56:         resp.pluginData.clear();
c@26:         if (r.getSuccess()) {
c@28:             auto pp = r.getResponse().getList().getPlugins();
c@28:             for (const auto &p: pp) {
c@26:                 Vamp::HostExt::PluginStaticData psd;
c@26:                 readPluginStaticData(psd, p);
c@56:                 resp.pluginData.push_back(psd);
c@26:             }
c@26:         }
c@26:     }
c@26:     
c@27:     static void
c@27:     readVampRequest_Load(Vamp::HostExt::LoadRequest &req,
c@27:                          const VampRequest::Reader &r) {
c@27:         if (getRequestResponseType(r) != RRType::Load) {
c@27:             throw std::logic_error("not a load request");
c@27:         }
c@27:         readLoadRequest(req, r.getRequest().getLoad());
c@27:     }
c@27: 
c@27:     static void
c@27:     readVampResponse_Load(Vamp::HostExt::LoadResponse &resp,
c@27:                           const VampResponse::Reader &r,
c@51:                           const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Load) {
c@27:             throw std::logic_error("not a load response");
c@27:         }
c@27:         resp = {};
c@27:         if (r.getSuccess()) {
c@49:             readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
c@27:         }
c@27:     }
c@27:     
c@27:     static void
c@27:     readVampRequest_Configure(Vamp::HostExt::ConfigurationRequest &req,
c@27:                               const VampRequest::Reader &r,
c@51:                               const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Configure) {
c@27:             throw std::logic_error("not a configuration request");
c@27:         }
c@49:         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
c@27:     }
c@27: 
c@27:     static void
c@27:     readVampResponse_Configure(Vamp::HostExt::ConfigurationResponse &resp,
c@55:                                const VampResponse::Reader &r,
c@55:                                const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Configure) {
c@27:             throw std::logic_error("not a configuration response");
c@27:         }
c@27:         resp = {};
c@27:         if (r.getSuccess()) {
c@55:             readConfigurationResponse(resp,
c@55:                                       r.getResponse().getConfigure(),
c@55:                                       pmapper);
c@27:         }
c@27:     }
c@27:     
c@27:     static void
c@27:     readVampRequest_Process(Vamp::HostExt::ProcessRequest &req,
c@27:                             const VampRequest::Reader &r,
c@51:                             const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Process) {
c@27:             throw std::logic_error("not a process request");
c@27:         }
c@49:         readProcessRequest(req, r.getRequest().getProcess(), pmapper);
c@27:     }
c@27: 
c@27:     static void
c@27:     readVampResponse_Process(Vamp::HostExt::ProcessResponse &resp,
c@49:                              const VampResponse::Reader &r,
c@51:                              const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Process) {
c@27:             throw std::logic_error("not a process response");
c@27:         }
c@27:         resp = {};
c@27:         if (r.getSuccess()) {
c@51:             readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
c@27:         }
c@27:     }
c@27:     
c@27:     static void
c@55:     readVampRequest_Finish(Vamp::HostExt::FinishRequest &req,
c@27:                            const VampRequest::Reader &r,
c@51:                            const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Finish) {
c@27:             throw std::logic_error("not a finish request");
c@27:         }
c@55:         req.plugin = pmapper.handleToPlugin
c@27:             (r.getRequest().getFinish().getPluginHandle());
c@27:     }
c@27: 
c@27:     static void
c@27:     readVampResponse_Finish(Vamp::HostExt::ProcessResponse &resp,
c@49:                             const VampResponse::Reader &r,
c@51:                             const PluginHandleMapper &pmapper) {
c@27:         if (getRequestResponseType(r) != RRType::Finish) {
c@27:             throw std::logic_error("not a finish response");
c@27:         }
c@27:         resp = {};
c@27:         if (r.getSuccess()) {
c@51:             readProcessResponse(resp, r.getResponse().getFinish(), pmapper);
c@27:         }
c@27:     }
c@5: };
c@5: 
c@5: }
c@5: 
c@5: