changeset 289:26027c3a99a0

Further wiring for ProgramParameters - should now be supported throughout

--- a/vamp-capnp/VampnProto.h	Tue Apr 07 18:04:53 2020 +0100
+++ b/vamp-capnp/VampnProto.h	Wed Apr 08 15:02:24 2020 +0100
@@ -534,6 +534,37 @@
         c.framing.stepSize = r.getFraming().getStepSize();
         c.framing.blockSize = r.getFraming().getBlockSize();
     }
+
+    static void
+    buildProgramParameterMap(piper::LoadResponse::PPPair::Builder &b,
+                             const PluginProgramParameters &pparams,
+                             std::string program) {
+        b.setProgram(program);
+        if (pparams.programParameters.find(program) ==
+            pparams.programParameters.end()) {
+            b.initParameters(0);
+            return;
+        }
+        auto params = b.initParameters
+            (unsigned(pparams.programParameters.at(program).size()));
+        int i = 0;
+        for (auto pv: pparams.programParameters.at(program)) {
+            params[i].setParameter(pv.first);
+            params[i].setValue(pv.second);
+            ++i;
+        }
+    }
+    
+    static void
+    readProgramParameterMap(PluginProgramParameters &pparams,
+                            const piper::LoadResponse::PPPair::Reader &r) {
+
+        auto program = r.getProgram();
+        auto params = r.getParameters();
+        for (auto pv: params) {
+            pparams.programParameters[program][pv.getParameter()] = pv.getValue();
+        }
+    }
     
     static void
     buildListRequest(piper::ListRequest::Builder &r,
@@ -636,6 +667,16 @@
         buildExtractorStaticData(sd, resp.staticData);
         auto conf = b.initDefaultConfiguration();
         buildConfiguration(conf, resp.defaultConfiguration);
+
+        auto pp = b.initProgramParameters
+            (unsigned(resp.programParameters.programParameters.size()));
+
+        int i = 0;
+        for (auto prog: resp.programParameters.programParameters) {
+            auto pb = pp[i];
+            buildProgramParameterMap(pb, resp.programParameters, prog.first);
+            ++i;
+        }
     }
 
     static void
@@ -648,6 +689,10 @@
         readExtractorStaticData(resp.staticData, r.getStaticData());
         readConfiguration(resp.defaultConfiguration,
                           r.getDefaultConfiguration());
+
+        for (auto pp: r.getProgramParameters()) {
+            readProgramParameterMap(resp.programParameters, pp);
+        }
     }
 
     static void

--- a/vamp-client/CapnpRRClient.h	Tue Apr 07 18:04:53 2020 +0100
+++ b/vamp-client/CapnpRRClient.h	Wed Apr 08 15:02:24 2020 +0100
@@ -188,7 +188,8 @@
                                                        req.inputSampleRate,
                                                        req.adapterFlags,
                                                        resp.staticData,
-                                                       resp.defaultConfiguration);
+                                                       resp.defaultConfiguration,
+                                                       resp.programParameters);
 
         Vamp::Plugin *plugin = new PiperVampPlugin(this,
                                                    req.pluginKey,
@@ -339,11 +340,14 @@
 
         PluginStaticData psd;
         PluginConfiguration defaultConfig;
+        PluginProgramParameters programParameters;
         PluginHandleMapper::Handle handle =
             serverLoad(plugin->getPluginKey(),
                        plugin->getInputSampleRate(),
                        plugin->getAdapterFlags(),
-                       psd, defaultConfig);
+                       psd,
+                       defaultConfig,
+                       programParameters);
 
         m_mapper.addPlugin(handle, plugin);
 
@@ -441,7 +445,8 @@
     PluginHandleMapper::Handle
     serverLoad(std::string key, float inputSampleRate, int adapterFlags,
                PluginStaticData &psd,
-               PluginConfiguration &defaultConfig) {
+               PluginConfiguration &defaultConfig,
+               PluginProgramParameters &programParameters) {
 
         LoadRequest request;
         request.pluginKey = key;
@@ -465,6 +470,9 @@
         const piper::LoadResponse::Reader &lr = reader.getResponse().getLoad();
         VampnProto::readExtractorStaticData(psd, lr.getStaticData());
         VampnProto::readConfiguration(defaultConfig, lr.getDefaultConfiguration());
+        for (auto pp: lr.getProgramParameters()) {
+            VampnProto::readProgramParameterMap(programParameters, pp);
+        }
         return lr.getHandle();
     };     
 

