comparison vamp-json/VampJson.h @ 220:02de5df3a884

Add static output descriptor, pass through type URI

Note that the server doesn't actually populate any type URIs yet, so
this is only half-tested.

 
 /*
     Piper C++
 
     Centre for Digital Music, Queen Mary, University of London.
-    Copyright 2015-2016 QMUL.
+    Copyright 2015-2017 QMUL.
   
     Permission is hereby granted, free of charge, to any person
     obtaining a copy of this software and associated documentation
     files (the "Software"), to deal in the Software without
     restriction, including without limitation the rights to use, copy,

 #include <base-n/include/basen.hpp>
 
 #include <vamp-hostsdk/Plugin.h>
 #include <vamp-hostsdk/PluginLoader.h>
 
+#include "vamp-support/StaticOutputDescriptor.h"
 #include "vamp-support/PluginStaticData.h"
 #include "vamp-support/PluginConfiguration.h"
 #include "vamp-support/RequestResponse.h"
 
 #include "vamp-support/PluginHandleMapper.h"

             return Vamp::Plugin::OutputDescriptor::OneSamplePerStep;
         }
     }
 
     static json11::Json
+    fromStaticOutputDescriptor(const StaticOutputDescriptor &sd) {
+        json11::Json::object jo;
+        if (sd.typeURI != "") {
+            jo["typeURI"] = sd.typeURI;
+        }
+        return json11::Json(jo);
+    }
+    
+    static json11::Json
     fromConfiguredOutputDescriptor(const Vamp::Plugin::OutputDescriptor &desc) {
         json11::Json::object jo {
             { "unit", desc.unit },
             { "sampleType", fromSampleType(desc.sampleType) },
             { "sampleRate", desc.sampleRate },

         }
         return json11::Json(jo);
     }
     
     static json11::Json
-    fromOutputDescriptor(const Vamp::Plugin::OutputDescriptor &desc) {
+    fromOutputDescriptor(const Vamp::Plugin::OutputDescriptor &desc,
+                         const StaticOutputDescriptor &sd) {
         json11::Json::object jo {
             { "basic", fromBasicDescriptor(desc) },
+            { "static", fromStaticOutputDescriptor(sd) },
             { "configured", fromConfiguredOutputDescriptor(desc) }
         };
         return json11::Json(jo);
+    }
+
+    static StaticOutputDescriptor
+    toStaticOutputDescriptor(json11::Json j, std::string &err) {
+
+        StaticOutputDescriptor sd;
+        if (!j.is_object()) {
+            err = "object expected for static output descriptor";
+            return {};
+        }
+
+        sd.typeURI = j["typeURI"].string_value();
+        return sd;
     }
     
     static Vamp::Plugin::OutputDescriptor
     toConfiguredOutputDescriptor(json11::Json j, std::string &err) {
 

         }
 
         return od;
     }
     
-    static Vamp::Plugin::OutputDescriptor
+    static std::pair<Vamp::Plugin::OutputDescriptor, StaticOutputDescriptor>
     toOutputDescriptor(json11::Json j, std::string &err) {
 
         Vamp::Plugin::OutputDescriptor od;
         if (!j.is_object()) {
             err = "object expected for output descriptor";

         if (failed(err)) return {};
     
         toBasicDescriptor(j["basic"], od, err);
         if (failed(err)) return {};
 
-        return od;
+        StaticOutputDescriptor sd;
+        if (j["static"] != json11::Json()) {
+            sd = toStaticOutputDescriptor(j["static"], err);
+            if (failed(err)) return {};
+        }
+
+        return { od, sd };
     }
 
     static json11::Json
     fromParameterDescriptor(const Vamp::PluginBase::ParameterDescriptor &desc) {
 

 
         json11::Json::array outinfo;
         auto vouts = d.basicOutputInfo;
         for (auto &o: vouts) outinfo.push_back(fromBasicDescriptor(o));
         jo["basicOutputInfo"] = outinfo;
-    
+
+        json11::Json::object statinfo;
+        auto souts = d.staticOutputInfo;
+        for (auto &s: souts) jo[s.first] = fromStaticOutputDescriptor(s.second);
+        
         return json11::Json(jo);
     }
 
     static PluginStaticData
     toPluginStaticData(json11::Json j, std::string &err) {

 
         jo["handle"] = double(pmapper.pluginToHandle(cr.plugin));
         
         json11::Json::array outs;
         for (auto &d: cr.outputs) {
-            outs.push_back(fromOutputDescriptor(d));
+            auto id = d.identifier;
+            StaticOutputDescriptor sd;
+            if (cr.staticOutputInfo.find(id) != cr.staticOutputInfo.end()) {
+                sd = cr.staticOutputInfo.at(id);
+            }
+            outs.push_back(fromOutputDescriptor(d, sd));
         }
         jo["outputList"] = outs;
 
         json11::Json::object framing;
         framing["stepSize"] = cr.framing.stepSize;

         }
         
         cr.plugin = pmapper.handleToPlugin(j["handle"].int_value());
 
         for (const auto &o: j["outputList"].array_items()) {
-            cr.outputs.push_back(toOutputDescriptor(o, err));
+            auto odpair = toOutputDescriptor(o, err);
             if (failed(err)) return {};
+            cr.outputs.push_back(odpair.first);
+            cr.staticOutputInfo[odpair.first.identifier] = odpair.second;
         }
 
         cr.framing.stepSize = int(round(j["framing"]["stepSize"].number_value()));
         cr.framing.blockSize = int(round(j["framing"]["blockSize"].number_value()));