comparison transform/FeatureExtractionPluginTransform.cpp @ 66:7afcfe666910

* Modify to use Vamp SDK for proper feature extraction plugins.
  Requires that the vamp-plugin-sdk directory tree be present below
  plugin/ (it's separate in Subversion).

 */
 
 #include "FeatureExtractionPluginTransform.h"
 
 #include "plugin/FeatureExtractionPluginFactory.h"
-#include "plugin/FeatureExtractionPlugin.h"
+#include "plugin/PluginXml.h"
+#include "vamp-sdk/Plugin.h"
 
 #include "base/Model.h"
 #include "model/SparseOneDimensionalModel.h"
 #include "model/SparseTimeValueModel.h"
 #include "model/DenseThreeDimensionalModel.h"

 		  << pluginId.toStdString() << "\"" << std::endl;
 	return;
     }
 
     if (configurationXml != "") {
-        m_plugin->setParametersFromXml(configurationXml);
-    }
-
-    FeatureExtractionPlugin::OutputList outputs =
+        PluginXml(m_plugin).setParametersFromXml(configurationXml);
+    }
+
+    Vamp::Plugin::OutputList outputs =
 	m_plugin->getOutputDescriptors();
 
     if (outputs.empty()) {
 	std::cerr << "FeatureExtractionPluginTransform: Plugin \""
 		  << pluginId.toStdString() << "\" has no outputs" << std::endl;

     }
     
     for (size_t i = 0; i < outputs.size(); ++i) {
 	if (outputName == "" || outputs[i].name == outputName.toStdString()) {
 	    m_outputFeatureNo = i;
-	    m_descriptor = new FeatureExtractionPlugin::OutputDescriptor
+	    m_descriptor = new Vamp::Plugin::OutputDescriptor
 		(outputs[i]);
 	    break;
 	}
     }
 

     size_t modelRate = m_input->getSampleRate();
     size_t modelResolution = 1;
     
     switch (m_descriptor->sampleType) {
 
-    case FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate:
+    case Vamp::Plugin::OutputDescriptor::VariableSampleRate:
 	if (m_descriptor->sampleRate != 0.0) {
 	    modelResolution = size_t(modelRate / m_descriptor->sampleRate + 0.001);
 	}
 	break;
 
-    case FeatureExtractionPlugin::OutputDescriptor::OneSamplePerStep:
+    case Vamp::Plugin::OutputDescriptor::OneSamplePerStep:
 	modelResolution = m_plugin->getPreferredStepSize();
 	break;
 
-    case FeatureExtractionPlugin::OutputDescriptor::FixedSampleRate:
+    case Vamp::Plugin::OutputDescriptor::FixedSampleRate:
 	modelRate = m_descriptor->sampleRate;
 	break;
     }
 
     if (valueCount == 0) {

 
     } else if (valueCount == 1 ||
 
 	       // We don't have a sparse 3D model
 	       m_descriptor->sampleType ==
-	       FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) {
+	       Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 	
         SparseTimeValueModel *model = new SparseTimeValueModel
             (modelRate, modelResolution, minValue, maxValue, false);
         model->setScaleUnits(outputs[m_outputFeatureNo].unit.c_str());
 

 		    buffers[ch][got++] = 0.0;
 		}
 	    }
 	}
 
-	FeatureExtractionPlugin::FeatureSet features = m_plugin->process
-	    (buffers, RealTime::frame2RealTime(blockFrame, sampleRate));
+	Vamp::Plugin::FeatureSet features = m_plugin->process
+	    (buffers, Vamp::RealTime::frame2RealTime(blockFrame, sampleRate));
 
 	for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) {
-	    FeatureExtractionPlugin::Feature feature =
+	    Vamp::Plugin::Feature feature =
 		features[m_outputFeatureNo][fi];
 	    addFeature(blockFrame, feature);
 	}
 
 	if (blockFrame == startFrame || completion > prevCompletion) {

 	}
 
 	blockFrame += stepSize;
     }
 
-    FeatureExtractionPlugin::FeatureSet features = m_plugin->getRemainingFeatures();
+    Vamp::Plugin::FeatureSet features = m_plugin->getRemainingFeatures();
 
     for (size_t fi = 0; fi < features[m_outputFeatureNo].size(); ++fi) {
-	FeatureExtractionPlugin::Feature feature =
+	Vamp::Plugin::Feature feature =
 	    features[m_outputFeatureNo][fi];
 	addFeature(blockFrame, feature);
     }
 
     setCompletion(100);
 }
 
 
 void
 FeatureExtractionPluginTransform::addFeature(size_t blockFrame,
-					     const FeatureExtractionPlugin::Feature &feature)
+					     const Vamp::Plugin::Feature &feature)
 {
     size_t inputRate = m_input->getSampleRate();
 
 //    std::cerr << "FeatureExtractionPluginTransform::addFeature("
 //	      << blockFrame << ")" << std::endl;

     }
 
     size_t frame = blockFrame;
 
     if (m_descriptor->sampleType ==
-	FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) {
+	Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 
 	if (!feature.hasTimestamp) {
 	    std::cerr
 		<< "WARNING: FeatureExtractionPluginTransform::addFeature: "
 		<< "Feature has variable sample rate but no timestamp!"
 		<< std::endl;
 	    return;
 	} else {
-	    frame = RealTime::realTime2Frame(feature.timestamp, inputRate);
+	    frame = Vamp::RealTime::realTime2Frame(feature.timestamp, inputRate);
 	}
 
     } else if (m_descriptor->sampleType ==
-	       FeatureExtractionPlugin::OutputDescriptor::FixedSampleRate) {
+	       Vamp::Plugin::OutputDescriptor::FixedSampleRate) {
 
 	if (feature.hasTimestamp) {
 	    //!!! warning: sampleRate may be non-integral
-	    frame = RealTime::realTime2Frame(feature.timestamp,
-					     m_descriptor->sampleRate);
+	    frame = Vamp::RealTime::realTime2Frame(feature.timestamp,
+                                                   m_descriptor->sampleRate);
 	} else {
 	    frame = m_output->getEndFrame() + 1;
 	}
     }
 	

 	if (!model) return;
 	model->addPoint(SparseOneDimensionalModel::Point(frame, feature.label.c_str()));
 	
     } else if (valueCount == 1 ||
 	       m_descriptor->sampleType == 
-	       FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) {
+	       Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 
 	float value = 0.0;
 	if (feature.values.size() > 0) value = feature.values[0];
 
 	SparseTimeValueModel *model = getOutput<SparseTimeValueModel>();

 	if (!model) return;
 	model->setCompletion(completion);
 
     } else if (valueCount == 1 ||
 	       m_descriptor->sampleType ==
-	       FeatureExtractionPlugin::OutputDescriptor::VariableSampleRate) {
+	       Vamp::Plugin::OutputDescriptor::VariableSampleRate) {
 
 	SparseTimeValueModel *model = getOutput<SparseTimeValueModel>();
 	if (!model) return;
 	model->setCompletion(completion);