--- a/vamp-client/PiperVampPlugin.h	Tue Apr 07 18:04:53 2020 +0100
+++ b/vamp-client/PiperVampPlugin.h	Wed Apr 08 15:02:24 2020 +0100
@@ -120,7 +120,7 @@
         m_config(defaultConfig),
         m_programParameters(programParameters)
     { }
-
+    
     virtual ~PiperVampPlugin() {
         if (m_state != Finished && m_state != Failed) {
             try {

--- a/vamp-json/VampJson.h	Tue Apr 07 18:04:53 2020 +0100
+++ b/vamp-json/VampJson.h	Wed Apr 08 15:02:24 2020 +0100
@@ -874,6 +874,53 @@
     }
 
     static json11::Json
+    fromProgramParameters(const PluginProgramParameters &programParameters) {
+        
+        json11::Json::object jo;
+        for (const auto &pp: programParameters.programParameters) {
+            auto program = pp.first;
+            json11::Json::object po;
+            for (const auto &pv: pp.second) {
+                po[pv.first] = pv.second;
+            }
+            jo[program] = po;
+        }
+
+        return json11::Json(jo);
+    }
+
+    static PluginProgramParameters
+    toProgramParameters(json11::Json j, std::string &err) {
+
+        if (!j.is_object()) {
+            err = "object expected for program parameters";
+            return {};
+        }
+
+        PluginProgramParameters params;
+
+        auto pp = j.object_items();
+        for (auto program: pp) {
+            std::string name = program.first;
+            if (!program.second.is_object()) {
+                err = std::string("object expected for program parameter map ") +
+                    "(in program \"" + name + "\")";
+                return {};
+            }
+            for (auto p: program.second.object_items()) {
+                if (!p.second.is_number()) {
+                    err = std::string("number expected for program parameter value ") +
+                        "(in program \"" + name + "\")";
+                    return {};
+                }
+                params.programParameters[name][p.first] = p.second.number_value();
+            }
+        }
+
+        return params;
+    }
+    
+    static json11::Json
     fromListRequest(const ListRequest &req) {
         json11::Json::object jo;
         json11::Json::array arr;
@@ -966,6 +1013,8 @@
         jo["staticData"] = fromPluginStaticData(resp.staticData);
         jo["defaultConfiguration"] =
             fromPluginConfiguration(resp.defaultConfiguration);
+        jo["programParameters"] =
+            fromProgramParameters(resp.programParameters);
         return json11::Json(jo);
     }
 
@@ -986,9 +1035,15 @@
         resp.plugin = pmapper.handleToPlugin(h);
         resp.staticData = toPluginStaticData(j["staticData"], err);
         if (failed(err)) return {};
-        resp.defaultConfiguration = toPluginConfiguration(j["defaultConfiguration"],
-                                                          err);
+        resp.defaultConfiguration =
+            toPluginConfiguration(j["defaultConfiguration"], err);
         if (failed(err)) return {};
+        if (j.object_items().find("programParameters") !=
+            j.object_items().end()) {
+            resp.programParameters =
+                toProgramParameters(j["programParameters"], err);
+            if (failed(err)) return {};
+        }
         return resp;
     }
 

--- a/vamp-support/PluginProgramParameters.h	Tue Apr 07 18:04:53 2020 +0100
+++ b/vamp-support/PluginProgramParameters.h	Wed Apr 08 15:02:24 2020 +0100
@@ -65,11 +65,8 @@
         if (programs.empty()) return {};
 
         PluginProgramParameters pp;
-
         for (auto program: programs) {
-
             p->selectProgram(program);
-
             for (auto param: defaultConfiguration.parameterValues) {
                 auto id = param.first;
                 pp.programParameters[program][id] = p->getParameter(id);