comparison plugins/SimilarityPlugin.cpp @ 41:b9fb6dee85f7

* Add similarity plugin

+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
+
+/*
+ * SegmenterPlugin.cpp
+ *
+ * Copyright 2008 Centre for Digital Music, Queen Mary, University of London.
+ * All rights reserved.
+ */
+
+#include <iostream>
+#include <sstream>
+
+#include "SimilarityPlugin.h"
+#include "dsp/mfcc/MFCC.h"
+#include "dsp/rateconversion/Decimator.h"
+
+using std::string;
+using std::vector;
+using std::cerr;
+using std::endl;
+using std::ostringstream;
+
+SimilarityPlugin::SimilarityPlugin(float inputSampleRate) :
+    Plugin(inputSampleRate),
+    m_mfcc(0),
+    m_decimator(0),
+    m_K(20),
+    m_blockSize(0),
+    m_channels(0)
+{
+	
+}
+
+SimilarityPlugin::~SimilarityPlugin()
+{
+    delete m_mfcc;
+    delete m_decimator;
+}
+
+string
+SimilarityPlugin::getIdentifier() const
+{
+    return "qm-similarity";
+}
+
+string
+SimilarityPlugin::getName() const
+{
+    return "Similarity";
+}
+
+string
+SimilarityPlugin::getDescription() const
+{
+    return "Return a distance metric for overall timbral similarity between the input audio channels";
+}
+
+string
+SimilarityPlugin::getMaker() const
+{
+    return "Chris Cannam, Queen Mary, University of London";
+}
+
+int
+SimilarityPlugin::getPluginVersion() const
+{
+    return 1;
+}
+
+string
+SimilarityPlugin::getCopyright() const
+{
+    return "Copyright (c) 2008 - All Rights Reserved";
+}
+
+size_t
+SimilarityPlugin::getMinChannelCount() const
+{
+    return 2;
+}
+
+size_t
+SimilarityPlugin::getMaxChannelCount() const
+{
+    return 1024;
+}
+
+bool
+SimilarityPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+    if (channels < getMinChannelCount() ||
+	channels > getMaxChannelCount()) return false;
+
+    if (stepSize != getPreferredStepSize()) {
+        std::cerr << "SimilarityPlugin::initialise: supplied step size "
+                  << stepSize << " differs from required step size "
+                  << getPreferredStepSize() << std::endl;
+        return false;
+    }
+
+    if (blockSize != getPreferredBlockSize()) {
+        std::cerr << "SimilarityPlugin::initialise: supplied block size "
+                  << blockSize << " differs from required block size "
+                  << getPreferredBlockSize() << std::endl;
+        return false;
+    }        
+    
+    m_blockSize = blockSize;
+    m_channels = channels;
+
+    int decimationFactor = getDecimationFactor();
+    if (decimationFactor > 1) {
+        m_decimator = new Decimator(getPreferredBlockSize(), decimationFactor);
+    }
+
+    MFCCConfig config;
+    config.FS = lrintf(m_inputSampleRate) / decimationFactor;
+    config.fftsize = 2048;
+    config.nceps = m_K - 1;
+    config.want_c0 = true;
+    m_mfcc = new MFCC(config);
+    
+    for (int i = 0; i < m_channels; ++i) {
+        m_mfeatures.push_back(MFCCFeatureVector());
+    }
+
+    return true;
+}
+
+void
+SimilarityPlugin::reset()
+{
+    //!!!
+}
+
+int
+SimilarityPlugin::getDecimationFactor() const
+{
+    int rate = lrintf(m_inputSampleRate);
+    int internalRate = 22050;
+    int decimationFactor = rate / internalRate;
+    if (decimationFactor < 1) decimationFactor = 1;
+
+    // must be a power of two
+    while (decimationFactor & (decimationFactor - 1)) ++decimationFactor;
+
+    return decimationFactor;
+}
+
+size_t
+SimilarityPlugin::getPreferredStepSize() const
+{
+    return 1024 * getDecimationFactor();
+}
+
+size_t
+SimilarityPlugin::getPreferredBlockSize() const
+{
+    return 2048 * getDecimationFactor();
+}
+
+SimilarityPlugin::ParameterList SimilarityPlugin::getParameterDescriptors() const
+{
+    ParameterList list;
+    return list;
+}
+
+float
+SimilarityPlugin::getParameter(std::string param) const
+{
+    std::cerr << "WARNING: SimilarityPlugin::getParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+    return 0.0;
+}
+
+void
+SimilarityPlugin::setParameter(std::string param, float value)
+{
+    std::cerr << "WARNING: SimilarityPlugin::setParameter: unknown parameter \""
+              << param << "\"" << std::endl;
+}
+
+SimilarityPlugin::OutputList
+SimilarityPlugin::getOutputDescriptors() const
+{
+    OutputList list;
+	
+    OutputDescriptor similarity;
+    similarity.identifier = "distance";
+    similarity.name = "Distance";
+    similarity.description = "Distance Metric for Timbral Similarity (smaller = more similar)";
+    similarity.unit = "";
+    similarity.hasFixedBinCount = true;
+    similarity.binCount = m_channels;
+    similarity.hasKnownExtents = false;
+    similarity.isQuantized = false;
+    similarity.sampleType = OutputDescriptor::FixedSampleRate;
+    similarity.sampleRate = 1;
+	
+    list.push_back(similarity);
+	
+    OutputDescriptor means;
+    means.identifier = "means";
+    means.name = "MFCC Means";
+    means.description = "";
+    means.unit = "";
+    means.hasFixedBinCount = true;
+    means.binCount = m_channels;
+    means.hasKnownExtents = false;
+    means.isQuantized = false;
+    means.sampleType = OutputDescriptor::VariableSampleRate;
+    means.sampleRate = m_inputSampleRate / getPreferredStepSize();
+	
+    list.push_back(means);
+    
+    OutputDescriptor variances;
+    variances.identifier = "variances";
+    variances.name = "MFCC Variances";
+    variances.description = "";
+    variances.unit = "";
+    variances.hasFixedBinCount = true;
+    variances.binCount = m_channels;
+    variances.hasKnownExtents = false;
+    variances.isQuantized = false;
+    variances.sampleType = OutputDescriptor::VariableSampleRate;
+    variances.sampleRate = m_inputSampleRate / getPreferredStepSize();
+	
+    list.push_back(variances);
+    
+    return list;
+}
+
+SimilarityPlugin::FeatureSet
+SimilarityPlugin::process(const float *const *inputBuffers, Vamp::RealTime /* timestamp */)
+{
+    double *dblbuf = new double[m_blockSize];
+    double *decbuf = dblbuf;
+    if (m_decimator) decbuf = new double[m_mfcc->getfftlength()];
+    double *ceps = new double[m_K];
+
+    for (size_t c = 0; c < m_channels; ++c) {
+
+        for (int i = 0; i < m_blockSize; ++i) {
+            dblbuf[i] = inputBuffers[c][i];
+        }
+
+        if (m_decimator) {
+            m_decimator->process(dblbuf, decbuf);
+        }
+        
+        m_mfcc->process(m_mfcc->getfftlength(), decbuf, ceps);
+        
+        MFCCFeature mf(m_K);
+        for (int i = 0; i < m_K; ++i) mf[i] = ceps[i];
+
+        m_mfeatures[c].push_back(mf);
+    }
+
+    if (m_decimator) delete[] decbuf;
+    delete[] dblbuf;
+    delete[] ceps;
+	
+    return FeatureSet();
+}
+
+SimilarityPlugin::FeatureSet
+SimilarityPlugin::getRemainingFeatures()
+{
+    std::vector<MFCCFeature> m(m_channels);
+    std::vector<MFCCFeature> v(m_channels);
+    
+    //!!! bail if m_mfeatures vectors are empty
+
+    for (int i = 0; i < m_channels; ++i) {
+
+        MFCCFeature mean(m_K), variance(m_K);
+
+        for (int j = 0; j < m_K; ++j) {
+
+            mean[j] = variance[j] = 0.0;
+            int count;
+
+            count = 0;
+            for (int k = 0; k < m_mfeatures[i].size(); ++k) {
+                double val = m_mfeatures[i][k][j];
+//                std::cout << "val = " << val << std::endl;
+                if (isnan(val) || isinf(val)) continue;
+                mean[j] += val;
+//                std::cout << "mean now = " << mean[j] << std::endl;
+                ++count;
+            }
+            if (count > 0) mean[j] /= count;
+//            std::cout << "divided by " << count << ", mean now " << mean[j] << std::endl;
+
+            count = 0;
+            for (int k = 0; k < m_mfeatures[i].size(); ++k) {
+                double val = ((m_mfeatures[i][k][j] - mean[j]) *
+                              (m_mfeatures[i][k][j] - mean[j]));
+                if (isnan(val) || isinf(val)) continue;
+                variance[j] += val;
+                ++count;
+            }
+            if (count > 0) variance[j] /= count;
+        }
+
+        m[i] = mean;
+        v[i] = variance;
+    }
+
+//    std::cout << "m[0][0] = " << m[0][0] << std::endl;
+
+    // so we sorta return a matrix of the distances between channels,
+    // but Vamp doesn't have a matrix return type so we actually
+    // return a series of vectors
+
+    std::vector<std::vector<double> > distances;
+
+    for (int i = 0; i < m_channels; ++i) {
+        distances.push_back(std::vector<double>());
+        for (int j = 0; j < m_channels; ++j) {
+            double d = -2.0 * m_K;
+            for (int k = 0; k < m_K; ++k) {
+                // m[i][k] is the mean of mfcc k for channel i
+                // v[i][k] is the variance of mfcc k for channel i
+                d += v[i][k] / v[j][k] + v[j][k] / v[i][k];
+                d += (m[i][k] - m[j][k])
+                    * (1.0 / v[i][k] + 1.0 / v[j][k])
+                    * (m[i][k] - m[j][k]);
+            }
+            d /= 2.0;
+            distances[i].push_back(d);
+        }
+    }
+
+    FeatureSet returnFeatures;
+
+    for (int i = 0; i < m_channels; ++i) {
+
+        Feature feature;
+        feature.hasTimestamp = true; // otherwise hosts will tend to stamp them at the end of the file, which is annoying
+        feature.timestamp = Vamp::RealTime(i, 0);
+
+        feature.values.clear();
+        for (int k = 0; k < m_K; ++k) {
+            feature.values.push_back(m[i][k]);
+        }
+
+        returnFeatures[1].push_back(feature);
+
+        feature.values.clear();
+        for (int k = 0; k < m_K; ++k) {
+            feature.values.push_back(v[i][k]);
+        }
+
+        returnFeatures[2].push_back(feature);
+
+        feature.values.clear();
+        for (int j = 0; j < m_channels; ++j) {
+            feature.values.push_back(distances[i][j]);
+        }
+        ostringstream oss;
+        oss << "Distance from " << (i + 1);
+        feature.label = oss.str();
+		
+        returnFeatures[0].push_back(feature);
+    }
+
+    return returnFeatures;
+}