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: #ifndef VAMP_JSON_H
c@5: #define VAMP_JSON_H
c@5: 
c@5: #include <vector>
c@5: #include <string>
c@5: #include <sstream>
c@5: #include <stdexcept>
c@5: 
c@5: #include <json11/json11.hpp>
c@5: #include <base-n/include/basen.hpp>
c@5: 
c@5: #include <vamp-hostsdk/Plugin.h>
c@5: #include <vamp-hostsdk/PluginLoader.h>
c@5: 
c@10: #include "bits/PluginHandleMapper.h"
c@25: #include "bits/RequestResponseType.h"
c@10: 
c@10: namespace vampipe {
c@10: 
c@6: /**
c@6:  * Convert the structures laid out in the Vamp SDK classes into JSON
c@6:  * (and back again) following the schema in the vamp-json-schema
c@6:  * project repo.
c@6:  */
c@5: class VampJson
c@5: {
c@5: public:
c@5:     class Failure : virtual public std::runtime_error {
c@5:     public:
c@5:         Failure(std::string s) : runtime_error(s) { }
c@5:     };
c@5:     
c@5:     template <typename T>
c@5:     static json11::Json
c@5:     fromBasicDescriptor(const T &t) {
c@5:         return json11::Json::object { 
c@5:             { "identifier", t.identifier },
c@5:             { "name", t.name },
c@5:             { "description", t.description }
c@5:         };
c@5:     }
c@5: 
c@5:     template <typename T>
c@5:     static void
c@5:     toBasicDescriptor(json11::Json j, T &t) {
c@5:         if (!j.is_object()) {
c@5:             throw Failure("object expected for basic descriptor content");
c@5:         }
c@5:         if (!j["identifier"].is_string()) {
c@5:             throw Failure("string expected for identifier");
c@5:         }
c@5:         t.identifier = j["identifier"].string_value();
c@5:         t.name = j["name"].string_value();
c@5:         t.description = j["description"].string_value();
c@5:     }
c@5: 
c@5:     template <typename T>
c@5:     static json11::Json
c@5:     fromValueExtents(const T &t) {
c@5:         return json11::Json::object {
c@5:             { "min", t.minValue },
c@5:             { "max", t.maxValue }
c@5:         };
c@5:     }
c@5: 
c@5:     template <typename T>
c@5:     static bool
c@5:     toValueExtents(json11::Json j, T &t) {
c@5:         if (j["extents"].is_null()) {
c@5:             return false;
c@5:         } else if (j["extents"].is_object()) {
c@5:             if (j["extents"]["min"].is_number() &&
c@5:                 j["extents"]["max"].is_number()) {
c@5:                 t.minValue = j["extents"]["min"].number_value();
c@5:                 t.maxValue = j["extents"]["max"].number_value();
c@5:                 return true;
c@5:             } else {
c@5:                 throw Failure("numbers expected for min and max");
c@5:             }
c@5:         } else {
c@5:             throw Failure("object expected for extents (if present)");
c@5:         }
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromRealTime(const Vamp::RealTime &r) {
c@5:         return json11::Json::object {
c@5:             { "s", r.sec },
c@5:             { "n", r.nsec }
c@5:         };
c@5:     }
c@5: 
c@5:     static Vamp::RealTime
c@5:     toRealTime(json11::Json j) {
c@5:         json11::Json sec = j["s"];
c@5:         json11::Json nsec = j["n"];
c@5:         if (!sec.is_number() || !nsec.is_number()) {
c@5:             throw Failure("invalid Vamp::RealTime object " + j.dump());
c@5:         }
c@5:         return Vamp::RealTime(sec.int_value(), nsec.int_value());
c@5:     }
c@5: 
c@5:     static std::string
c@5:     fromSampleType(Vamp::Plugin::OutputDescriptor::SampleType type) {
c@5:         switch (type) {
c@5:         case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
c@5:             return "OneSamplePerStep";
c@5:         case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
c@5:             return "FixedSampleRate";
c@5:         case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
c@5:             return "VariableSampleRate";
c@5:         }
c@5:         return "";
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::OutputDescriptor::SampleType
c@5:     toSampleType(std::string text) {
c@5:         if (text == "OneSamplePerStep") {
c@5:             return Vamp::Plugin::OutputDescriptor::OneSamplePerStep;
c@5:         } else if (text == "FixedSampleRate") {
c@5:             return Vamp::Plugin::OutputDescriptor::FixedSampleRate;
c@5:         } else if (text == "VariableSampleRate") {
c@5:             return Vamp::Plugin::OutputDescriptor::VariableSampleRate;
c@5:         } else {
c@5:             throw Failure("invalid sample type string: " + text);
c@5:         }
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromOutputDescriptor(const Vamp::Plugin::OutputDescriptor &desc) {
c@5:         json11::Json::object jo {
c@5:             { "basic", fromBasicDescriptor(desc) },
c@5:             { "unit", desc.unit },
c@5:             { "sampleType", fromSampleType(desc.sampleType) },
c@5:             { "sampleRate", desc.sampleRate },
c@5:             { "hasDuration", desc.hasDuration }
c@5:         };
c@5:         if (desc.hasFixedBinCount) {
c@5:             jo["binCount"] = int(desc.binCount);
c@5:             jo["binNames"] = json11::Json::array
c@5:                 (desc.binNames.begin(), desc.binNames.end());
c@5:         }
c@5:         if (desc.hasKnownExtents) {
c@5:             jo["extents"] = fromValueExtents(desc);
c@5:         }
c@5:         if (desc.isQuantized) {
c@5:             jo["quantizeStep"] = desc.quantizeStep;
c@5:         }
c@5:         return json11::Json(jo);
c@5:     }
c@12:     
c@5:     static Vamp::Plugin::OutputDescriptor
c@5:     toOutputDescriptor(json11::Json j) {
c@5: 
c@5:         Vamp::Plugin::OutputDescriptor od;
c@5:         if (!j.is_object()) {
c@5:             throw Failure("object expected for output descriptor");
c@5:         }
c@5:     
c@5:         toBasicDescriptor(j["basic"], od);
c@5: 
c@5:         od.unit = j["unit"].string_value();
c@5: 
c@5:         od.sampleType = toSampleType(j["sampleType"].string_value());
c@5: 
c@5:         if (!j["sampleRate"].is_number()) {
c@5:             throw Failure("number expected for sample rate");
c@5:         }
c@5:         od.sampleRate = j["sampleRate"].number_value();
c@5:         od.hasDuration = j["hasDuration"].bool_value();
c@5: 
c@5:         if (j["binCount"].is_number() && j["binCount"].int_value() > 0) {
c@5:             od.hasFixedBinCount = true;
c@5:             od.binCount = j["binCount"].int_value();
c@5:             for (auto &n: j["binNames"].array_items()) {
c@5:                 if (!n.is_string()) {
c@5:                     throw Failure("string expected for bin name");
c@5:                 }
c@5:                 od.binNames.push_back(n.string_value());
c@5:             }
c@5:         } else {
c@5:             od.hasFixedBinCount = false;
c@5:         }
c@5: 
c@5:         bool extentsPresent = toValueExtents(j, od);
c@5:         od.hasKnownExtents = extentsPresent;
c@5: 
c@5:         if (j["quantizeStep"].is_number()) {
c@5:             od.isQuantized = true;
c@5:             od.quantizeStep = j["quantizeStep"].number_value();
c@5:         } else {
c@5:             od.isQuantized = false;
c@5:         }
c@5: 
c@5:         return od;
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromParameterDescriptor(const Vamp::PluginBase::ParameterDescriptor &desc) {
c@5: 
c@5:         json11::Json::object jo {
c@5:             { "basic", fromBasicDescriptor(desc) },
c@5:             { "unit", desc.unit },
c@5:             { "extents", fromValueExtents(desc) },
c@5:             { "defaultValue", desc.defaultValue },
c@5:             { "valueNames", json11::Json::array
c@5:                     (desc.valueNames.begin(), desc.valueNames.end()) }
c@5:         };
c@5:         if (desc.isQuantized) {
c@5:             jo["quantizeStep"] = desc.quantizeStep;
c@5:         }
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::PluginBase::ParameterDescriptor
c@5:     toParameterDescriptor(json11::Json j) {
c@5: 
c@5:         Vamp::PluginBase::ParameterDescriptor pd;
c@5:         if (!j.is_object()) {
c@5:             throw Failure("object expected for parameter descriptor");
c@5:         }
c@5:     
c@5:         toBasicDescriptor(j["basic"], pd);
c@5: 
c@5:         pd.unit = j["unit"].string_value();
c@5: 
c@5:         bool extentsPresent = toValueExtents(j, pd);
c@5:         if (!extentsPresent) {
c@5:             throw Failure("extents must be present in parameter descriptor");
c@5:         }
c@5:     
c@5:         if (!j["defaultValue"].is_number()) {
c@5:             throw Failure("number expected for default value");
c@5:         }
c@5:     
c@5:         pd.defaultValue = j["defaultValue"].number_value();
c@5: 
c@5:         pd.valueNames.clear();
c@5:         for (auto &n: j["valueNames"].array_items()) {
c@5:             if (!n.is_string()) {
c@5:                 throw Failure("string expected for value name");
c@5:             }
c@5:             pd.valueNames.push_back(n.string_value());
c@5:         }
c@5: 
c@5:         if (j["quantizeStep"].is_number()) {
c@5:             pd.isQuantized = true;
c@5:             pd.quantizeStep = j["quantizeStep"].number_value();
c@5:         } else {
c@5:             pd.isQuantized = false;
c@5:         }
c@5: 
c@5:         return pd;
c@5:     }
c@5: 
c@5:     static std::string
c@5:     fromFloatBuffer(const float *buffer, size_t nfloats) {
c@5:         // must use char pointers, otherwise the converter will only
c@5:         // encode every 4th byte (as it will count up in float* steps)
c@5:         const char *start = reinterpret_cast<const char *>(buffer);
c@5:         const char *end = reinterpret_cast<const char *>(buffer + nfloats);
c@5:         std::string encoded;
c@5:         bn::encode_b64(start, end, back_inserter(encoded));
c@5:         return encoded;
c@5:     }
c@5: 
c@5:     static std::vector<float>
c@5:     toFloatBuffer(std::string encoded) {
c@5:         std::string decoded;
c@5:         bn::decode_b64(encoded.begin(), encoded.end(), back_inserter(decoded));
c@5:         const float *buffer = reinterpret_cast<const float *>(decoded.c_str());
c@5:         size_t n = decoded.size() / sizeof(float);
c@5:         return std::vector<float>(buffer, buffer + n);
c@5:     }
c@5: 
c@5:     static json11::Json
c@35:     fromFeature(const Vamp::Plugin::Feature &f, bool asText) {
c@5: 
c@5:         json11::Json::object jo;
c@5:         if (f.values.size() > 0) {
c@35:             if (asText) {
c@35:                 jo["values"] = json11::Json::array(f.values.begin(),
c@35:                                                    f.values.end());
c@35:             } else {
c@35:                 jo["b64values"] = fromFloatBuffer(f.values.data(),
c@35:                                                   f.values.size());
c@35:             }
c@5:         }
c@5:         if (f.label != "") {
c@5:             jo["label"] = f.label;
c@5:         }
c@5:         if (f.hasTimestamp) {
c@5:             jo["timestamp"] = fromRealTime(f.timestamp);
c@5:         }
c@5:         if (f.hasDuration) {
c@5:             jo["duration"] = fromRealTime(f.duration);
c@5:         }
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::Feature
c@5:     toFeature(json11::Json j) {
c@5: 
c@5:         Vamp::Plugin::Feature f;
c@5:         if (!j.is_object()) {
c@5:             throw Failure("object expected for feature");
c@5:         }
c@5:         if (j["timestamp"].is_object()) {
c@5:             f.timestamp = toRealTime(j["timestamp"]);
c@5:             f.hasTimestamp = true;
c@5:         }
c@5:         if (j["duration"].is_object()) {
c@5:             f.duration = toRealTime(j["duration"]);
c@5:             f.hasDuration = true;
c@5:         }
c@5:         if (j["b64values"].is_string()) {
c@5:             f.values = toFloatBuffer(j["b64values"].string_value());
c@5:         } else if (j["values"].is_array()) {
c@5:             for (auto v : j["values"].array_items()) {
c@5:                 f.values.push_back(v.number_value());
c@5:             }
c@5:         }
c@5:         f.label = j["label"].string_value();
c@5:         return f;
c@5:     }
c@5: 
c@5:     static json11::Json
c@35:     fromFeatureSet(const Vamp::Plugin::FeatureSet &fs, bool asText) {
c@5: 
c@5:         json11::Json::object jo;
c@5:         for (const auto &fsi : fs) {
c@5:             std::vector<json11::Json> fj;
c@5:             for (const Vamp::Plugin::Feature &f: fsi.second) {
c@35:                 fj.push_back(fromFeature(f, asText));
c@5:             }
c@5:             std::stringstream sstr;
c@5:             sstr << fsi.first;
c@5:             std::string n = sstr.str();
c@5:             jo[n] = fj;
c@5:         }
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::FeatureList
c@5:     toFeatureList(json11::Json j) {
c@5: 
c@5:         Vamp::Plugin::FeatureList fl;
c@5:         if (!j.is_array()) {
c@5:             throw Failure("array expected for feature list");
c@5:         }
c@5:         for (const json11::Json &fj : j.array_items()) {
c@5:             fl.push_back(toFeature(fj));
c@5:         }
c@5:         return fl;
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::FeatureSet
c@5:     toFeatureSet(json11::Json j) {
c@5: 
c@5:         Vamp::Plugin::FeatureSet fs;
c@5:         if (!j.is_object()) {
c@5:             throw Failure("object expected for feature set");
c@5:         }
c@5:         for (auto &entry : j.object_items()) {
c@5:             std::string nstr = entry.first;
c@5:             size_t count = 0;
c@5:             int n = stoi(nstr, &count);
c@5:             if (n < 0 || fs.find(n) != fs.end() || count < nstr.size()) {
c@5:                 throw Failure("invalid or duplicate numerical index for output");
c@5:             }
c@5:             fs[n] = toFeatureList(entry.second);
c@5:         }
c@5:         return fs;
c@5:     }
c@5: 
c@5:     static std::string
c@5:     fromInputDomain(Vamp::Plugin::InputDomain domain) {
c@5: 
c@5:         switch (domain) {
c@5:         case Vamp::Plugin::TimeDomain:
c@5:             return "TimeDomain";
c@5:         case Vamp::Plugin::FrequencyDomain:
c@5:             return "FrequencyDomain";
c@5:         }
c@5:         return "";
c@5:     }
c@5: 
c@5:     static Vamp::Plugin::InputDomain
c@5:     toInputDomain(std::string text) {
c@5: 
c@5:         if (text == "TimeDomain") {
c@5:             return Vamp::Plugin::TimeDomain;
c@5:         } else if (text == "FrequencyDomain") {
c@5:             return Vamp::Plugin::FrequencyDomain;
c@5:         } else {
c@5:             throw Failure("invalid input domain string: " + text);
c@5:         }
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromPluginStaticData(const Vamp::HostExt::PluginStaticData &d) {
c@5: 
c@5:         json11::Json::object jo;
c@5:         jo["pluginKey"] = d.pluginKey;
c@5:         jo["basic"] = fromBasicDescriptor(d.basic);
c@5:         jo["maker"] = d.maker;
c@5:         jo["copyright"] = d.copyright;
c@5:         jo["pluginVersion"] = d.pluginVersion;
c@5: 
c@5:         json11::Json::array cat;
c@5:         for (const std::string &c: d.category) cat.push_back(c);
c@5:         jo["category"] = cat;
c@5: 
c@5:         jo["minChannelCount"] = d.minChannelCount;
c@5:         jo["maxChannelCount"] = d.maxChannelCount;
c@5: 
c@5:         json11::Json::array params;
c@5:         Vamp::PluginBase::ParameterList vparams = d.parameters;
c@5:         for (auto &p: vparams) params.push_back(fromParameterDescriptor(p));
c@5:         jo["parameters"] = params;
c@5: 
c@5:         json11::Json::array progs;
c@5:         Vamp::PluginBase::ProgramList vprogs = d.programs;
c@5:         for (auto &p: vprogs) progs.push_back(p);
c@5:         jo["programs"] = progs;
c@5: 
c@5:         jo["inputDomain"] = fromInputDomain(d.inputDomain);
c@5: 
c@5:         json11::Json::array outinfo;
c@5:         auto vouts = d.basicOutputInfo;
c@5:         for (auto &o: vouts) outinfo.push_back(fromBasicDescriptor(o));
c@5:         jo["basicOutputInfo"] = outinfo;
c@5:     
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::HostExt::PluginStaticData
c@5:     toPluginStaticData(json11::Json j) {
c@5: 
c@5:         std::string err;
c@5:         if (!j.has_shape({
c@5:                     { "pluginKey", json11::Json::STRING },
c@5:                     { "pluginVersion", json11::Json::NUMBER },
c@5:                     { "minChannelCount", json11::Json::NUMBER },
c@5:                     { "maxChannelCount", json11::Json::NUMBER },
c@5:                     { "inputDomain", json11::Json::STRING }}, err)) {
c@5:             throw Failure("malformed plugin static data: " + err);
c@5:         }
c@5: 
c@5:         if (!j["basicOutputInfo"].is_array()) {
c@5:             throw Failure("array expected for basic output info");
c@5:         }
c@5: 
c@5:         if (!j["maker"].is_null() &&
c@5:             !j["maker"].is_string()) {
c@5:             throw Failure("string expected for maker");
c@5:         }
c@5:         
c@5:         if (!j["copyright"].is_null() &&
c@5:             !j["copyright"].is_string()) {
c@5:             throw Failure("string expected for copyright");
c@5:         }
c@5: 
c@5:         if (!j["category"].is_null() &&
c@5:             !j["category"].is_array()) {
c@5:             throw Failure("array expected for category");
c@5:         }
c@5: 
c@5:         if (!j["parameters"].is_null() &&
c@5:             !j["parameters"].is_array()) {
c@5:             throw Failure("array expected for parameters");
c@5:         }
c@5: 
c@5:         if (!j["programs"].is_null() &&
c@5:             !j["programs"].is_array()) {
c@5:             throw Failure("array expected for programs");
c@5:         }
c@5: 
c@5:         if (!j["inputDomain"].is_null() &&
c@5:             !j["inputDomain"].is_string()) {
c@5:             throw Failure("string expected for inputDomain");
c@5:         }
c@5: 
c@5:         if (!j["basicOutputInfo"].is_null() &&
c@5:             !j["basicOutputInfo"].is_array()) {
c@5:             throw Failure("array expected for basicOutputInfo");
c@5:         }
c@5: 
c@5:         Vamp::HostExt::PluginStaticData psd;
c@5: 
c@5:         psd.pluginKey = j["pluginKey"].string_value();
c@5: 
c@5:         toBasicDescriptor(j["basic"], psd.basic);
c@5: 
c@5:         psd.maker = j["maker"].string_value();
c@5:         psd.copyright = j["copyright"].string_value();
c@5:         psd.pluginVersion = j["pluginVersion"].int_value();
c@5: 
c@5:         for (const auto &c : j["category"].array_items()) {
c@5:             if (!c.is_string()) {
c@5:                 throw Failure("strings expected in category array");
c@5:             }
c@5:             psd.category.push_back(c.string_value());
c@5:         }
c@5: 
c@5:         psd.minChannelCount = j["minChannelCount"].int_value();
c@5:         psd.maxChannelCount = j["maxChannelCount"].int_value();
c@5: 
c@5:         for (const auto &p : j["parameters"].array_items()) {
c@5:             auto pd = toParameterDescriptor(p);
c@5:             psd.parameters.push_back(pd);
c@5:         }
c@5: 
c@5:         for (const auto &p : j["programs"].array_items()) {
c@5:             if (!p.is_string()) {
c@5:                 throw Failure("strings expected in programs array");
c@5:             }
c@5:             psd.programs.push_back(p.string_value());
c@5:         }
c@5: 
c@5:         psd.inputDomain = toInputDomain(j["inputDomain"].string_value());
c@5: 
c@5:         for (const auto &bo : j["basicOutputInfo"].array_items()) {
c@5:             Vamp::HostExt::PluginStaticData::Basic b;
c@5:             toBasicDescriptor(bo, b);
c@5:             psd.basicOutputInfo.push_back(b);
c@5:         }
c@5: 
c@5:         return psd;
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromPluginConfiguration(const Vamp::HostExt::PluginConfiguration &c) {
c@5: 
c@5:         json11::Json::object jo;
c@5: 
c@5:         json11::Json::object paramValues;
c@5:         for (auto &vp: c.parameterValues) {
c@5:             paramValues[vp.first] = vp.second;
c@5:         }
c@5:         jo["parameterValues"] = paramValues;
c@5: 
c@5:         if (c.currentProgram != "") {
c@5:             jo["currentProgram"] = c.currentProgram;
c@5:         }
c@5: 
c@5:         jo["channelCount"] = c.channelCount;
c@5:         jo["stepSize"] = c.stepSize;
c@5:         jo["blockSize"] = c.blockSize;
c@5:     
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::HostExt::PluginConfiguration
c@5:     toPluginConfiguration(json11::Json j) {
c@5:         
c@5:         std::string err;
c@5:         if (!j.has_shape({
c@5:                     { "channelCount", json11::Json::NUMBER },
c@5:                     { "stepSize", json11::Json::NUMBER },
c@5:                     { "blockSize", json11::Json::NUMBER } }, err)) {
c@5:             throw Failure("malformed plugin configuration: " + err);
c@5:         }
c@5: 
c@5:         if (!j["parameterValues"].is_null() &&
c@5:             !j["parameterValues"].is_object()) {
c@5:             throw Failure("object expected for parameter values");
c@5:         }
c@5: 
c@5:         for (auto &pv : j["parameterValues"].object_items()) {
c@5:             if (!pv.second.is_number()) {
c@5:                 throw Failure("number expected for parameter value");
c@5:             }
c@5:         }
c@5:     
c@5:         if (!j["currentProgram"].is_null() &&
c@5:             !j["currentProgram"].is_string()) {
c@5:             throw Failure("string expected for program name");
c@5:         }
c@5: 
c@5:         Vamp::HostExt::PluginConfiguration config;
c@5: 
c@5:         config.channelCount = j["channelCount"].number_value();
c@5:         config.stepSize = j["stepSize"].number_value();
c@5:         config.blockSize = j["blockSize"].number_value();
c@5:         
c@5:         for (auto &pv : j["parameterValues"].object_items()) {
c@5:             config.parameterValues[pv.first] = pv.second.number_value();
c@5:         }
c@5: 
c@5:         if (j["currentProgram"].is_string()) {
c@5:             config.currentProgram = j["currentProgram"].string_value();
c@5:         }
c@5: 
c@5:         return config;
c@5:     }
c@5: 
c@5:     static json11::Json
c@5:     fromAdapterFlags(int flags) {
c@5: 
c@5:         json11::Json::array arr;
c@5: 
c@5:         if (flags & Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN) {
c@5:             arr.push_back("AdaptInputDomain");
c@5:         }
c@5:         if (flags & Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT) {
c@5:             arr.push_back("AdaptChannelCount");
c@5:         }
c@5:         if (flags & Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE) {
c@5:             arr.push_back("AdaptBufferSize");
c@5:         }
c@5: 
c@5:         return json11::Json(arr);
c@5:     }
c@5: 
c@5:     static Vamp::HostExt::PluginLoader::AdapterFlags
c@5:     toAdapterFlags(json11::Json j) {
c@5: 
c@5:         if (!j.is_array()) {
c@5:             throw Failure("array expected for adapter flags");
c@5:         }
c@5:         int flags = 0x0;
c@5: 
c@5:         for (auto &jj: j.array_items()) {
c@5:             if (!jj.is_string()) {
c@5:                 throw Failure("string expected for adapter flag");
c@5:             }
c@5:             std::string text = jj.string_value();
c@5:             if (text == "AdaptInputDomain") {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_INPUT_DOMAIN;
c@5:             } else if (text == "AdaptChannelCount") {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_CHANNEL_COUNT;
c@5:             } else if (text == "AdaptBufferSize") {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_BUFFER_SIZE;
c@5:             } else if (text == "AdaptAllSafe") {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_ALL_SAFE;
c@5:             } else if (text == "AdaptAll") {
c@5:                 flags |= Vamp::HostExt::PluginLoader::ADAPT_ALL;
c@5:             } else {
c@5:                 throw Failure("invalid adapter flag string: " + text);
c@5:             }
c@5:         }
c@5: 
c@5:         return Vamp::HostExt::PluginLoader::AdapterFlags(flags);
c@5:     }
c@5: 
c@5:     static json11::Json
c@17:     fromLoadRequest(const Vamp::HostExt::LoadRequest &req) {
c@5: 
c@5:         json11::Json::object jo;
c@5:         jo["pluginKey"] = req.pluginKey;
c@5:         jo["inputSampleRate"] = req.inputSampleRate;
c@5:         jo["adapterFlags"] = fromAdapterFlags(req.adapterFlags);
c@5:         return json11::Json(jo);
c@5:     }
c@5: 
c@5:     static Vamp::HostExt::LoadRequest
c@5:     toLoadRequest(json11::Json j) {
c@5:         
c@5:         std::string err;
c@5: 
c@5:         if (!j.has_shape({
c@5:                     { "pluginKey", json11::Json::STRING },
c@32:                     { "inputSampleRate", json11::Json::NUMBER } }, err)) {
c@12:             throw Failure("malformed load request: " + err);
c@5:         }
c@5:     
c@5:         Vamp::HostExt::LoadRequest req;
c@5:         req.pluginKey = j["pluginKey"].string_value();
c@5:         req.inputSampleRate = j["inputSampleRate"].number_value();
c@32:         if (!j["adapterFlags"].is_null()) {
c@32:             req.adapterFlags = toAdapterFlags(j["adapterFlags"]);
c@32:         }
c@5:         return req;
c@5:     }
c@10: 
c@10:     static json11::Json
c@17:     fromLoadResponse(const Vamp::HostExt::LoadResponse &resp,
c@10:                      PluginHandleMapper &mapper) {
c@10: 
c@10:         json11::Json::object jo;
c@10:         jo["pluginHandle"] = double(mapper.pluginToHandle(resp.plugin));
c@10:         jo["staticData"] = fromPluginStaticData(resp.staticData);
c@10:         jo["defaultConfiguration"] =
c@10:             fromPluginConfiguration(resp.defaultConfiguration);
c@10:         return json11::Json(jo);
c@10:     }
c@10: 
c@10:     static Vamp::HostExt::LoadResponse
c@10:     toLoadResponse(json11::Json j,
c@10:                    PluginHandleMapper &mapper) {
c@10: 
c@10:         std::string err;
c@10: 
c@10:         if (!j.has_shape({
c@10:                     { "pluginHandle", json11::Json::NUMBER },
c@10:                     { "staticData", json11::Json::OBJECT },
c@10:                     { "defaultConfiguration", json11::Json::OBJECT } }, err)) {
c@12:             throw Failure("malformed load response: " + err);
c@10:         }
c@10: 
c@10:         Vamp::HostExt::LoadResponse resp;
c@10:         resp.plugin = mapper.handleToPlugin(j["pluginHandle"].int_value());
c@10:         resp.staticData = toPluginStaticData(j["staticData"]);
c@10:         resp.defaultConfiguration = toPluginConfiguration(j["defaultConfiguration"]);
c@10:         return resp;
c@10:     }
c@12: 
c@12:     static json11::Json
c@13:     fromConfigurationRequest(const Vamp::HostExt::ConfigurationRequest &cr,
c@13:                              PluginHandleMapper &mapper) {
c@13: 
c@13:         json11::Json::object jo;
c@13: 
c@13:         jo["pluginHandle"] = mapper.pluginToHandle(cr.plugin);
c@13:         jo["configuration"] = fromPluginConfiguration(cr.configuration);
c@13:         
c@13:         return json11::Json(jo);
c@13:     }
c@13: 
c@13:     static Vamp::HostExt::ConfigurationRequest
c@13:     toConfigurationRequest(json11::Json j,
c@13:                            PluginHandleMapper &mapper) {
c@13: 
c@13:         std::string err;
c@13: 
c@13:         if (!j.has_shape({
c@13:                     { "pluginHandle", json11::Json::NUMBER },
c@13:                     { "configuration", json11::Json::OBJECT } }, err)) {
c@13:             throw Failure("malformed configuration request: " + err);
c@13:         }
c@13: 
c@13:         Vamp::HostExt::ConfigurationRequest cr;
c@13:         cr.plugin = mapper.handleToPlugin(j["pluginHandle"].int_value());
c@13:         cr.configuration = toPluginConfiguration(j["configuration"]);
c@13:         return cr;
c@13:     }
c@13: 
c@13:     static json11::Json
c@12:     fromConfigurationResponse(const Vamp::HostExt::ConfigurationResponse &cr) {
c@12: 
c@13:         json11::Json::object jo;
c@12:         
c@12:         json11::Json::array outs;
c@12:         for (auto &d: cr.outputs) {
c@12:             outs.push_back(fromOutputDescriptor(d));
c@12:         }
c@13:         jo["outputList"] = outs;
c@12:         
c@13:         return json11::Json(jo);
c@12:     }
c@12: 
c@13:     static Vamp::HostExt::ConfigurationResponse
c@13:     toConfigurationResponse(json11::Json j) {
c@13:         
c@12:         Vamp::HostExt::ConfigurationResponse cr;
c@12: 
c@12:         if (!j["outputList"].is_array()) {
c@12:             throw Failure("array expected for output list");
c@12:         }
c@12: 
c@12:         for (const auto &o: j["outputList"].array_items()) {
c@12:             cr.outputs.push_back(toOutputDescriptor(o));
c@12:         }
c@12: 
c@12:         return cr;
c@12:     }
c@16: 
c@16:     static json11::Json
c@16:     fromProcessRequest(const Vamp::HostExt::ProcessRequest &r,
c@16:                        PluginHandleMapper &mapper) {
c@16: 
c@16:         json11::Json::object jo;
c@16:         jo["pluginHandle"] = mapper.pluginToHandle(r.plugin);
c@16: 
c@16:         json11::Json::object io;
c@16:         io["timestamp"] = fromRealTime(r.timestamp);
c@16: 
c@16:         json11::Json::array chans;
c@16:         for (size_t i = 0; i < r.inputBuffers.size(); ++i) {
c@16:             json11::Json::object c;
c@16:             c["b64values"] = fromFloatBuffer(r.inputBuffers[i].data(),
c@16:                                              r.inputBuffers[i].size());
c@16:             chans.push_back(c);
c@16:         }
c@16:         io["inputBuffers"] = chans;
c@16:         
c@16:         jo["processInput"] = io;
c@16:         return json11::Json(jo);
c@16:     }
c@17: 
c@17:     static Vamp::HostExt::ProcessRequest
c@17:     toProcessRequest(json11::Json j, PluginHandleMapper &mapper) {
c@17: 
c@17:         std::string err;
c@17: 
c@17:         if (!j.has_shape({
c@17:                     { "pluginHandle", json11::Json::NUMBER },
c@17:                     { "processInput", json11::Json::OBJECT } }, err)) {
c@17:             throw Failure("malformed process request: " + err);
c@17:         }
c@17: 
c@17:         auto input = j["processInput"];
c@17: 
c@17:         if (!input.has_shape({
c@17:                     { "timestamp", json11::Json::OBJECT },
c@17:                     { "inputBuffers", json11::Json::ARRAY } }, err)) {
c@17:             throw Failure("malformed process request: " + err);
c@17:         }
c@17: 
c@17:         Vamp::HostExt::ProcessRequest r;
c@17:         r.plugin = mapper.handleToPlugin(j["pluginHandle"].int_value());
c@17: 
c@17:         r.timestamp = toRealTime(input["timestamp"]);
c@17: 
c@17:         for (auto a: input["inputBuffers"].array_items()) {
c@17:             if (a["b64values"].is_string()) {
c@17:                 r.inputBuffers.push_back(toFloatBuffer
c@17:                                          (a["b64values"].string_value()));
c@17:             } else if (a["values"].is_array()) {
c@17:                 std::vector<float> buf;
c@17:                 for (auto v : a["values"].array_items()) {
c@17:                     buf.push_back(v.number_value());
c@17:                 }
c@17:                 r.inputBuffers.push_back(buf);
c@17:             } else {
c@17:                 throw Failure("expected values or b64values in inputBuffers object");
c@17:             }
c@17:         }
c@17: 
c@17:         return r;
c@17:     }
c@17: 
c@17:     static json11::Json
c@17:     fromVampRequest_List() {
c@17: 
c@17:         json11::Json::object jo;
c@17:         jo["type"] = "list";
c@17:         return json11::Json(jo);
c@17:     }
c@17: 
c@17:     static json11::Json
c@17:     fromVampResponse_List(std::string errorText,
c@17:                           const std::vector<Vamp::HostExt::PluginStaticData> &d) {
c@17: 
c@17:         json11::Json::object jo;
c@24:         jo["type"] = "list";
c@17:         jo["success"] = (errorText == "");
c@17:         jo["errorText"] = errorText;
c@17: 
c@17:         json11::Json::array arr;
c@17:         for (const auto &a: d) {
c@17:             arr.push_back(fromPluginStaticData(a));
c@17:         }
c@24:         json11::Json::object po;
c@24:         po["plugins"] = arr;
c@24: 
c@24:         jo["content"] = po;
c@17:         return json11::Json(jo);
c@17:     }
c@17:     
c@17:     static json11::Json
c@17:     fromVampRequest_Load(const Vamp::HostExt::LoadRequest &req) {
c@17: 
c@17:         json11::Json::object jo;
c@17:         jo["type"] = "load";
c@17:         jo["content"] = fromLoadRequest(req);
c@17:         return json11::Json(jo);
c@17:     }    
c@17: 
c@17:     static json11::Json
c@17:     fromVampResponse_Load(const Vamp::HostExt::LoadResponse &resp,
c@17:                           PluginHandleMapper &mapper) {
c@17: 
c@17:         json11::Json::object jo;
c@24:         jo["type"] = "load";
c@17:         jo["success"] = (resp.plugin != 0);
c@17:         jo["errorText"] = "";
c@24:         jo["content"] = fromLoadResponse(resp, mapper);
c@17:         return json11::Json(jo);
c@17:     }
c@17: 
c@17:     static json11::Json
c@17:     fromVampRequest_Configure(const Vamp::HostExt::ConfigurationRequest &req,
c@17:                               PluginHandleMapper &mapper) {
c@17: 
c@17:         json11::Json::object jo;
c@17:         jo["type"] = "configure";
c@17:         jo["content"] = fromConfigurationRequest(req, mapper);
c@17:         return json11::Json(jo);
c@17:     }    
c@17: 
c@17:     static json11::Json
c@17:     fromVampResponse_Configure(const Vamp::HostExt::ConfigurationResponse &resp) {
c@17:         
c@17:         json11::Json::object jo;
c@24:         jo["type"] = "configure";
c@17:         jo["success"] = (!resp.outputs.empty());
c@17:         jo["errorText"] = "";
c@24:         jo["content"] = fromConfigurationResponse(resp);
c@17:         return json11::Json(jo);
c@17:     }
c@17:     
c@17:     static json11::Json
c@17:     fromVampRequest_Process(const Vamp::HostExt::ProcessRequest &req,
c@17:                             PluginHandleMapper &mapper) {
c@17: 
c@17:         json11::Json::object jo;
c@17:         jo["type"] = "process";
c@17:         jo["content"] = fromProcessRequest(req, mapper);
c@17:         return json11::Json(jo);
c@17:     }    
c@17: 
c@17:     static json11::Json
c@17:     fromVampResponse_Process(const Vamp::HostExt::ProcessResponse &resp) {
c@17:         
c@17:         json11::Json::object jo;
c@24:         jo["type"] = "process";
c@17:         jo["success"] = true;
c@17:         jo["errorText"] = "";
c@35:         jo["content"] = fromFeatureSet(resp.features, true);
c@17:         return json11::Json(jo);
c@17:     }
c@17:     
c@17:     static json11::Json
c@24:     fromVampRequest_Finish(Vamp::Plugin *p,
c@24:                            PluginHandleMapper &mapper) {
c@17: 
c@17:         json11::Json::object jo;
c@17:         jo["type"] = "finish";
c@24:         json11::Json::object fo;
c@24:         fo["pluginHandle"] = mapper.pluginToHandle(p);
c@24:         jo["content"] = fo;
c@17:         return json11::Json(jo);
c@17:     }    
c@17:     
c@17:     static json11::Json
c@17:     fromVampResponse_Finish(const Vamp::HostExt::ProcessResponse &resp) {
c@17: 
c@17:         json11::Json::object jo;
c@24:         jo["type"] = "finish";
c@17:         jo["success"] = true;
c@17:         jo["errorText"] = "";
c@35:         jo["content"] = fromFeatureSet(resp.features, true);
c@17:         return json11::Json(jo);
c@17:     }
c@24: 
c@24: private: // go private briefly for a couple of helper functions
c@24:     
c@24:     static void
c@24:     checkTypeField(json11::Json j, std::string expected) {
c@24:         if (!j["type"].is_string()) {
c@24:             throw Failure("string expected for type");
c@24:         }
c@24:         if (j["type"].string_value() != expected) {
c@24:             throw Failure("expected value \"" + expected + "\" for type");
c@24:         }
c@24:     }
c@24: 
c@24:     static bool
c@24:     successful(json11::Json j) {
c@24:         if (!j["success"].is_bool()) {
c@24:             throw Failure("bool expected for success");
c@24:         }
c@24:         return j["success"].bool_value();
c@24:     }
c@24: 
c@24: public:
c@25:     static RRType
c@25:     getRequestResponseType(json11::Json j) {
c@25: 
c@25:         if (!j["type"].is_string()) {
c@25:             throw Failure("string expected for type");
c@25:         }
c@25:         
c@25:         std::string type = j["type"].string_value();
c@25: 
c@25: 	if (type == "list") return RRType::List;
c@25: 	else if (type == "load") return RRType::Load;
c@25: 	else if (type == "configure") return RRType::Configure;
c@25: 	else if (type == "process") return RRType::Process;
c@25: 	else if (type == "finish") return RRType::Finish;
c@25: 	else {
c@25: 	    throw Failure("unknown or unexpected request/response type \"" +
c@25:                           type + "\"");
c@25: 	}
c@25:     }
c@25:     
c@24:     static void
c@24:     toVampRequest_List(json11::Json j) {
c@24:         
c@24:         checkTypeField(j, "list");
c@24:     }
c@24: 
c@24:     static std::vector<Vamp::HostExt::PluginStaticData>
c@24:     toVampResponse_List(json11::Json j) {
c@24: 
c@24:         std::vector<Vamp::HostExt::PluginStaticData> arr;
c@24:         if (successful(j)) {
c@24:             for (const auto &a: j["content"]["plugins"].array_items()) {
c@24:                 arr.push_back(toPluginStaticData(a));
c@24:             }
c@24:         }
c@24:         return arr;
c@24:     }
c@24: 
c@24:     static Vamp::HostExt::LoadRequest
c@24:     toVampRequest_Load(json11::Json j) {
c@24:         
c@24:         checkTypeField(j, "load");
c@24:         return toLoadRequest(j["content"]);
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::LoadResponse
c@24:     toVampResponse_Load(json11::Json j, PluginHandleMapper &mapper) {
c@24:         
c@24:         Vamp::HostExt::LoadResponse resp;
c@24:         if (successful(j)) {
c@24:             resp = toLoadResponse(j["content"], mapper);
c@24:         }
c@24:         return resp;
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::ConfigurationRequest
c@24:     toVampRequest_Configure(json11::Json j, PluginHandleMapper &mapper) {
c@24:         
c@24:         checkTypeField(j, "configure");
c@24:         return toConfigurationRequest(j["content"], mapper);
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::ConfigurationResponse
c@24:     toVampResponse_Configure(json11::Json j) {
c@24:         
c@24:         Vamp::HostExt::ConfigurationResponse resp;
c@24:         if (successful(j)) {
c@24:             resp = toConfigurationResponse(j["content"]);
c@24:         }
c@24:         return resp;
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::ProcessRequest
c@24:     toVampRequest_Process(json11::Json j, PluginHandleMapper &mapper) {
c@24:         
c@24:         checkTypeField(j, "process");
c@24:         return toProcessRequest(j["content"], mapper);
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::ProcessResponse
c@24:     toVampResponse_Process(json11::Json j) {
c@24:         
c@24:         Vamp::HostExt::ProcessResponse resp;
c@24:         if (successful(j)) {
c@24:             resp.features = toFeatureSet(j["content"]);
c@24:         }
c@24:         return resp;
c@24:     }
c@24:     
c@24:     static Vamp::Plugin *
c@24:     toVampRequest_Finish(json11::Json j, PluginHandleMapper &mapper) {
c@24:         
c@24:         checkTypeField(j, "finish");
c@24:         return mapper.handleToPlugin(j["content"]["pluginHandle"].int_value());
c@24:     }
c@24:     
c@24:     static Vamp::HostExt::ProcessResponse
c@24:     toVampResponse_Finish(json11::Json j) {
c@24:         
c@24:         Vamp::HostExt::ProcessResponse resp;
c@24:         if (successful(j)) {
c@24:             resp.features = toFeatureSet(j["content"]);
c@24:         }
c@24:         return resp;
c@24:     }
c@5: };
c@5: 
c@10: }
c@5: 
c@5: #endif