From 50c51ce2392c44156b16f228b71f035766f64dfb Mon Sep 17 00:00:00 2001 From: Paul Davis Date: Fri, 25 Jan 2008 17:45:44 +0000 Subject: [PATCH] new plugin files to be packed with ardour git-svn-id: svn://localhost/ardour2/branches/2.0-ongoing@2966 d708f5d6-7413-0410-9779-e7cbd77b26cf --- libs/vamp-sdk/SConscript | 7 + libs/vamp-sdk/plugins/AmplitudeFollower.cpp | 247 +++++++++++++++ libs/vamp-sdk/plugins/AmplitudeFollower.h | 84 ++++++ .../plugins/PercussionOnsetDetector.cpp | 285 ++++++++++++++++++ .../plugins/PercussionOnsetDetector.h | 90 ++++++ libs/vamp-sdk/plugins/SpectralCentroid.cpp | 188 ++++++++++++ libs/vamp-sdk/plugins/SpectralCentroid.h | 78 +++++ libs/vamp-sdk/plugins/ZeroCrossing.cpp | 194 ++++++++++++ libs/vamp-sdk/plugins/ZeroCrossing.h | 78 +++++ libs/vamp-sdk/plugins/plugins.cpp | 63 ++++ 10 files changed, 1314 insertions(+) create mode 100644 libs/vamp-sdk/plugins/AmplitudeFollower.cpp create mode 100644 libs/vamp-sdk/plugins/AmplitudeFollower.h create mode 100644 libs/vamp-sdk/plugins/PercussionOnsetDetector.cpp create mode 100644 libs/vamp-sdk/plugins/PercussionOnsetDetector.h create mode 100644 libs/vamp-sdk/plugins/SpectralCentroid.cpp create mode 100644 libs/vamp-sdk/plugins/SpectralCentroid.h create mode 100644 libs/vamp-sdk/plugins/ZeroCrossing.cpp create mode 100644 libs/vamp-sdk/plugins/ZeroCrossing.h create mode 100644 libs/vamp-sdk/plugins/plugins.cpp diff --git a/libs/vamp-sdk/SConscript b/libs/vamp-sdk/SConscript index f6a27288f9..f8a25112a1 100644 --- a/libs/vamp-sdk/SConscript +++ b/libs/vamp-sdk/SConscript @@ -19,6 +19,8 @@ vamp-sdk/hostext/PluginWrapper.cpp vamp-sdk/RealTime.cpp """) +plugin_files = glob.glob ("plugins/*.cpp") + Import('env install_prefix libraries') vampsdk = env.Copy() @@ -26,17 +28,22 @@ vampsdk.Append (CPPATH='#libs/vamp-sdk/vamp', CXXFLAGS="-Ilibs/vamp-sdk") libvampsdk = vampsdk.SharedLibrary('vampsdk', vampsdk_files) libvamphostsdk = vampsdk.SharedLibrary('vamphostsdk', vamphostsdk_files) +libvampplugins = vampsdk.SharedLibrary('ardourvampplugins', plugin_files) Default(libvampsdk) Default(libvamphostsdk) +Default(libvampplugins) env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libvampsdk)) env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libvamphostsdk)) +env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2', 'vamp'), libvampplugins)) env.Alias('tarball', env.Distribute (env['DISTTREE'], [ 'SConscript', 'COPYING', 'README' ] + vampsdk_files + vamphostsdk_files + + plugin_files + glob.glob('vamp/*.h') + + glob.glob('plugins/*.h') + glob.glob('vamp-sdk/*.h') + glob.glob('vamp-sdk/hostext/*.h'))) diff --git a/libs/vamp-sdk/plugins/AmplitudeFollower.cpp b/libs/vamp-sdk/plugins/AmplitudeFollower.cpp new file mode 100644 index 0000000000..7023297d33 --- /dev/null +++ b/libs/vamp-sdk/plugins/AmplitudeFollower.cpp @@ -0,0 +1,247 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + This file copyright 2006 Dan Stowell. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#include "AmplitudeFollower.h" + +#include + +#include +#include +#include + +using std::string; +using std::vector; +using std::cerr; +using std::endl; + +/** + * An implementation of SuperCollider's amplitude-follower algorithm + * as a simple Vamp plugin. + */ + +AmplitudeFollower::AmplitudeFollower(float inputSampleRate) : + Plugin(inputSampleRate), + m_stepSize(0), + m_previn(0.0f), + m_clampcoef(0.01f), + m_relaxcoef(0.01f) +{ +} + +AmplitudeFollower::~AmplitudeFollower() +{ +} + +string +AmplitudeFollower::getIdentifier() const +{ + return "amplitudefollower"; +} + +string +AmplitudeFollower::getName() const +{ + return "Amplitude Follower"; +} + +string +AmplitudeFollower::getDescription() const +{ + return "Track the amplitude of the audio signal"; +} + +string +AmplitudeFollower::getMaker() const +{ + return "Vamp SDK Example Plugins"; +} + +int +AmplitudeFollower::getPluginVersion() const +{ + return 1; +} + +string +AmplitudeFollower::getCopyright() const +{ + return "Code copyright 2006 Dan Stowell; method from SuperCollider. Freely redistributable (BSD license)"; +} + +bool +AmplitudeFollower::initialise(size_t channels, size_t stepSize, size_t blockSize) +{ + if (channels < getMinChannelCount() || + channels > getMaxChannelCount()) return false; + + m_stepSize = std::min(stepSize, blockSize); + + // Translate the coefficients + // from their "convenient" 60dB convergence-time values + // to real coefficients + m_clampcoef = m_clampcoef==0.0 ? 0.0 : exp(log(0.1)/(m_clampcoef * m_inputSampleRate)); + m_relaxcoef = m_relaxcoef==0.0 ? 0.0 : exp(log(0.1)/(m_relaxcoef * m_inputSampleRate)); + + return true; +} + +void +AmplitudeFollower::reset() +{ + m_previn = 0.0f; +} + +AmplitudeFollower::OutputList +AmplitudeFollower::getOutputDescriptors() const +{ + OutputList list; + + OutputDescriptor sca; + sca.identifier = "amplitude"; + sca.name = "Amplitude"; + sca.description = ""; + sca.unit = "V"; + sca.hasFixedBinCount = true; + sca.binCount = 1; + sca.hasKnownExtents = false; + sca.isQuantized = false; + sca.sampleType = OutputDescriptor::OneSamplePerStep; + list.push_back(sca); + + return list; +} + +AmplitudeFollower::ParameterList +AmplitudeFollower::getParameterDescriptors() const +{ + ParameterList list; + + ParameterDescriptor att; + att.identifier = "attack"; + att.name = "Attack time"; + att.description = ""; + att.unit = "s"; + att.minValue = 0.0f; + att.maxValue = 1.f; + att.defaultValue = 0.01f; + att.isQuantized = false; + + list.push_back(att); + + ParameterDescriptor dec; + dec.identifier = "release"; + dec.name = "Release time"; + dec.description = ""; + dec.unit = "s"; + dec.minValue = 0.0f; + dec.maxValue = 1.f; + dec.defaultValue = 0.01f; + dec.isQuantized = false; + + list.push_back(dec); + + return list; +} + +void AmplitudeFollower::setParameter(std::string paramid, float newval) +{ + if (paramid == "attack") { + m_clampcoef = newval; + } else if (paramid == "release") { + m_relaxcoef = newval; + } +} + +float AmplitudeFollower::getParameter(std::string paramid) const +{ + if (paramid == "attack") { + return m_clampcoef; + } else if (paramid == "release") { + return m_relaxcoef; + } + + return 0.0f; +} + +AmplitudeFollower::FeatureSet +AmplitudeFollower::process(const float *const *inputBuffers, + Vamp::RealTime timestamp) +{ + if (m_stepSize == 0) { + cerr << "ERROR: AmplitudeFollower::process: " + << "AmplitudeFollower has not been initialised" + << endl; + return FeatureSet(); + } + + float previn = m_previn; + + FeatureSet returnFeatures; + + float val; + float peak = 0.0f; + + for (size_t i = 0; i < m_stepSize; ++i) { + + val = fabs(inputBuffers[0][i]); + + if (val < previn) { + val = val + (previn - val) * m_relaxcoef; + } else { + val = val + (previn - val) * m_clampcoef; + } + + if (val > peak) peak = val; + previn = val; + } + + m_previn = previn; + + // Now store the "feature" (peak amp) for this sample + Feature feature; + feature.hasTimestamp = false; + feature.values.push_back(peak); + returnFeatures[0].push_back(feature); + + return returnFeatures; +} + +AmplitudeFollower::FeatureSet +AmplitudeFollower::getRemainingFeatures() +{ + return FeatureSet(); +} + diff --git a/libs/vamp-sdk/plugins/AmplitudeFollower.h b/libs/vamp-sdk/plugins/AmplitudeFollower.h new file mode 100644 index 0000000000..6c3426e324 --- /dev/null +++ b/libs/vamp-sdk/plugins/AmplitudeFollower.h @@ -0,0 +1,84 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + This file copyright 2006 Dan Stowell. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#ifndef _AMPLITUDE_FOLLOWER_PLUGIN_H_ +#define _AMPLITUDE_FOLLOWER_PLUGIN_H_ + +#include "vamp-sdk/Plugin.h" + +/** + * Example plugin implementing the SuperCollider amplitude follower + * function. + */ + +class AmplitudeFollower : public Vamp::Plugin +{ +public: + AmplitudeFollower(float inputSampleRate); + virtual ~AmplitudeFollower(); + + bool initialise(size_t channels, size_t stepSize, size_t blockSize); + void reset(); + + InputDomain getInputDomain() const { return TimeDomain; } + + std::string getIdentifier() const; + std::string getName() const; + std::string getDescription() const; + std::string getMaker() const; + int getPluginVersion() const; + std::string getCopyright() const; + + OutputList getOutputDescriptors() const; + + ParameterList getParameterDescriptors() const; + float getParameter(std::string paramid) const; + void setParameter(std::string paramid, float newval); + + FeatureSet process(const float *const *inputBuffers, + Vamp::RealTime timestamp); + + FeatureSet getRemainingFeatures(); + +protected: + size_t m_stepSize; + float m_previn; + float m_clampcoef; + float m_relaxcoef; +}; + + +#endif diff --git a/libs/vamp-sdk/plugins/PercussionOnsetDetector.cpp b/libs/vamp-sdk/plugins/PercussionOnsetDetector.cpp new file mode 100644 index 0000000000..447eb19a28 --- /dev/null +++ b/libs/vamp-sdk/plugins/PercussionOnsetDetector.cpp @@ -0,0 +1,285 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#include "PercussionOnsetDetector.h" + +using std::string; +using std::vector; +using std::cerr; +using std::endl; + +#include + + +PercussionOnsetDetector::PercussionOnsetDetector(float inputSampleRate) : + Plugin(inputSampleRate), + m_stepSize(0), + m_blockSize(0), + m_threshold(3), + m_sensitivity(40), + m_priorMagnitudes(0), + m_dfMinus1(0), + m_dfMinus2(0) +{ +} + +PercussionOnsetDetector::~PercussionOnsetDetector() +{ + delete[] m_priorMagnitudes; +} + +string +PercussionOnsetDetector::getIdentifier() const +{ + return "percussiononsets"; +} + +string +PercussionOnsetDetector::getName() const +{ + return "Simple Percussion Onset Detector"; +} + +string +PercussionOnsetDetector::getDescription() const +{ + return "Detect percussive note onsets by identifying broadband energy rises"; +} + +string +PercussionOnsetDetector::getMaker() const +{ + return "Vamp SDK Example Plugins"; +} + +int +PercussionOnsetDetector::getPluginVersion() const +{ + return 2; +} + +string +PercussionOnsetDetector::getCopyright() const +{ + return "Code copyright 2006 Queen Mary, University of London, after Dan Barry et al 2005. Freely redistributable (BSD license)"; +} + +size_t +PercussionOnsetDetector::getPreferredStepSize() const +{ + return 0; +} + +size_t +PercussionOnsetDetector::getPreferredBlockSize() const +{ + return 1024; +} + +bool +PercussionOnsetDetector::initialise(size_t channels, size_t stepSize, size_t blockSize) +{ + if (channels < getMinChannelCount() || + channels > getMaxChannelCount()) return false; + + m_stepSize = stepSize; + m_blockSize = blockSize; + + m_priorMagnitudes = new float[m_blockSize/2]; + + for (size_t i = 0; i < m_blockSize/2; ++i) { + m_priorMagnitudes[i] = 0.f; + } + + m_dfMinus1 = 0.f; + m_dfMinus2 = 0.f; + + return true; +} + +void +PercussionOnsetDetector::reset() +{ + for (size_t i = 0; i < m_blockSize/2; ++i) { + m_priorMagnitudes[i] = 0.f; + } + + m_dfMinus1 = 0.f; + m_dfMinus2 = 0.f; +} + +PercussionOnsetDetector::ParameterList +PercussionOnsetDetector::getParameterDescriptors() const +{ + ParameterList list; + + ParameterDescriptor d; + d.identifier = "threshold"; + d.name = "Energy rise threshold"; + d.description = "Energy rise within a frequency bin necessary to count toward broadband total"; + d.unit = "dB"; + d.minValue = 0; + d.maxValue = 20; + d.defaultValue = 3; + d.isQuantized = false; + list.push_back(d); + + d.identifier = "sensitivity"; + d.name = "Sensitivity"; + d.description = "Sensitivity of peak detector applied to broadband detection function"; + d.unit = "%"; + d.minValue = 0; + d.maxValue = 100; + d.defaultValue = 40; + d.isQuantized = false; + list.push_back(d); + + return list; +} + +float +PercussionOnsetDetector::getParameter(std::string id) const +{ + if (id == "threshold") return m_threshold; + if (id == "sensitivity") return m_sensitivity; + return 0.f; +} + +void +PercussionOnsetDetector::setParameter(std::string id, float value) +{ + if (id == "threshold") { + if (value < 0) value = 0; + if (value > 20) value = 20; + m_threshold = value; + } else if (id == "sensitivity") { + if (value < 0) value = 0; + if (value > 100) value = 100; + m_sensitivity = value; + } +} + +PercussionOnsetDetector::OutputList +PercussionOnsetDetector::getOutputDescriptors() const +{ + OutputList list; + + OutputDescriptor d; + d.identifier = "onsets"; + d.name = "Onsets"; + d.description = "Percussive note onset locations"; + d.unit = ""; + d.hasFixedBinCount = true; + d.binCount = 0; + d.hasKnownExtents = false; + d.isQuantized = false; + d.sampleType = OutputDescriptor::VariableSampleRate; + d.sampleRate = m_inputSampleRate; + list.push_back(d); + + d.identifier = "detectionfunction"; + d.name = "Detection Function"; + d.description = "Broadband energy rise detection function"; + d.binCount = 1; + d.isQuantized = true; + d.quantizeStep = 1.0; + d.sampleType = OutputDescriptor::OneSamplePerStep; + list.push_back(d); + + return list; +} + +PercussionOnsetDetector::FeatureSet +PercussionOnsetDetector::process(const float *const *inputBuffers, + Vamp::RealTime ts) +{ + if (m_stepSize == 0) { + cerr << "ERROR: PercussionOnsetDetector::process: " + << "PercussionOnsetDetector has not been initialised" + << endl; + return FeatureSet(); + } + + int count = 0; + + for (size_t i = 1; i < m_blockSize/2; ++i) { + + float real = inputBuffers[0][i*2]; + float imag = inputBuffers[0][i*2 + 1]; + + float sqrmag = real * real + imag * imag; + + if (m_priorMagnitudes[i] > 0.f) { + float diff = 10.f * log10f(sqrmag / m_priorMagnitudes[i]); + +// std::cout << "i=" << i << ", mag=" << mag << ", prior=" << m_priorMagnitudes[i] << ", diff=" << diff << ", threshold=" << m_threshold << std::endl; + + if (diff >= m_threshold) ++count; + } + + m_priorMagnitudes[i] = sqrmag; + } + + FeatureSet returnFeatures; + + Feature detectionFunction; + detectionFunction.hasTimestamp = false; + detectionFunction.values.push_back(count); + returnFeatures[1].push_back(detectionFunction); + + if (m_dfMinus2 < m_dfMinus1 && + m_dfMinus1 >= count && + m_dfMinus1 > ((100 - m_sensitivity) * m_blockSize) / 200) { + + Feature onset; + onset.hasTimestamp = true; + onset.timestamp = ts - Vamp::RealTime::frame2RealTime + (m_stepSize, lrintf(m_inputSampleRate)); + returnFeatures[0].push_back(onset); + } + + m_dfMinus2 = m_dfMinus1; + m_dfMinus1 = count; + + return returnFeatures; +} + +PercussionOnsetDetector::FeatureSet +PercussionOnsetDetector::getRemainingFeatures() +{ + return FeatureSet(); +} + diff --git a/libs/vamp-sdk/plugins/PercussionOnsetDetector.h b/libs/vamp-sdk/plugins/PercussionOnsetDetector.h new file mode 100644 index 0000000000..d54c0cfa13 --- /dev/null +++ b/libs/vamp-sdk/plugins/PercussionOnsetDetector.h @@ -0,0 +1,90 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#ifndef _PERCUSSION_ONSET_DETECTOR_PLUGIN_H_ +#define _PERCUSSION_ONSET_DETECTOR_PLUGIN_H_ + +#include "vamp-sdk/Plugin.h" + +/** + * Example plugin that detects percussive events. + */ + +class PercussionOnsetDetector : public Vamp::Plugin +{ +public: + PercussionOnsetDetector(float inputSampleRate); + virtual ~PercussionOnsetDetector(); + + bool initialise(size_t channels, size_t stepSize, size_t blockSize); + void reset(); + + InputDomain getInputDomain() const { return FrequencyDomain; } + + std::string getIdentifier() const; + std::string getName() const; + std::string getDescription() const; + std::string getMaker() const; + int getPluginVersion() const; + std::string getCopyright() const; + + size_t getPreferredStepSize() const; + size_t getPreferredBlockSize() const; + + ParameterList getParameterDescriptors() const; + float getParameter(std::string id) const; + void setParameter(std::string id, float value); + + OutputList getOutputDescriptors() const; + + FeatureSet process(const float *const *inputBuffers, + Vamp::RealTime timestamp); + + FeatureSet getRemainingFeatures(); + +protected: + size_t m_stepSize; + size_t m_blockSize; + + float m_threshold; + float m_sensitivity; + float *m_priorMagnitudes; + float m_dfMinus1; + float m_dfMinus2; +}; + + +#endif diff --git a/libs/vamp-sdk/plugins/SpectralCentroid.cpp b/libs/vamp-sdk/plugins/SpectralCentroid.cpp new file mode 100644 index 0000000000..82d80b8100 --- /dev/null +++ b/libs/vamp-sdk/plugins/SpectralCentroid.cpp @@ -0,0 +1,188 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#include "SpectralCentroid.h" + +using std::string; +using std::vector; +using std::cerr; +using std::endl; + +#include + + +SpectralCentroid::SpectralCentroid(float inputSampleRate) : + Plugin(inputSampleRate), + m_stepSize(0), + m_blockSize(0) +{ +} + +SpectralCentroid::~SpectralCentroid() +{ +} + +string +SpectralCentroid::getIdentifier() const +{ + return "spectralcentroid"; +} + +string +SpectralCentroid::getName() const +{ + return "Spectral Centroid"; +} + +string +SpectralCentroid::getDescription() const +{ + return "Calculate the centroid frequency of the spectrum of the input signal"; +} + +string +SpectralCentroid::getMaker() const +{ + return "Vamp SDK Example Plugins"; +} + +int +SpectralCentroid::getPluginVersion() const +{ + return 2; +} + +string +SpectralCentroid::getCopyright() const +{ + return "Freely redistributable (BSD license)"; +} + +bool +SpectralCentroid::initialise(size_t channels, size_t stepSize, size_t blockSize) +{ + if (channels < getMinChannelCount() || + channels > getMaxChannelCount()) return false; + + m_stepSize = stepSize; + m_blockSize = blockSize; + + return true; +} + +void +SpectralCentroid::reset() +{ +} + +SpectralCentroid::OutputList +SpectralCentroid::getOutputDescriptors() const +{ + OutputList list; + + OutputDescriptor d; + d.identifier = "logcentroid"; + d.name = "Log Frequency Centroid"; + d.description = "Centroid of the log weighted frequency spectrum"; + d.unit = "Hz"; + d.hasFixedBinCount = true; + d.binCount = 1; + d.hasKnownExtents = false; + d.isQuantized = false; + d.sampleType = OutputDescriptor::OneSamplePerStep; + list.push_back(d); + + d.identifier = "linearcentroid"; + d.name = "Linear Frequency Centroid"; + d.description = "Centroid of the linear frequency spectrum"; + list.push_back(d); + + return list; +} + +SpectralCentroid::FeatureSet +SpectralCentroid::process(const float *const *inputBuffers, Vamp::RealTime) +{ + if (m_stepSize == 0) { + cerr << "ERROR: SpectralCentroid::process: " + << "SpectralCentroid has not been initialised" + << endl; + return FeatureSet(); + } + + double numLin = 0.0, numLog = 0.0, denom = 0.0; + + for (size_t i = 1; i <= m_blockSize/2; ++i) { + double freq = (double(i) * m_inputSampleRate) / m_blockSize; + double real = inputBuffers[0][i*2]; + double imag = inputBuffers[0][i*2 + 1]; + double power = sqrt(real * real + imag * imag) / (m_blockSize/2); + numLin += freq * power; + numLog += log10f(freq) * power; + denom += power; + } + + FeatureSet returnFeatures; + +// std::cerr << "power " << denom << ", block size " << m_blockSize << std::endl; + + if (denom != 0.0) { + float centroidLin = float(numLin / denom); + float centroidLog = powf(10, float(numLog / denom)); + + Feature feature; + feature.hasTimestamp = false; + if (!std::isnan(centroidLog) && !std::isinf(centroidLog)) { + feature.values.push_back(centroidLog); + } + returnFeatures[0].push_back(feature); + + feature.values.clear(); + if (!std::isnan(centroidLin) && !std::isinf(centroidLin)) { + feature.values.push_back(centroidLin); + } + returnFeatures[1].push_back(feature); + } + + return returnFeatures; +} + +SpectralCentroid::FeatureSet +SpectralCentroid::getRemainingFeatures() +{ + return FeatureSet(); +} + diff --git a/libs/vamp-sdk/plugins/SpectralCentroid.h b/libs/vamp-sdk/plugins/SpectralCentroid.h new file mode 100644 index 0000000000..02cc8d981d --- /dev/null +++ b/libs/vamp-sdk/plugins/SpectralCentroid.h @@ -0,0 +1,78 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#ifndef _SPECTRAL_CENTROID_PLUGIN_H_ +#define _SPECTRAL_CENTROID_PLUGIN_H_ + +#include "vamp-sdk/Plugin.h" + +/** + * Example plugin that calculates the centre of gravity of the + * frequency domain representation of each block of audio. + */ + +class SpectralCentroid : public Vamp::Plugin +{ +public: + SpectralCentroid(float inputSampleRate); + virtual ~SpectralCentroid(); + + bool initialise(size_t channels, size_t stepSize, size_t blockSize); + void reset(); + + InputDomain getInputDomain() const { return FrequencyDomain; } + + std::string getIdentifier() const; + std::string getName() const; + std::string getDescription() const; + std::string getMaker() const; + int getPluginVersion() const; + std::string getCopyright() const; + + OutputList getOutputDescriptors() const; + + FeatureSet process(const float *const *inputBuffers, + Vamp::RealTime timestamp); + + FeatureSet getRemainingFeatures(); + +protected: + size_t m_stepSize; + size_t m_blockSize; +}; + + +#endif diff --git a/libs/vamp-sdk/plugins/ZeroCrossing.cpp b/libs/vamp-sdk/plugins/ZeroCrossing.cpp new file mode 100644 index 0000000000..4b678e3f8f --- /dev/null +++ b/libs/vamp-sdk/plugins/ZeroCrossing.cpp @@ -0,0 +1,194 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#include "ZeroCrossing.h" + +using std::string; +using std::vector; +using std::cerr; +using std::endl; + + +ZeroCrossing::ZeroCrossing(float inputSampleRate) : + Plugin(inputSampleRate), + m_stepSize(0), + m_previousSample(0.0f) +{ +} + +ZeroCrossing::~ZeroCrossing() +{ +} + +string +ZeroCrossing::getIdentifier() const +{ + return "zerocrossing"; +} + +string +ZeroCrossing::getName() const +{ + return "Zero Crossings"; +} + +string +ZeroCrossing::getDescription() const +{ + return "Detect and count zero crossing points"; +} + +string +ZeroCrossing::getMaker() const +{ + return "Vamp SDK Example Plugins"; +} + +int +ZeroCrossing::getPluginVersion() const +{ + return 2; +} + +string +ZeroCrossing::getCopyright() const +{ + return "Freely redistributable (BSD license)"; +} + +bool +ZeroCrossing::initialise(size_t channels, size_t stepSize, size_t blockSize) +{ + if (channels < getMinChannelCount() || + channels > getMaxChannelCount()) return false; + + m_stepSize = std::min(stepSize, blockSize); + + return true; +} + +void +ZeroCrossing::reset() +{ + m_previousSample = 0.0f; +} + +ZeroCrossing::OutputList +ZeroCrossing::getOutputDescriptors() const +{ + OutputList list; + + OutputDescriptor zc; + zc.identifier = "counts"; + zc.name = "Zero Crossing Counts"; + zc.description = "The number of zero crossing points per processing block"; + zc.unit = "crossings"; + zc.hasFixedBinCount = true; + zc.binCount = 1; + zc.hasKnownExtents = false; + zc.isQuantized = true; + zc.quantizeStep = 1.0; + zc.sampleType = OutputDescriptor::OneSamplePerStep; + list.push_back(zc); + + zc.identifier = "zerocrossings"; + zc.name = "Zero Crossings"; + zc.description = "The locations of zero crossing points"; + zc.unit = ""; + zc.hasFixedBinCount = true; + zc.binCount = 0; + zc.sampleType = OutputDescriptor::VariableSampleRate; + zc.sampleRate = m_inputSampleRate; + list.push_back(zc); + + return list; +} + +ZeroCrossing::FeatureSet +ZeroCrossing::process(const float *const *inputBuffers, + Vamp::RealTime timestamp) +{ + if (m_stepSize == 0) { + cerr << "ERROR: ZeroCrossing::process: " + << "ZeroCrossing has not been initialised" + << endl; + return FeatureSet(); + } + + float prev = m_previousSample; + size_t count = 0; + + FeatureSet returnFeatures; + + for (size_t i = 0; i < m_stepSize; ++i) { + + float sample = inputBuffers[0][i]; + bool crossing = false; + + if (sample <= 0.0) { + if (prev > 0.0) crossing = true; + } else if (sample > 0.0) { + if (prev <= 0.0) crossing = true; + } + + if (crossing) { + ++count; + Feature feature; + feature.hasTimestamp = true; + feature.timestamp = timestamp + + Vamp::RealTime::frame2RealTime(i, (size_t)m_inputSampleRate); + returnFeatures[1].push_back(feature); + } + + prev = sample; + } + + m_previousSample = prev; + + Feature feature; + feature.hasTimestamp = false; + feature.values.push_back(count); + + returnFeatures[0].push_back(feature); + return returnFeatures; +} + +ZeroCrossing::FeatureSet +ZeroCrossing::getRemainingFeatures() +{ + return FeatureSet(); +} + diff --git a/libs/vamp-sdk/plugins/ZeroCrossing.h b/libs/vamp-sdk/plugins/ZeroCrossing.h new file mode 100644 index 0000000000..ede2a74492 --- /dev/null +++ b/libs/vamp-sdk/plugins/ZeroCrossing.h @@ -0,0 +1,78 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#ifndef _ZERO_CROSSING_PLUGIN_H_ +#define _ZERO_CROSSING_PLUGIN_H_ + +#include "vamp-sdk/Plugin.h" + +/** + * Example plugin that calculates the positions and density of + * zero-crossing points in an audio waveform. +*/ + +class ZeroCrossing : public Vamp::Plugin +{ +public: + ZeroCrossing(float inputSampleRate); + virtual ~ZeroCrossing(); + + bool initialise(size_t channels, size_t stepSize, size_t blockSize); + void reset(); + + InputDomain getInputDomain() const { return TimeDomain; } + + std::string getIdentifier() const; + std::string getName() const; + std::string getDescription() const; + std::string getMaker() const; + int getPluginVersion() const; + std::string getCopyright() const; + + OutputList getOutputDescriptors() const; + + FeatureSet process(const float *const *inputBuffers, + Vamp::RealTime timestamp); + + FeatureSet getRemainingFeatures(); + +protected: + size_t m_stepSize; + float m_previousSample; +}; + + +#endif diff --git a/libs/vamp-sdk/plugins/plugins.cpp b/libs/vamp-sdk/plugins/plugins.cpp new file mode 100644 index 0000000000..25c6e6c0d4 --- /dev/null +++ b/libs/vamp-sdk/plugins/plugins.cpp @@ -0,0 +1,63 @@ +/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */ + +/* + Vamp + + An API for audio analysis and feature extraction plugins. + + Centre for Digital Music, Queen Mary, University of London. + Copyright 2006 Chris Cannam. + + 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, + modify, merge, publish, distribute, sublicense, and/or sell copies + of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR + ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF + CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + Except as contained in this notice, the names of the Centre for + Digital Music; Queen Mary, University of London; and Chris Cannam + shall not be used in advertising or otherwise to promote the sale, + use or other dealings in this Software without prior written + authorization. +*/ + +#include "vamp/vamp.h" +#include "vamp-sdk/PluginAdapter.h" + +#include "ZeroCrossing.h" +#include "SpectralCentroid.h" +#include "PercussionOnsetDetector.h" +#include "AmplitudeFollower.h" + +static Vamp::PluginAdapter zeroCrossingAdapter; +static Vamp::PluginAdapter spectralCentroidAdapter; +static Vamp::PluginAdapter percussionOnsetAdapter; +static Vamp::PluginAdapter amplitudeAdapter; + +const VampPluginDescriptor *vampGetPluginDescriptor(unsigned int version, + unsigned int index) +{ + if (version < 1) return 0; + + switch (index) { + case 0: return zeroCrossingAdapter.getDescriptor(); + case 1: return spectralCentroidAdapter.getDescriptor(); + case 2: return percussionOnsetAdapter.getDescriptor(); + case 3: return amplitudeAdapter.getDescriptor(); + default: return 0; + } +} + -- 2.30.2