comparison vamp-json/VampJson.h @ 139:1c58149b64a2

Fix various compiler warnings

 
 #include <vector>
 #include <string>
 #include <sstream>
 #include <iterator>
+#include <cmath>
 
 #include <json11/json11.hpp>
 #include <base-n/include/basen.hpp>
 
 #include <vamp-hostsdk/Plugin.h>

 
         if (!j["sampleRate"].is_number()) {
             err = "number expected for sample rate";
             return {};
         }
-        od.sampleRate = j["sampleRate"].number_value();
+        od.sampleRate = float(j["sampleRate"].number_value());
         od.hasDuration = j["hasDuration"].bool_value();
 
         if (j["binCount"].is_number() && j["binCount"].int_value() > 0) {
             od.hasFixedBinCount = true;
             od.binCount = j["binCount"].int_value();

         
         od.hasKnownExtents = extentsPresent;
 
         if (j["quantizeStep"].is_number()) {
             od.isQuantized = true;
-            od.quantizeStep = j["quantizeStep"].number_value();
+            od.quantizeStep = float(j["quantizeStep"].number_value());
         } else {
             od.isQuantized = false;
         }
 
         return od;

         if (!j["defaultValue"].is_number()) {
             err = "number expected for default value";
             return {};
         }
     
-        pd.defaultValue = j["defaultValue"].number_value();
+        pd.defaultValue = float(j["defaultValue"].number_value());
 
         pd.valueNames.clear();
         for (auto &n: j["valueNames"].array_items()) {
             if (!n.is_string()) {
                 err = "string expected for value name";

             pd.valueNames.push_back(n.string_value());
         }
 
         if (j["quantizeStep"].is_number()) {
             pd.isQuantized = true;
-            pd.quantizeStep = j["quantizeStep"].number_value();
+            pd.quantizeStep = float(j["quantizeStep"].number_value());
         } else {
             pd.isQuantized = false;
         }
 
         return pd;

             f.values = toFloatBuffer(j["featureValues"].string_value(), err);
             if (failed(err)) return {};
             serialisation = BufferSerialisation::Base64;
         } else if (j["featureValues"].is_array()) {
             for (auto v : j["featureValues"].array_items()) {
-                f.values.push_back(v.number_value());
+                f.values.push_back(float(v.number_value()));
             }
             serialisation = BufferSerialisation::Array;
         }
         f.label = j["label"].string_value();
         return f;

             return {};
         }
 
         PluginConfiguration config;
 
-        config.channelCount = j["channelCount"].number_value();
-        config.stepSize = j["stepSize"].number_value();
-        config.blockSize = j["blockSize"].number_value();
+        config.channelCount = int(round(j["channelCount"].number_value()));
+        config.stepSize = int(round(j["stepSize"].number_value()));
+        config.blockSize = int(round(j["blockSize"].number_value()));
         
         for (auto &pv : j["parameterValues"].object_items()) {
-            config.parameterValues[pv.first] = pv.second.number_value();
+            config.parameterValues[pv.first] = float(pv.second.number_value());
         }
 
         if (j["currentProgram"].is_string()) {
             config.currentProgram = j["currentProgram"].string_value();
         }

             return {};
         }
     
         LoadRequest req;
         req.pluginKey = j["key"].string_value();
-        req.inputSampleRate = j["inputSampleRate"].number_value();
+        req.inputSampleRate = float(j["inputSampleRate"].number_value());
         if (!j["adapterFlags"].is_null()) {
             req.adapterFlags = toAdapterFlags(j["adapterFlags"], err);
             if (failed(err)) return {};
         }
         return req;

                 serialisation = BufferSerialisation::Base64;
 
             } else if (a.is_array()) {
                 std::vector<float> buf;
                 for (auto v : a.array_items()) {
-                    buf.push_back(v.number_value());
+                    buf.push_back(float(v.number_value()));
                 }
                 r.inputBuffers.push_back(buf);
                 serialisation = BufferSerialisation::Array;
 
             } else {