c@75: /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
c@75: 
c@75: /*
c@75:     Piper C++
c@75: 
c@75:     Centre for Digital Music, Queen Mary, University of London.
cannam@220:     Copyright 2015-2017 QMUL.
c@75:   
c@75:     Permission is hereby granted, free of charge, to any person
c@75:     obtaining a copy of this software and associated documentation
c@75:     files (the "Software"), to deal in the Software without
c@75:     restriction, including without limitation the rights to use, copy,
c@75:     modify, merge, publish, distribute, sublicense, and/or sell copies
c@75:     of the Software, and to permit persons to whom the Software is
c@75:     furnished to do so, subject to the following conditions:
c@75: 
c@75:     The above copyright notice and this permission notice shall be
c@75:     included in all copies or substantial portions of the Software.
c@75: 
c@75:     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
c@75:     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
c@75:     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
c@75:     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
c@75:     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
c@75:     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
c@75:     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
c@75: 
c@75:     Except as contained in this notice, the names of the Centre for
c@75:     Digital Music; Queen Mary, University of London; and Chris Cannam
c@75:     shall not be used in advertising or otherwise to promote the sale,
c@75:     use or other dealings in this Software without prior written
c@75:     authorization.
c@75: */
c@75: 
c@75: #include "piper.capnp.h"
c@75: 
c@75: #include <capnp/message.h>
c@75: 
c@75: #include <vamp-hostsdk/Plugin.h>
c@75: #include <vamp-hostsdk/PluginLoader.h>
c@97: 
c@97: #include "vamp-support/PluginStaticData.h"
c@97: #include "vamp-support/PluginConfiguration.h"
c@97: #include "vamp-support/RequestResponse.h"
c@75: 
c@75: #include "vamp-support/PluginHandleMapper.h"
c@75: #include "vamp-support/PluginOutputIdMapper.h"
c@75: #include "vamp-support/RequestResponseType.h"
c@75: 
c@97: namespace piper_vamp
c@75: {
c@75: 
c@75: /**
c@75:  * Convert the structures laid out in the Vamp SDK classes into Cap'n
c@75:  * Proto structures (and back again).
c@75:  * 
c@75:  * At least some of this will be necessary for any implementation
c@75:  * using Cap'n Proto that uses the C++ Vamp SDK to provide its
c@75:  * reference structures. An implementation could alternatively use the
c@75:  * Cap'n Proto structures directly, and interact with Vamp plugins
c@75:  * using the Vamp C API, without using the C++ Vamp SDK classes at
c@75:  * all. That would avoid a lot of copying (in Cap'n Proto style).
c@75:  */
c@75: class VampnProto
c@75: {
c@75: public:
c@75:     typedef ::capnp::MallocMessageBuilder MsgBuilder;
c@75: 
c@75:     template <typename T, typename B>
c@75:     static void buildBasicDescriptor(B &basic, const T &t) {
c@75:         basic.setIdentifier(t.identifier);
c@75:         basic.setName(t.name);
c@75:         basic.setDescription(t.description);
c@75:     }
c@75: 
c@75:     template <typename T, typename B>
c@75:     static void readBasicDescriptor(T &t, const B &basic) {
c@75:         t.identifier = basic.getIdentifier();
c@75:         t.name = basic.getName();
c@75:         t.description = basic.getDescription();
c@75:     }
c@75: 
c@75:     template <typename T, typename M>
c@75:     static void buildValueExtents(M &m, const T &t) {
c@75:         m.setMinValue(t.minValue);
c@75:         m.setMaxValue(t.maxValue);
c@75:     }
c@75: 
c@75:     template <typename T, typename M>
c@75:     static void readValueExtents(T &t, const M &m) {
c@75:         t.minValue = m.getMinValue();
c@75:         t.maxValue = m.getMaxValue();
c@75:     }
c@75: 
c@97:     static void buildRealTime(piper::RealTime::Builder &b,
c@97:                               const Vamp::RealTime &t) {
c@75:         b.setSec(t.sec);
c@75:         b.setNsec(t.nsec);
c@75:     }
c@75: 
c@97:     static void readRealTime(Vamp::RealTime &t,
c@97:                              const piper::RealTime::Reader &r) {
c@75:         t.sec = r.getSec();
c@75:         t.nsec = r.getNsec();
c@75:     }
c@75: 
c@97:     static piper::SampleType
c@75:     fromSampleType(Vamp::Plugin::OutputDescriptor::SampleType t) {
c@75:         switch (t) {
c@75:         case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
c@97:             return piper::SampleType::ONE_SAMPLE_PER_STEP;
c@75:         case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
c@97:             return piper::SampleType::FIXED_SAMPLE_RATE;
c@75:         case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
c@97:             return piper::SampleType::VARIABLE_SAMPLE_RATE;
c@75:         }
c@75:         throw std::logic_error("unexpected Vamp SampleType enum value");
c@75:     }
c@75: 
c@75:     static Vamp::Plugin::OutputDescriptor::SampleType
c@97:     toSampleType(piper::SampleType t) {
c@75:         switch (t) {
c@97:         case piper::SampleType::ONE_SAMPLE_PER_STEP:
c@75:             return Vamp::Plugin::OutputDescriptor::OneSamplePerStep;
c@97:         case piper::SampleType::FIXED_SAMPLE_RATE:
c@75:             return Vamp::Plugin::OutputDescriptor::FixedSampleRate;
c@97:         case piper::SampleType::VARIABLE_SAMPLE_RATE:
c@75:             return Vamp::Plugin::OutputDescriptor::VariableSampleRate;
c@75:         }
c@75:         throw std::logic_error("unexpected Capnp SampleType enum value");
c@75:     }
c@75: 
c@75:     static void
cannam@220:     buildStaticOutputDescriptor(piper::StaticOutputDescriptor::Builder &b,
cannam@220:                                 const StaticOutputDescriptor &sd) {
cannam@220:         b.setTypeURI(sd.typeURI);
cannam@220:     }
cannam@220:     
cannam@220:     static void
c@97:     buildConfiguredOutputDescriptor(piper::ConfiguredOutputDescriptor::Builder &b,
c@75:                                     const Vamp::Plugin::OutputDescriptor &od) {
c@75: 
c@75:         b.setUnit(od.unit);
c@75:         b.setSampleType(fromSampleType(od.sampleType));
c@75:         b.setSampleRate(od.sampleRate);
c@75:         b.setHasDuration(od.hasDuration);
c@75: 
c@75:         b.setHasFixedBinCount(od.hasFixedBinCount);
c@75:         if (od.hasFixedBinCount) {
c@102:             b.setBinCount(int(od.binCount));
c@75:             if (od.binNames.size() > 0) {
c@102:                 auto binNames = b.initBinNames(unsigned(od.binNames.size()));
c@102:                 for (int i = 0; i < int(od.binNames.size()); ++i) {
c@75:                     binNames.set(i, od.binNames[i]);
c@75:                 }
c@75:             }
c@75:         }
c@75: 
c@75:         b.setHasKnownExtents(od.hasKnownExtents);
c@75:         if (od.hasKnownExtents) {
c@75:             buildValueExtents(b, od);
c@75:         }
c@75: 
c@75:         b.setIsQuantized(od.isQuantized);
c@75:         if (od.isQuantized) {
c@75:             b.setQuantizeStep(od.quantizeStep);
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     buildOutputDescriptor(piper::OutputDescriptor::Builder &b,
cannam@220:                           const Vamp::Plugin::OutputDescriptor &od,
cannam@220:                           const StaticOutputDescriptor &sd) {
c@75: 
c@75:         auto basic = b.initBasic();
c@75:         buildBasicDescriptor(basic, od);
c@75: 
c@75:         auto configured = b.initConfigured();
c@75:         buildConfiguredOutputDescriptor(configured, od);
cannam@220: 
cannam@220:         auto statc = b.initStatic();
cannam@220:         buildStaticOutputDescriptor(statc, sd);
cannam@220:     }
cannam@220: 
cannam@220:     static void
cannam@220:     readStaticOutputDescriptor(StaticOutputDescriptor &sd,
cannam@220:                                const piper::StaticOutputDescriptor::Reader &r) {
cannam@220:         sd.typeURI = r.getTypeURI();
c@75:     }
c@75:     
c@75:     static void
c@75:     readConfiguredOutputDescriptor(Vamp::Plugin::OutputDescriptor &od,
c@97:                                    const piper::ConfiguredOutputDescriptor::Reader &r) {
c@75: 
c@75:         od.unit = r.getUnit();
c@75: 
c@75:         od.sampleType = toSampleType(r.getSampleType());
c@75:         od.sampleRate = r.getSampleRate();
c@75:         od.hasDuration = r.getHasDuration();
c@75: 
c@75:         od.hasFixedBinCount = r.getHasFixedBinCount();
c@75:         if (od.hasFixedBinCount) {
c@75:             od.binCount = r.getBinCount();
c@75:             od.binNames.clear();
c@75:             auto nn = r.getBinNames();
c@75:             for (const auto &n: nn) {
c@75:                 od.binNames.push_back(n);
c@75:             }
c@75:         }
c@75: 
c@75:         od.hasKnownExtents = r.getHasKnownExtents();
c@75:         if (od.hasKnownExtents) {
c@75:             readValueExtents(od, r);
c@75:         }
c@75: 
c@75:         od.isQuantized = r.getIsQuantized();
c@75:         if (od.isQuantized) {
c@75:             od.quantizeStep = r.getQuantizeStep();
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@75:     readOutputDescriptor(Vamp::Plugin::OutputDescriptor &od,
cannam@220:                          StaticOutputDescriptor &sd,
c@97:                          const piper::OutputDescriptor::Reader &r) {
c@75: 
c@75:         readBasicDescriptor(od, r.getBasic());
cannam@220:         readStaticOutputDescriptor(sd, r.getStatic());
c@75:         readConfiguredOutputDescriptor(od, r.getConfigured());
c@75:     }
c@75: 
c@75:     static void
c@97:     buildParameterDescriptor(piper::ParameterDescriptor::Builder &b,
c@75:                              const Vamp::Plugin::ParameterDescriptor &pd) {
c@75: 
c@75:         auto basic = b.initBasic();
c@75:         buildBasicDescriptor(basic, pd);
c@75: 
c@75:         b.setUnit(pd.unit);
c@75: 
c@75:         buildValueExtents(b, pd);
c@75: 
c@75:         b.setDefaultValue(pd.defaultValue);
c@75: 
c@75:         b.setIsQuantized(pd.isQuantized);
c@75:         if (pd.isQuantized) {
c@75:             b.setQuantizeStep(pd.quantizeStep);
c@75:         }
c@75:         
c@75:         if (pd.valueNames.size() > 0) {
c@102:             auto valueNames = b.initValueNames(unsigned(pd.valueNames.size()));
c@102:             for (int i = 0; i < int(pd.valueNames.size()); ++i) {
c@75:                 valueNames.set(i, pd.valueNames[i]);
c@75:             }
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@75:     readParameterDescriptor(Vamp::Plugin::ParameterDescriptor &pd,
c@97:                             const piper::ParameterDescriptor::Reader &r) {
c@75: 
c@75:         readBasicDescriptor(pd, r.getBasic());
c@75: 
c@75:         pd.unit = r.getUnit();
c@75: 
c@75:         readValueExtents(pd, r);
c@75: 
c@75:         pd.defaultValue = r.getDefaultValue();
c@75: 
c@75:         pd.isQuantized = r.getIsQuantized();
c@75:         if (pd.isQuantized) {
c@75:             pd.quantizeStep = r.getQuantizeStep();
c@75:         }
c@75: 
c@75:         pd.valueNames.clear();
c@75:         auto nn = r.getValueNames();
c@75:         for (const auto &n: nn) {
c@75:             pd.valueNames.push_back(n);
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@97:     buildFeature(piper::Feature::Builder &b,
c@75:                  const Vamp::Plugin::Feature &f) {
c@75: 
c@75:         b.setHasTimestamp(f.hasTimestamp);
c@75:         if (f.hasTimestamp) {
c@75:             auto timestamp = b.initTimestamp();
c@75:             buildRealTime(timestamp, f.timestamp);
c@75:         }
c@75: 
c@75:         b.setHasDuration(f.hasDuration);
c@75:         if (f.hasDuration) {
c@75:             auto duration = b.initDuration();
c@75:             buildRealTime(duration, f.duration);
c@75:         }
c@75: 
c@75:         b.setLabel(f.label);
c@75: 
c@75:         if (f.values.size() > 0) {
c@102:             auto values = b.initFeatureValues(unsigned(f.values.size()));
c@102:             for (int i = 0; i < int(f.values.size()); ++i) {
c@75:                 values.set(i, f.values[i]);
c@75:             }
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@75:     readFeature(Vamp::Plugin::Feature &f,
c@97:                 const piper::Feature::Reader &r) {
c@75: 
c@75:         f.hasTimestamp = r.getHasTimestamp();
c@75:         if (f.hasTimestamp) {
c@75:             readRealTime(f.timestamp, r.getTimestamp());
c@75:         }
c@75: 
c@75:         f.hasDuration = r.getHasDuration();
c@75:         if (f.hasDuration) {
c@75:             readRealTime(f.duration, r.getDuration());
c@75:         }
c@75: 
c@75:         f.label = r.getLabel();
c@75: 
c@75:         f.values.clear();
c@75:         auto vv = r.getFeatureValues();
c@75:         for (auto v: vv) {
c@75:             f.values.push_back(v);
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@97:     buildFeatureSet(piper::FeatureSet::Builder &b,
c@75:                     const Vamp::Plugin::FeatureSet &fs,
c@75:                     const PluginOutputIdMapper &omapper) {
c@75: 
c@102:         auto featureset = b.initFeaturePairs(unsigned(fs.size()));
c@75:         int ix = 0;
c@75:         for (const auto &fsi : fs) {
c@75:             auto fspair = featureset[ix];
c@75:             fspair.setOutput(omapper.indexToId(fsi.first));
c@102:             auto featurelist = fspair.initFeatures(unsigned(fsi.second.size()));
c@102:             for (int j = 0; j < int(fsi.second.size()); ++j) {
c@75:                 auto feature = featurelist[j];
c@75:                 buildFeature(feature, fsi.second[j]);
c@75:             }
c@75:             ++ix;
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@75:     readFeatureSet(Vamp::Plugin::FeatureSet &fs,
c@97:                    const piper::FeatureSet::Reader &r,
c@75:                    const PluginOutputIdMapper &omapper) {
c@75: 
c@75:         fs.clear();
c@75:         auto pp = r.getFeaturePairs();
c@75:         for (const auto &p: pp) {
c@75:             Vamp::Plugin::FeatureList vfl;
c@75:             auto ff = p.getFeatures();
c@75:             for (const auto &f: ff) {
c@75:                 Vamp::Plugin::Feature vf;
c@75:                 readFeature(vf, f);
c@75:                 vfl.push_back(vf);
c@75:             }
c@75:             fs[omapper.idToIndex(p.getOutput())] = vfl;
c@75:         }
c@75:     }
c@75:     
c@97:     static piper::InputDomain
c@75:     fromInputDomain(Vamp::Plugin::InputDomain d) {
c@75:         switch(d) {
c@75:         case Vamp::Plugin::TimeDomain:
c@97:             return piper::InputDomain::TIME_DOMAIN;
c@75:         case Vamp::Plugin::FrequencyDomain:
c@97:             return piper::InputDomain::FREQUENCY_DOMAIN;
c@75:         default:
c@75:             throw std::logic_error("unexpected Vamp InputDomain enum value");
c@75:         }
c@75:     }
c@75: 
c@75:     static Vamp::Plugin::InputDomain
c@97:     toInputDomain(piper::InputDomain d) {
c@75:         switch(d) {
c@97:         case piper::InputDomain::TIME_DOMAIN:
c@75:             return Vamp::Plugin::TimeDomain;
c@97:         case piper::InputDomain::FREQUENCY_DOMAIN:
c@75:             return Vamp::Plugin::FrequencyDomain;
c@75:         default:
c@75:             throw std::logic_error("unexpected Capnp InputDomain enum value");
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@97:     buildExtractorStaticData(piper::ExtractorStaticData::Builder &b,
c@97:                              const PluginStaticData &d) {
c@75: 
c@75:         b.setKey(d.pluginKey);
c@75: 
c@75:         auto basic = b.initBasic();
c@75:         buildBasicDescriptor(basic, d.basic);
c@75: 
c@75:         b.setMaker(d.maker);
cannam@216:         b.setRights(d.copyright);
c@75:         b.setVersion(d.pluginVersion);
c@75: 
c@102:         auto clist = b.initCategory(unsigned(d.category.size()));
c@102:         for (int i = 0; i < int(d.category.size()); ++i) {
c@75:             clist.set(i, d.category[i]);
c@75:         }
c@75: 
c@102:         b.setMinChannelCount(int(d.minChannelCount));
c@102:         b.setMaxChannelCount(int(d.maxChannelCount));
c@75: 
c@75:         const auto &vparams = d.parameters;
c@102:         auto plist = b.initParameters(unsigned(vparams.size()));
c@102:         for (int i = 0; i < int(vparams.size()); ++i) {
c@75:             auto pd = plist[i];
c@75:             buildParameterDescriptor(pd, vparams[i]);
c@75:         }
c@75:         
c@75:         const auto &vprogs = d.programs;
c@102:         auto pglist = b.initPrograms(unsigned(vprogs.size()));
c@102:         for (int i = 0; i < int(vprogs.size()); ++i) {
c@75:             pglist.set(i, vprogs[i]);
c@75:         }
c@75: 
c@75:         b.setInputDomain(fromInputDomain(d.inputDomain));
c@75: 
c@75:         const auto &vouts = d.basicOutputInfo;
c@102:         auto olist = b.initBasicOutputInfo(unsigned(vouts.size()));
c@102:         for (int i = 0; i < int(vouts.size()); ++i) {
c@75:             auto od = olist[i];
c@75:             buildBasicDescriptor(od, vouts[i]);
c@75:         }
cannam@220: 
cannam@220:         const auto &vstatic = d.staticOutputInfo;
cannam@220:         auto slist = b.initStaticOutputInfo(unsigned(vstatic.size()));
cannam@220:         int i = 0;
cannam@220:         for (const auto &vi: vstatic) {
cannam@220:             auto spair = slist[i];
cannam@220:             spair.setOutput(vi.first);
cannam@220:             auto sdata = spair.initStatic();
cannam@220:             sdata.setTypeURI(vi.second.typeURI);
cannam@220:             ++i;
cannam@220:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     readExtractorStaticData(PluginStaticData &d,
c@97:                             const piper::ExtractorStaticData::Reader &r) {
c@75:         
c@75:         d.pluginKey = r.getKey();
c@75: 
c@75:         readBasicDescriptor(d.basic, r.getBasic());
c@75: 
c@75:         d.maker = r.getMaker();
cannam@216:         d.copyright = r.getRights();
c@75:         d.pluginVersion = r.getVersion();
c@75: 
c@75:         d.category.clear();
c@75:         auto cc = r.getCategory();
c@75:         for (auto c: cc) {
c@75:             d.category.push_back(c);
c@75:         }
c@75: 
c@75:         d.minChannelCount = r.getMinChannelCount();
c@75:         d.maxChannelCount = r.getMaxChannelCount();
c@75: 
c@75:         d.parameters.clear();
c@75:         auto pp = r.getParameters();
c@75:         for (auto p: pp) {
c@75:             Vamp::Plugin::ParameterDescriptor pd;
c@75:             readParameterDescriptor(pd, p);
c@75:             d.parameters.push_back(pd);
c@75:         }
c@75: 
c@75:         d.programs.clear();
c@75:         auto prp = r.getPrograms();
c@75:         for (auto p: prp) {
c@75:             d.programs.push_back(p);
c@75:         }
c@75: 
c@75:         d.inputDomain = toInputDomain(r.getInputDomain());
c@75: 
c@75:         d.basicOutputInfo.clear();
c@75:         auto oo = r.getBasicOutputInfo();
c@75:         for (auto o: oo) {
c@97:             PluginStaticData::Basic b;
c@75:             readBasicDescriptor(b, o);
c@75:             d.basicOutputInfo.push_back(b);
c@75:         }
cannam@220: 
cannam@220:         d.staticOutputInfo.clear();
cannam@220:         auto sp = r.getStaticOutputInfo();
cannam@220:         for (auto s: sp) {
cannam@220:             std::string id = s.getOutput();
cannam@220:             std::string typeURI = s.getStatic().getTypeURI();
cannam@220:             d.staticOutputInfo[id] = { typeURI };
cannam@220:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     buildConfiguration(piper::Configuration::Builder &b,
c@97:                        const PluginConfiguration &c) {
c@75: 
c@75:         const auto &vparams = c.parameterValues;
c@102:         auto params = b.initParameterValues(unsigned(vparams.size()));
c@75:         int i = 0;
c@75:         for (const auto &pp : vparams) {
c@75:             auto param = params[i++];
c@75:             param.setParameter(pp.first);
c@75:             param.setValue(pp.second);
c@75:         }
c@75: 
c@75:         b.setCurrentProgram(c.currentProgram);
c@75:         b.setChannelCount(c.channelCount);
cannam@185: 
cannam@185:         auto framing = b.initFraming();
cannam@185:         framing.setStepSize(c.framing.stepSize);
cannam@185:         framing.setBlockSize(c.framing.blockSize);
c@75:     }
c@75: 
c@75:     static void
c@97:     readConfiguration(PluginConfiguration &c,
c@97:                       const piper::Configuration::Reader &r) {
c@75: 
c@75:         auto pp = r.getParameterValues();
c@75:         for (const auto &p: pp) {
c@75:             c.parameterValues[p.getParameter()] = p.getValue();
c@75:         }
c@75: 
c@75:         c.currentProgram = r.getCurrentProgram();
c@75:         c.channelCount = r.getChannelCount();
cannam@185:         c.framing.stepSize = r.getFraming().getStepSize();
cannam@185:         c.framing.blockSize = r.getFraming().getBlockSize();
c@75:     }
cannam@289: 
cannam@289:     static void
cannam@289:     buildProgramParameterMap(piper::LoadResponse::PPPair::Builder &b,
cannam@289:                              const PluginProgramParameters &pparams,
cannam@289:                              std::string program) {
cannam@289:         b.setProgram(program);
cannam@289:         if (pparams.programParameters.find(program) ==
cannam@289:             pparams.programParameters.end()) {
cannam@289:             b.initParameters(0);
cannam@289:             return;
cannam@289:         }
cannam@289:         auto params = b.initParameters
cannam@289:             (unsigned(pparams.programParameters.at(program).size()));
cannam@289:         int i = 0;
cannam@289:         for (auto pv: pparams.programParameters.at(program)) {
cannam@289:             params[i].setParameter(pv.first);
cannam@289:             params[i].setValue(pv.second);
cannam@289:             ++i;
cannam@289:         }
cannam@289:     }
cannam@289:     
cannam@289:     static void
cannam@289:     readProgramParameterMap(PluginProgramParameters &pparams,
cannam@289:                             const piper::LoadResponse::PPPair::Reader &r) {
cannam@289: 
cannam@289:         auto program = r.getProgram();
cannam@289:         auto params = r.getParameters();
cannam@289:         for (auto pv: params) {
cannam@289:             pparams.programParameters[program][pv.getParameter()] = pv.getValue();
cannam@289:         }
cannam@289:     }
c@127:     
c@127:     static void
c@127:     buildListRequest(piper::ListRequest::Builder &r,
c@127:                      const ListRequest &resp) {
c@75: 
c@127:         auto p = r.initFrom(unsigned(resp.from.size()));
c@127:         for (int i = 0; i < int(resp.from.size()); ++i) {
c@127:             p.set(i, resp.from[i]);
c@127:         }
c@127:     }
c@127:     
c@127:     static void
c@127:     readListRequest(ListRequest &lr,
c@127:                     const piper::ListRequest::Reader &r) {
c@127: 
c@127:         lr.from.clear();
c@127:         for (auto f: r.getFrom()) {
c@127:             lr.from.push_back(f);
c@127:         }
c@127:     }
c@127: 
c@127:     static void
c@127:     buildListResponse(piper::ListResponse::Builder &r,
c@127:                       const ListResponse &resp) {
c@127:         
c@127:         auto p = r.initAvailable(unsigned(resp.available.size()));
c@127:         for (int i = 0; i < int(resp.available.size()); ++i) {
c@127:             auto pd = p[i];
c@127:             buildExtractorStaticData(pd, resp.available[i]);
c@127:         }
c@127:     }
c@127:     
c@75:     static void
c@97:     readListResponse(ListResponse &lr,
c@97:                      const piper::ListResponse::Reader &r) {
c@95: 
c@95:         lr.available.clear();
c@95:         auto pp = r.getAvailable();
c@95:         for (const auto &p: pp) {
c@97:             PluginStaticData psd;
c@95:             readExtractorStaticData(psd, p);
c@95:             lr.available.push_back(psd);
c@95:         }
c@95:     }
c@95: 
c@95:     static void
c@97:     buildLoadRequest(piper::LoadRequest::Builder &r,
c@97:                      const LoadRequest &req) {
c@75: 
c@75:         r.setKey(req.pluginKey);
c@75:         r.setInputSampleRate(req.inputSampleRate);
c@75: 
c@97:         std::vector<piper::AdapterFlag> flags;
c@75:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN) {
c@97:             flags.push_back(piper::AdapterFlag::ADAPT_INPUT_DOMAIN);
c@75:         }
c@75:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT) {
c@97:             flags.push_back(piper::AdapterFlag::ADAPT_CHANNEL_COUNT);
c@75:         }
c@75:         if (req.adapterFlags & Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE) {
c@97:             flags.push_back(piper::AdapterFlag::ADAPT_BUFFER_SIZE);
c@75:         }
c@75: 
c@102:         auto f = r.initAdapterFlags(unsigned(flags.size()));
c@102:         for (int i = 0; i < int(flags.size()); ++i) {
c@75:             f.set(i, flags[i]);
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     readLoadRequest(LoadRequest &req,
c@97:                     const piper::LoadRequest::Reader &r) {
c@75: 
c@75:         req.pluginKey = r.getKey();
c@75:         req.inputSampleRate = r.getInputSampleRate();
c@75: 
c@75:         int flags = 0;
c@75:         auto aa = r.getAdapterFlags();
c@75:         for (auto a: aa) {
c@97:             if (a == piper::AdapterFlag::ADAPT_INPUT_DOMAIN) {
c@75:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN;
c@75:             }
c@97:             if (a == piper::AdapterFlag::ADAPT_CHANNEL_COUNT) {
c@75:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT;
c@75:             }
c@97:             if (a == piper::AdapterFlag::ADAPT_BUFFER_SIZE) {
c@75:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE;
c@75:             }
c@75:         }
c@75:         req.adapterFlags = flags;
c@75:     }
c@75: 
c@75:     static void
c@97:     buildLoadResponse(piper::LoadResponse::Builder &b,
c@97:                       const LoadResponse &resp,
c@75:                       const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(resp.plugin));
c@75:         auto sd = b.initStaticData();
c@75:         buildExtractorStaticData(sd, resp.staticData);
c@75:         auto conf = b.initDefaultConfiguration();
c@75:         buildConfiguration(conf, resp.defaultConfiguration);
cannam@289: 
cannam@289:         auto pp = b.initProgramParameters
cannam@289:             (unsigned(resp.programParameters.programParameters.size()));
cannam@289: 
cannam@289:         int i = 0;
cannam@289:         for (auto prog: resp.programParameters.programParameters) {
cannam@289:             auto pb = pp[i];
cannam@289:             buildProgramParameterMap(pb, resp.programParameters, prog.first);
cannam@289:             ++i;
cannam@289:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     readLoadResponse(LoadResponse &resp,
c@97:                      const piper::LoadResponse::Reader &r,
c@75:                      const PluginHandleMapper &pmapper) {
c@75: 
cannam@275:         auto h = r.getHandle();
cannam@275:         resp.plugin = pmapper.handleToPlugin(h);
c@75:         readExtractorStaticData(resp.staticData, r.getStaticData());
c@75:         readConfiguration(resp.defaultConfiguration,
c@80:                           r.getDefaultConfiguration());
cannam@289: 
cannam@289:         for (auto pp: r.getProgramParameters()) {
cannam@289:             readProgramParameterMap(resp.programParameters, pp);
cannam@289:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     buildConfigurationRequest(piper::ConfigurationRequest::Builder &b,
c@97:                               const ConfigurationRequest &cr,
c@75:                               const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(cr.plugin));
c@75:         auto c = b.initConfiguration();
c@75:         buildConfiguration(c, cr.configuration);
c@75:     }
c@75: 
c@75:     static void
c@97:     readConfigurationRequest(ConfigurationRequest &cr,
c@97:                              const piper::ConfigurationRequest::Reader &r,
c@75:                              const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto h = r.getHandle();
c@75:         cr.plugin = pmapper.handleToPlugin(h);
c@75:         auto c = r.getConfiguration();
c@75:         readConfiguration(cr.configuration, c);
c@75:     }
c@75: 
c@75:     static void
c@97:     buildConfigurationResponse(piper::ConfigurationResponse::Builder &b,
c@97:                                const ConfigurationResponse &cr,
c@75:                                const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(cr.plugin));
c@102:         auto olist = b.initOutputs(unsigned(cr.outputs.size()));
cannam@220: 
c@102:         for (int i = 0; i < int(cr.outputs.size()); ++i) {
cannam@220: 
cannam@220:             auto id = cr.outputs[i].identifier;
cannam@220:             StaticOutputDescriptor sd;
cannam@220:             if (cr.staticOutputInfo.find(id) != cr.staticOutputInfo.end()) {
cannam@220:                 sd = cr.staticOutputInfo.at(id);
cannam@220:             }
cannam@220: 
c@75:             auto od = olist[i];
cannam@220:             buildOutputDescriptor(od, cr.outputs[i], sd);
c@75:         }
cannam@220:             
cannam@185:         auto framing = b.initFraming();
cannam@185:         framing.setStepSize(cr.framing.stepSize);
cannam@185:         framing.setBlockSize(cr.framing.blockSize);
c@75:     }
c@75: 
c@75:     static void
c@97:     readConfigurationResponse(ConfigurationResponse &cr,
c@97:                               const piper::ConfigurationResponse::Reader &r,
c@75:                               const PluginHandleMapper &pmapper) {
c@75: 
cannam@275:         auto h = r.getHandle();
cannam@275:         cr.plugin = pmapper.handleToPlugin(h);
c@75:         cr.outputs.clear();
cannam@220:         cr.staticOutputInfo.clear();
c@75:         auto oo = r.getOutputs();
c@75:         for (const auto &o: oo) {
c@75:             Vamp::Plugin::OutputDescriptor desc;
cannam@220:             StaticOutputDescriptor sd;
cannam@220:             readOutputDescriptor(desc, sd, o);
c@75:             cr.outputs.push_back(desc);
cannam@220:             if (sd.typeURI != "") {
cannam@220:                 cr.staticOutputInfo[desc.identifier] = { sd.typeURI };
cannam@220:             }
c@75:         }
cannam@185:         cr.framing.stepSize = r.getFraming().getStepSize();
cannam@185:         cr.framing.blockSize = r.getFraming().getBlockSize();
c@75:     }
c@75: 
c@75:     static void
c@97:     buildProcessInput(piper::ProcessInput::Builder &b,
c@75:                       Vamp::RealTime timestamp,
c@75:                       const std::vector<std::vector<float> > &buffers) {
c@75: 
c@75:         auto t = b.initTimestamp();
c@75:         buildRealTime(t, timestamp);
c@102:         auto vv = b.initInputBuffers(unsigned(buffers.size()));
c@102:         for (int ch = 0; ch < int(buffers.size()); ++ch) {
c@75:             const int n = int(buffers[ch].size());
c@75:             vv.init(ch, n);
c@75:             auto v = vv[ch];
c@75:             for (int i = 0; i < n; ++i) {
c@75:                 v.set(i, buffers[ch][i]);
c@75:             }
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@75:     readProcessInput(Vamp::RealTime &timestamp,
c@75:                      std::vector<std::vector<float> > &buffers,
c@97:                      const piper::ProcessInput::Reader &b) {
c@75: 
c@75:         readRealTime(timestamp, b.getTimestamp());
c@75:         buffers.clear();
c@75:         auto vv = b.getInputBuffers();
c@75:         for (const auto &v: vv) {
c@75:             std::vector<float> buf;
c@75:             for (auto x: v) {
c@75:                 buf.push_back(x);
c@75:             }
c@75:             buffers.push_back(buf);
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@97:     buildProcessRequest(piper::ProcessRequest::Builder &b,
c@97:                         const ProcessRequest &pr,
c@75:                         const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(pr.plugin));
c@75:         auto input = b.initProcessInput();
c@75:         buildProcessInput(input, pr.timestamp, pr.inputBuffers);
c@75:     }
c@75: 
c@75:     static void
c@97:     readProcessRequest(ProcessRequest &pr,
c@97:                        const piper::ProcessRequest::Reader &r,
c@75:                        const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto h = r.getHandle();
c@75:         pr.plugin = pmapper.handleToPlugin(h);
c@75:         readProcessInput(pr.timestamp, pr.inputBuffers, r.getProcessInput());
c@75:     }
c@75: 
c@75:     static void
c@97:     buildProcessResponse(piper::ProcessResponse::Builder &b,
c@97:                          const ProcessResponse &pr,
c@75:                          const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(pr.plugin));
c@75:         auto f = b.initFeatures();
c@75:         buildFeatureSet(f, pr.features,
c@75:                         *pmapper.pluginToOutputIdMapper(pr.plugin));
c@75:     }
c@75:     
c@75:     static void
c@97:     readProcessResponse(ProcessResponse &pr,
c@97:                         const piper::ProcessResponse::Reader &r,
c@75:                         const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto h = r.getHandle();
c@75:         pr.plugin = pmapper.handleToPlugin(h);
c@75:         readFeatureSet(pr.features, r.getFeatures(),
c@75:                        *pmapper.handleToOutputIdMapper(r.getHandle()));
c@75:     }
c@75: 
c@75:     static void
c@97:     buildFinishResponse(piper::FinishResponse::Builder &b,
c@97:                         const FinishResponse &pr,
c@75:                         const PluginHandleMapper &pmapper) {
c@75: 
c@75:         b.setHandle(pmapper.pluginToHandle(pr.plugin));
c@75:         auto f = b.initFeatures();
c@75:         buildFeatureSet(f, pr.features,
c@75:                         *pmapper.pluginToOutputIdMapper(pr.plugin));
c@75:     }
c@75:     
c@75:     static void
c@97:     readFinishResponse(FinishResponse &pr,
c@97:                        const piper::FinishResponse::Reader &r,
c@75:                        const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto h = r.getHandle();
c@75:         pr.plugin = pmapper.handleToPlugin(h);
c@75:         readFeatureSet(pr.features, r.getFeatures(),
c@75:                        *pmapper.handleToOutputIdMapper(r.getHandle()));
c@75:     }
c@75: 
c@75:     static void
c@127:     buildRpcRequest_List(piper::RpcRequest::Builder &b,
c@127:                          const ListRequest &req) {
c@127:         auto r = b.getRequest().initList();
c@127:         buildListRequest(r, req);
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcResponse_List(piper::RpcResponse::Builder &b,
c@97:                           const ListResponse &resp) {
c@75: 
c@75:         auto r = b.getResponse().initList();
c@127:         buildListResponse(r, resp);
c@75:     }
c@75:     
c@75:     static void
c@97:     buildRpcRequest_Load(piper::RpcRequest::Builder &b,
c@97:                          const LoadRequest &req) {
c@75:         auto u = b.getRequest().initLoad();
c@75:         buildLoadRequest(u, req);
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcResponse_Load(piper::RpcResponse::Builder &b,
c@97:                           const LoadResponse &resp,
c@80:                           const PluginHandleMapper &pmapper) {
c@75: 
c@75:         if (resp.plugin) {
c@75:             auto u = b.getResponse().initLoad();
c@75:             buildLoadResponse(u, resp, pmapper);
c@75:         } else {
c@75:             buildRpcResponse_Error(b, "Failed to load plugin", RRType::Load);
c@75:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcRequest_Configure(piper::RpcRequest::Builder &b,
c@97:                               const ConfigurationRequest &cr,
c@80:                               const PluginHandleMapper &pmapper) {
c@75:         auto u = b.getRequest().initConfigure();
c@75:         buildConfigurationRequest(u, cr, pmapper);
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcResponse_Configure(piper::RpcResponse::Builder &b,
c@97:                                const ConfigurationResponse &cr,
c@80:                                const PluginHandleMapper &pmapper) {
c@75: 
c@75:         if (!cr.outputs.empty()) {
c@75:             auto u = b.getResponse().initConfigure();
c@75:             buildConfigurationResponse(u, cr, pmapper);
c@75:         } else {
c@75:             buildRpcResponse_Error(b, "Failed to configure plugin",
c@75:                                    RRType::Configure);
c@75:         }
c@75:     }
c@75:     
c@75:     static void
c@97:     buildRpcRequest_Process(piper::RpcRequest::Builder &b,
c@97:                             const ProcessRequest &pr,
c@80:                             const PluginHandleMapper &pmapper) {
c@75:         auto u = b.getRequest().initProcess();
c@75:         buildProcessRequest(u, pr, pmapper);
c@75:     }
c@75:     
c@75:     static void
c@97:     buildRpcResponse_Process(piper::RpcResponse::Builder &b,
c@97:                              const ProcessResponse &pr,
c@80:                              const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto u = b.getResponse().initProcess();
c@75:         buildProcessResponse(u, pr, pmapper);
c@75:     }
c@75:     
c@75:     static void
c@97:     buildRpcRequest_Finish(piper::RpcRequest::Builder &b,
c@97:                            const FinishRequest &req,
c@80:                            const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto u = b.getRequest().initFinish();
c@75:         u.setHandle(pmapper.pluginToHandle(req.plugin));
c@75:     }
c@75:     
c@75:     static void
c@97:     buildRpcResponse_Finish(piper::RpcResponse::Builder &b,
c@97:                             const FinishResponse &pr,
c@80:                             const PluginHandleMapper &pmapper) {
c@75: 
c@75:         auto u = b.getResponse().initFinish();
c@75:         buildFinishResponse(u, pr, pmapper);
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcResponse_Error(piper::RpcResponse::Builder &b,
c@80:                            const std::string &errorText,
c@80:                            RRType responseType)
c@75:     {
c@75:         std::string type;
c@75: 
c@75:         auto e = b.getResponse().initError();
c@75: 
c@75:         if (responseType == RRType::List) {
c@75:             type = "list";
c@75:         } else if (responseType == RRType::Load) {
c@75:             type = "load";
c@75:         } else if (responseType == RRType::Configure) {
c@75:             type = "configure";
c@75:         } else if (responseType == RRType::Process) {
c@75:             type = "process";
c@75:         } else if (responseType == RRType::Finish) {
c@75:             type = "finish";
c@75:         } else {
c@75:             type = "invalid";
c@75:         }
c@75: 
c@75:         e.setCode(0);
cannam@158: 
cannam@158:         if (responseType == RRType::NotValid) {
cannam@158:             e.setMessage(errorText);
cannam@158:         } else {
cannam@158:             e.setMessage
cannam@158:                 (std::string("error in ") + type + " request: " + errorText);
cannam@158:         }
c@75:     }
c@75: 
c@75:     static void
c@97:     buildRpcResponse_Exception(piper::RpcResponse::Builder &b,
c@80:                                const std::exception &e,
c@80:                                RRType responseType)
c@75:     {
c@75:         return buildRpcResponse_Error(b, e.what(), responseType);
c@75:     }
c@75:     
c@75:     static RRType
c@97:     getRequestResponseType(const piper::RpcRequest::Reader &r) {
c@75:         switch (r.getRequest().which()) {
c@97:         case piper::RpcRequest::Request::Which::LIST:
c@75:             return RRType::List;
c@97:         case piper::RpcRequest::Request::Which::LOAD:
c@75:             return RRType::Load;
c@97:         case piper::RpcRequest::Request::Which::CONFIGURE:
c@75:             return RRType::Configure;
c@97:         case piper::RpcRequest::Request::Which::PROCESS:
c@75:             return RRType::Process;
c@97:         case piper::RpcRequest::Request::Which::FINISH:
c@75:             return RRType::Finish;
c@75:         }
c@75:         return RRType::NotValid;
c@75:     }
c@75: 
c@75:     static RRType
c@97:     getRequestResponseType(const piper::RpcResponse::Reader &r) {
c@75:         switch (r.getResponse().which()) {
c@97:         case piper::RpcResponse::Response::Which::ERROR:
cannam@170:             return RRType::NotValid;
c@97:         case piper::RpcResponse::Response::Which::LIST:
c@75:             return RRType::List;
c@97:         case piper::RpcResponse::Response::Which::LOAD:
c@75:             return RRType::Load;
c@97:         case piper::RpcResponse::Response::Which::CONFIGURE:
c@75:             return RRType::Configure;
c@97:         case piper::RpcResponse::Response::Which::PROCESS:
c@75:             return RRType::Process;
c@97:         case piper::RpcResponse::Response::Which::FINISH:
c@75:             return RRType::Finish;
c@75:         }
c@75:         return RRType::NotValid;
c@75:     }
c@75:     
c@75:     static void
c@75:     readRpcResponse_Error(int &code,
c@75:                           std::string &message,
c@97:                           const piper::RpcResponse::Reader &r) {
c@75:         if (getRequestResponseType(r) != RRType::NotValid) {
c@75:             throw std::logic_error("not an error response");
c@75:         }
c@75:         code = r.getResponse().getError().getCode();
c@75:         message = r.getResponse().getError().getMessage();
c@75:     }
c@75:         
c@75:     static void
c@127:     readRpcRequest_List(ListRequest &req,
c@127:                         const piper::RpcRequest::Reader &r) {
c@75:         if (getRequestResponseType(r) != RRType::List) {
c@75:             throw std::logic_error("not a list request");
c@75:         }
c@127:         readListRequest(req, r.getRequest().getList());
c@75:     }
c@75: 
c@75:     static void
c@97:     readRpcResponse_List(ListResponse &resp,
c@97:                          const piper::RpcResponse::Reader &r) {
c@75:         if (getRequestResponseType(r) != RRType::List) {
c@75:             throw std::logic_error("not a list response");
c@75:         }
c@95:         readListResponse(resp, r.getResponse().getList());
c@75:     }
c@75:     
c@75:     static void
c@97:     readRpcRequest_Load(LoadRequest &req,
c@97:                         const piper::RpcRequest::Reader &r) {
c@75:         if (getRequestResponseType(r) != RRType::Load) {
c@75:             throw std::logic_error("not a load request");
c@75:         }
c@75:         readLoadRequest(req, r.getRequest().getLoad());
c@75:     }
c@75: 
c@75:     static void
c@97:     readRpcResponse_Load(LoadResponse &resp,
c@97:                          const piper::RpcResponse::Reader &r,
c@75:                          const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Load) {
c@75:             throw std::logic_error("not a load response");
c@75:         }
c@75:         resp = {};
c@75:         readLoadResponse(resp, r.getResponse().getLoad(), pmapper);
c@75:     }
c@75:     
c@75:     static void
c@97:     readRpcRequest_Configure(ConfigurationRequest &req,
c@97:                              const piper::RpcRequest::Reader &r,
c@80:                              const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Configure) {
c@75:             throw std::logic_error("not a configuration request");
c@75:         }
c@75:         readConfigurationRequest(req, r.getRequest().getConfigure(), pmapper);
c@75:     }
c@75: 
c@75:     static void
c@97:     readRpcResponse_Configure(ConfigurationResponse &resp,
c@97:                               const piper::RpcResponse::Reader &r,
c@80:                               const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Configure) {
c@75:             throw std::logic_error("not a configuration response");
c@75:         }
c@75:         resp = {};
c@75:         readConfigurationResponse(resp,
c@75:                                   r.getResponse().getConfigure(),
c@75:                                   pmapper);
c@75:     }
c@75:     
c@75:     static void
c@97:     readRpcRequest_Process(ProcessRequest &req,
c@97:                            const piper::RpcRequest::Reader &r,
c@80:                            const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Process) {
c@75:             throw std::logic_error("not a process request");
c@75:         }
c@75:         readProcessRequest(req, r.getRequest().getProcess(), pmapper);
c@75:     }
c@75: 
c@75:     static void
c@97:     readRpcResponse_Process(ProcessResponse &resp,
c@97:                             const piper::RpcResponse::Reader &r,
c@80:                             const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Process) {
c@75:             throw std::logic_error("not a process response");
c@75:         }
c@75:         resp = {};
c@75:         readProcessResponse(resp, r.getResponse().getProcess(), pmapper);
c@75:     }
c@75:     
c@75:     static void
c@97:     readRpcRequest_Finish(FinishRequest &req,
c@97:                           const piper::RpcRequest::Reader &r,
c@80:                           const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Finish) {
c@75:             throw std::logic_error("not a finish request");
c@75:         }
cannam@275:         auto h = r.getRequest().getFinish().getHandle();
cannam@275:         req.plugin = pmapper.handleToPlugin(h);
c@75:     }
c@75: 
c@75:     static void
c@97:     readRpcResponse_Finish(FinishResponse &resp,
c@97:                            const piper::RpcResponse::Reader &r,
c@80:                            const PluginHandleMapper &pmapper) {
c@75:         if (getRequestResponseType(r) != RRType::Finish) {
c@75:             throw std::logic_error("not a finish response");
c@75:         }
c@75:         resp = {};
c@75:         readFinishResponse(resp, r.getResponse().getFinish(), pmapper);
c@75:     }
c@75: };
c@75: 
c@75: }
c@75: 
c@75: