comparison src/MatchVampPlugin.cpp @ 180:d1bc89794cd4 tuning-rescale

Build with -Wconversion

     desc.identifier = "usespecdiff";
     desc.name = "Use feature difference";
     desc.description = "Whether to use half-wave rectified feature-to-feature difference instead of straight spectral or chroma feature";
     desc.minValue = 0;
     desc.maxValue = 1;
-    desc.defaultValue = (int)m_defaultFcParams.order;
+    desc.defaultValue = (float)m_defaultFcParams.order;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     list.push_back(desc);
 
     desc.identifier = "framenorm";
     desc.name = "Frame normalisation";
     desc.description = "Type of normalisation to use for features";
     desc.minValue = 0;
     desc.maxValue = 2;
-    desc.defaultValue = (int)m_defaultFcParams.norm;
+    desc.defaultValue = (float)m_defaultFcParams.norm;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     desc.valueNames.clear();
     desc.valueNames.push_back("None");
     desc.valueNames.push_back("Sum to 1");

     desc.identifier = "metric";
     desc.name = "Distance metric";
     desc.description = "Metric for distance calculations.";
     desc.minValue = 0;
     desc.maxValue = 2;
-    desc.defaultValue = (int)m_defaultDParams.metric;
+    desc.defaultValue = (float)m_defaultDParams.metric;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     desc.valueNames.clear();
     desc.valueNames.push_back("Manhattan");
     desc.valueNames.push_back("Euclidean");

     desc.identifier = "distnorm";
     desc.name = "Distance normalisation";
     desc.description = "Type of normalisation to use for distance metric";
     desc.minValue = 0;
     desc.maxValue = 2;
-    desc.defaultValue = (int)m_defaultDParams.norm;
+    desc.defaultValue = (float)m_defaultDParams.norm;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     desc.valueNames.clear();
     desc.valueNames.push_back("None");
     desc.valueNames.push_back("Sum of frames");

     desc.identifier = "noise";
     desc.name = "Add noise";
     desc.description = "Whether to mix in a small constant white noise term when calculating feature distance. This can improve alignment against sources containing cleanly synthesised audio.";
     desc.minValue = 0;
     desc.maxValue = 1;
-    desc.defaultValue = (int)m_defaultDParams.noise;
+    desc.defaultValue = (float)m_defaultDParams.noise;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     list.push_back(desc);
     
     desc.identifier = "gradientlimit";
     desc.name = "Gradient limit";
     desc.description = "Limit of number of frames that will be accepted from one source without a frame from the other source being accepted";
     desc.minValue = 1;
     desc.maxValue = 10;
-    desc.defaultValue = m_defaultParams.maxRunCount;
+    desc.defaultValue = (float)m_defaultParams.maxRunCount;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     list.push_back(desc);
 
     desc.identifier = "zonewidth";

 MatchVampPlugin::getParameter(std::string name) const
 {
     if (name == "serialise") {
         return m_serialise ? 1.0 : 0.0; 
     } else if (name == "framenorm") {
-        return (int)m_fcParams.norm;
+        return (float)m_fcParams.norm;
     } else if (name == "distnorm") {
-        return (int)m_dParams.norm;
+        return (float)m_dParams.norm;
     } else if (name == "usespecdiff") {
-        return (int)m_fcParams.order;
+        return (float)m_fcParams.order;
     } else if (name == "usechroma") {
         return m_feParams.useChromaFrequencyMap ? 1.0 : 0.0;
     } else if (name == "gradientlimit") {
-        return m_params.maxRunCount;
+        return (float)m_params.maxRunCount;
     } else if (name == "diagonalweight") {
         return m_params.diagonalWeight;
     } else if (name == "zonewidth") {
         return (float)m_params.blockTime;
     } else if (name == "smooth") {
         return m_smooth ? 1.0 : 0.0;
     } else if (name == "silencethreshold") {
         return (float)m_fcParams.silenceThreshold;
     } else if (name == "metric") {
-        return (int)m_dParams.metric;
+        return (float)m_dParams.metric;
     } else if (name == "noise") {
         return m_dParams.noise;
     } else if (name == "freq1") {
         return (float)m_feParams.referenceFrequency;
     } else if (name == "freq2") {

     if (channels < getMinChannelCount() ||
 	channels > getMaxChannelCount()) return false;
     if (stepSize > blockSize/2 ||
         blockSize != getPreferredBlockSize()) return false;
 
-    m_stepSize = stepSize;
+    m_stepSize = (int)stepSize;
     m_stepTime = float(stepSize) / m_inputSampleRate;
-    m_blockSize = blockSize;
+    m_blockSize = (int)blockSize;
 
     createMatchers();
     m_begin = true;
     m_locked = false;
 

     desc.hasKnownExtents = false;
     desc.isQuantized = true;
     desc.quantizeStep = 1;
     desc.sampleType = OutputDescriptor::VariableSampleRate;
     desc.sampleRate = outRate;
-    m_pathOutNo = list.size();
+    m_pathOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "a_b";
     desc.name = "A-B Timeline";
     desc.description = "Timing in performance B corresponding to moments in performance A";

     desc.binCount = 1;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::VariableSampleRate;
     desc.sampleRate = outRate;
-    m_abOutNo = list.size();
+    m_abOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "b_a";
     desc.name = "B-A Timeline";
     desc.description = "Timing in performance A corresponding to moments in performance B";

     desc.binCount = 1;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::VariableSampleRate;
     desc.sampleRate = outRate;
-    m_baOutNo = list.size();
+    m_baOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "a_b_divergence";
     desc.name = "A-B Divergence";
     desc.description = "Difference between timings in performances A and B";

     desc.binCount = 1;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::VariableSampleRate;
     desc.sampleRate = outRate;
-    m_abDivOutNo = list.size();
+    m_abDivOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "a_b_temporatio";
     desc.name = "A-B Tempo Ratio";
     desc.description = "Ratio of tempi between performances A and B";

     desc.binCount = 1;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::VariableSampleRate;
     desc.sampleRate = outRate;
-    m_abRatioOutNo = list.size();
+    m_abRatioOutNo = int(list.size());
     list.push_back(desc);
 
     int featureSize = FeatureExtractor(m_feParams).getFeatureSize();
     
     desc.identifier = "a_features";

     desc.binCount = featureSize;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::FixedSampleRate;
     desc.sampleRate = outRate;
-    m_aFeaturesOutNo = list.size();
+    m_aFeaturesOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "b_features";
     desc.name = "Raw B Features";
     desc.description = "Spectral features extracted from performance B";

     desc.binCount = featureSize;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::FixedSampleRate;
     desc.sampleRate = outRate;
-    m_bFeaturesOutNo = list.size();
+    m_bFeaturesOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "a_cfeatures";
     desc.name = "Conditioned A Features";
     desc.description = "Spectral features extracted from performance A, after normalisation and conditioning";

     desc.binCount = featureSize;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::FixedSampleRate;
     desc.sampleRate = outRate;
-    m_caFeaturesOutNo = list.size();
+    m_caFeaturesOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "b_cfeatures";
     desc.name = "Conditioned B Features";
     desc.description = "Spectral features extracted from performance B, after norrmalisation and conditioning";

     desc.binCount = featureSize;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::FixedSampleRate;
     desc.sampleRate = outRate;
-    m_cbFeaturesOutNo = list.size();
+    m_cbFeaturesOutNo = int(list.size());
     list.push_back(desc);
 
     desc.identifier = "overall_cost";
     desc.name = "Overall Cost";
     desc.description = "Normalised overall path cost for the cheapest path";

     desc.binCount = 1;
     desc.hasKnownExtents = false;
     desc.isQuantized = false;
     desc.sampleType = OutputDescriptor::FixedSampleRate;
     desc.sampleRate = 1;
-    m_overallCostOutNo = list.size();
+    m_overallCostOutNo = int(list.size());
     list.push_back(desc);
     
     return list;
 }
 

 
         int x = pathx[i];
         int y = pathy[i];
 
         Vamp::RealTime xt = Vamp::RealTime::frame2RealTime
-            (x * m_stepSize, lrintf(m_inputSampleRate));
+            (x * m_stepSize, int(m_inputSampleRate + 0.5));
         Vamp::RealTime yt = Vamp::RealTime::frame2RealTime
-            (y * m_stepSize, lrintf(m_inputSampleRate));
+            (y * m_stepSize, int(m_inputSampleRate + 0.5));
 
         Feature feature;
         feature.hasTimestamp = true;
         feature.timestamp = m_startTime + xt;
         feature.values.clear();