import glob
vampsdk_files = Split ("""
-vamp-sdk/PluginAdapter.cpp
-vamp-sdk/RealTime.cpp
+src/vamp-sdk/PluginAdapter.cpp
+src/vamp-sdk/RealTime.cpp
""")
vamphostsdk_files = Split ("""
-vamp-sdk/PluginHostAdapter.cpp
-vamp-sdk/hostext/PluginBufferingAdapter.cpp
-vamp-sdk/hostext/PluginChannelAdapter.cpp
-vamp-sdk/hostext/PluginInputDomainAdapter.cpp
-vamp-sdk/hostext/PluginLoader.cpp
-vamp-sdk/hostext/PluginWrapper.cpp
-vamp-sdk/RealTime.cpp
+src/vamp-hostsdk/PluginHostAdapter.cpp
+src/vamp-hostsdk/PluginBufferingAdapter.cpp
+src/vamp-hostsdk/PluginChannelAdapter.cpp
+src/vamp-hostsdk/PluginInputDomainAdapter.cpp
+src/vamp-hostsdk/PluginLoader.cpp
+src/vamp-hostsdk/PluginWrapper.cpp
""")
Import('env install_prefix libraries')
vamphostsdk_files +
glob.glob('vamp/*.h') +
glob.glob('vamp-sdk/*.h') +
- glob.glob('vamp-sdk/hostext/*.h')))
+ glob.glob('vamp-hostsdk/*.h')))
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+ This file by Mark Levy and Chris Cannam, Copyright 2007-2008 QMUL.
+
+ 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 <vector>
+#include <map>
+
+#include <vamp-hostsdk/PluginBufferingAdapter.h>
+
+using std::vector;
+using std::map;
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginBufferingAdapter.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginBufferingAdapter::Impl
+{
+public:
+ Impl(Plugin *plugin, float inputSampleRate);
+ ~Impl();
+
+ void setPluginStepSize(size_t stepSize);
+ void setPluginBlockSize(size_t blockSize);
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ void getActualStepAndBlockSizes(size_t &stepSize, size_t &blockSize);
+
+ OutputList getOutputDescriptors() const;
+
+ void setParameter(std::string, float);
+ void selectProgram(std::string);
+
+ void reset();
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ FeatureSet getRemainingFeatures();
+
+protected:
+ class RingBuffer
+ {
+ public:
+ RingBuffer(int n) :
+ m_buffer(new float[n+1]), m_writer(0), m_reader(0), m_size(n+1) { }
+ virtual ~RingBuffer() { delete[] m_buffer; }
+
+ int getSize() const { return m_size-1; }
+ void reset() { m_writer = 0; m_reader = 0; }
+
+ int getReadSpace() const {
+ int writer = m_writer, reader = m_reader, space;
+ if (writer > reader) space = writer - reader;
+ else if (writer < reader) space = (writer + m_size) - reader;
+ else space = 0;
+ return space;
+ }
+
+ int getWriteSpace() const {
+ int writer = m_writer;
+ int reader = m_reader;
+ int space = (reader + m_size - writer - 1);
+ if (space >= m_size) space -= m_size;
+ return space;
+ }
+
+ int peek(float *destination, int n) const {
+
+ int available = getReadSpace();
+
+ if (n > available) {
+ for (int i = available; i < n; ++i) {
+ destination[i] = 0.f;
+ }
+ n = available;
+ }
+ if (n == 0) return n;
+
+ int reader = m_reader;
+ int here = m_size - reader;
+ const float *const bufbase = m_buffer + reader;
+
+ if (here >= n) {
+ for (int i = 0; i < n; ++i) {
+ destination[i] = bufbase[i];
+ }
+ } else {
+ for (int i = 0; i < here; ++i) {
+ destination[i] = bufbase[i];
+ }
+ float *const destbase = destination + here;
+ const int nh = n - here;
+ for (int i = 0; i < nh; ++i) {
+ destbase[i] = m_buffer[i];
+ }
+ }
+
+ return n;
+ }
+
+ int skip(int n) {
+
+ int available = getReadSpace();
+ if (n > available) {
+ n = available;
+ }
+ if (n == 0) return n;
+
+ int reader = m_reader;
+ reader += n;
+ while (reader >= m_size) reader -= m_size;
+ m_reader = reader;
+ return n;
+ }
+
+ int write(const float *source, int n) {
+
+ int available = getWriteSpace();
+ if (n > available) {
+ n = available;
+ }
+ if (n == 0) return n;
+
+ int writer = m_writer;
+ int here = m_size - writer;
+ float *const bufbase = m_buffer + writer;
+
+ if (here >= n) {
+ for (int i = 0; i < n; ++i) {
+ bufbase[i] = source[i];
+ }
+ } else {
+ for (int i = 0; i < here; ++i) {
+ bufbase[i] = source[i];
+ }
+ const int nh = n - here;
+ const float *const srcbase = source + here;
+ float *const buf = m_buffer;
+ for (int i = 0; i < nh; ++i) {
+ buf[i] = srcbase[i];
+ }
+ }
+
+ writer += n;
+ while (writer >= m_size) writer -= m_size;
+ m_writer = writer;
+
+ return n;
+ }
+
+ int zero(int n) {
+
+ int available = getWriteSpace();
+ if (n > available) {
+ n = available;
+ }
+ if (n == 0) return n;
+
+ int writer = m_writer;
+ int here = m_size - writer;
+ float *const bufbase = m_buffer + writer;
+
+ if (here >= n) {
+ for (int i = 0; i < n; ++i) {
+ bufbase[i] = 0.f;
+ }
+ } else {
+ for (int i = 0; i < here; ++i) {
+ bufbase[i] = 0.f;
+ }
+ const int nh = n - here;
+ for (int i = 0; i < nh; ++i) {
+ m_buffer[i] = 0.f;
+ }
+ }
+
+ writer += n;
+ while (writer >= m_size) writer -= m_size;
+ m_writer = writer;
+
+ return n;
+ }
+
+ protected:
+ float *m_buffer;
+ int m_writer;
+ int m_reader;
+ int m_size;
+
+ private:
+ RingBuffer(const RingBuffer &); // not provided
+ RingBuffer &operator=(const RingBuffer &); // not provided
+ };
+
+ Plugin *m_plugin;
+ size_t m_inputStepSize; // value passed to wrapper initialise()
+ size_t m_inputBlockSize; // value passed to wrapper initialise()
+ size_t m_setStepSize; // value passed to setPluginStepSize()
+ size_t m_setBlockSize; // value passed to setPluginBlockSize()
+ size_t m_stepSize; // value actually used to initialise plugin
+ size_t m_blockSize; // value actually used to initialise plugin
+ size_t m_channels;
+ vector<RingBuffer *> m_queue;
+ float **m_buffers;
+ float m_inputSampleRate;
+ long m_frame;
+ bool m_unrun;
+ mutable OutputList m_outputs;
+ mutable std::map<int, bool> m_rewriteOutputTimes;
+
+ void processBlock(FeatureSet& allFeatureSets);
+};
+
+PluginBufferingAdapter::PluginBufferingAdapter(Plugin *plugin) :
+ PluginWrapper(plugin)
+{
+ m_impl = new Impl(plugin, m_inputSampleRate);
+}
+
+PluginBufferingAdapter::~PluginBufferingAdapter()
+{
+ delete m_impl;
+}
+
+size_t
+PluginBufferingAdapter::getPreferredStepSize() const
+{
+ return getPreferredBlockSize();
+}
+
+size_t
+PluginBufferingAdapter::getPreferredBlockSize() const
+{
+ return PluginWrapper::getPreferredBlockSize();
+}
+
+size_t
+PluginBufferingAdapter::getPluginPreferredStepSize() const
+{
+ return PluginWrapper::getPreferredStepSize();
+}
+
+size_t
+PluginBufferingAdapter::getPluginPreferredBlockSize() const
+{
+ return PluginWrapper::getPreferredBlockSize();
+}
+
+void
+PluginBufferingAdapter::setPluginStepSize(size_t stepSize)
+{
+ m_impl->setPluginStepSize(stepSize);
+}
+
+void
+PluginBufferingAdapter::setPluginBlockSize(size_t blockSize)
+{
+ m_impl->setPluginBlockSize(blockSize);
+}
+
+void
+PluginBufferingAdapter::getActualStepAndBlockSizes(size_t &stepSize,
+ size_t &blockSize)
+{
+ m_impl->getActualStepAndBlockSizes(stepSize, blockSize);
+}
+
+bool
+PluginBufferingAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ return m_impl->initialise(channels, stepSize, blockSize);
+}
+
+PluginBufferingAdapter::OutputList
+PluginBufferingAdapter::getOutputDescriptors() const
+{
+ return m_impl->getOutputDescriptors();
+}
+
+void
+PluginBufferingAdapter::setParameter(std::string name, float value)
+{
+ m_impl->setParameter(name, value);
+}
+
+void
+PluginBufferingAdapter::selectProgram(std::string name)
+{
+ m_impl->selectProgram(name);
+}
+
+void
+PluginBufferingAdapter::reset()
+{
+ m_impl->reset();
+}
+
+PluginBufferingAdapter::FeatureSet
+PluginBufferingAdapter::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ return m_impl->process(inputBuffers, timestamp);
+}
+
+PluginBufferingAdapter::FeatureSet
+PluginBufferingAdapter::getRemainingFeatures()
+{
+ return m_impl->getRemainingFeatures();
+}
+
+PluginBufferingAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
+ m_plugin(plugin),
+ m_inputStepSize(0),
+ m_inputBlockSize(0),
+ m_setStepSize(0),
+ m_setBlockSize(0),
+ m_stepSize(0),
+ m_blockSize(0),
+ m_channels(0),
+ m_queue(0),
+ m_buffers(0),
+ m_inputSampleRate(inputSampleRate),
+ m_frame(0),
+ m_unrun(true)
+{
+ (void)getOutputDescriptors(); // set up m_outputs and m_rewriteOutputTimes
+}
+
+PluginBufferingAdapter::Impl::~Impl()
+{
+ // the adapter will delete the plugin
+
+ for (size_t i = 0; i < m_channels; ++i) {
+ delete m_queue[i];
+ delete[] m_buffers[i];
+ }
+ delete[] m_buffers;
+}
+
+void
+PluginBufferingAdapter::Impl::setPluginStepSize(size_t stepSize)
+{
+ if (m_inputStepSize != 0) {
+ std::cerr << "PluginBufferingAdapter::setPluginStepSize: ERROR: Cannot be called after initialise()" << std::endl;
+ return;
+ }
+ m_setStepSize = stepSize;
+}
+
+void
+PluginBufferingAdapter::Impl::setPluginBlockSize(size_t blockSize)
+{
+ if (m_inputBlockSize != 0) {
+ std::cerr << "PluginBufferingAdapter::setPluginBlockSize: ERROR: Cannot be called after initialise()" << std::endl;
+ return;
+ }
+ m_setBlockSize = blockSize;
+}
+
+void
+PluginBufferingAdapter::Impl::getActualStepAndBlockSizes(size_t &stepSize,
+ size_t &blockSize)
+{
+ stepSize = m_stepSize;
+ blockSize = m_blockSize;
+}
+
+bool
+PluginBufferingAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ if (stepSize != blockSize) {
+ std::cerr << "PluginBufferingAdapter::initialise: input stepSize must be equal to blockSize for this adapter (stepSize = " << stepSize << ", blockSize = " << blockSize << ")" << std::endl;
+ return false;
+ }
+
+ m_channels = channels;
+ m_inputStepSize = stepSize;
+ m_inputBlockSize = blockSize;
+
+ // if the user has requested particular step or block sizes, use
+ // those; otherwise use the step and block sizes which the plugin
+ // prefers
+
+ m_stepSize = 0;
+ m_blockSize = 0;
+
+ if (m_setStepSize > 0) {
+ m_stepSize = m_setStepSize;
+ }
+ if (m_setBlockSize > 0) {
+ m_blockSize = m_setBlockSize;
+ }
+
+ if (m_stepSize == 0 && m_blockSize == 0) {
+ m_stepSize = m_plugin->getPreferredStepSize();
+ m_blockSize = m_plugin->getPreferredBlockSize();
+ }
+
+ bool freq = (m_plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain);
+
+ // or sensible defaults if it has no preference
+ if (m_blockSize == 0) {
+ if (m_stepSize == 0) {
+ m_blockSize = 1024;
+ if (freq) {
+ m_stepSize = m_blockSize / 2;
+ } else {
+ m_stepSize = m_blockSize;
+ }
+ } else if (freq) {
+ m_blockSize = m_stepSize * 2;
+ } else {
+ m_blockSize = m_stepSize;
+ }
+ } else if (m_stepSize == 0) { // m_blockSize != 0 (that was handled above)
+ if (freq) {
+ m_stepSize = m_blockSize/2;
+ } else {
+ m_stepSize = m_blockSize;
+ }
+ }
+
+ // current implementation breaks if step is greater than block
+ if (m_stepSize > m_blockSize) {
+ size_t newBlockSize;
+ if (freq) {
+ newBlockSize = m_stepSize * 2;
+ } else {
+ newBlockSize = m_stepSize;
+ }
+ std::cerr << "PluginBufferingAdapter::initialise: WARNING: step size " << m_stepSize << " is greater than block size " << m_blockSize << ": cannot handle this in adapter; adjusting block size to " << newBlockSize << std::endl;
+ m_blockSize = newBlockSize;
+ }
+
+// std::cerr << "PluginBufferingAdapter::initialise: NOTE: stepSize " << m_inputStepSize << " -> " << m_stepSize
+// << ", blockSize " << m_inputBlockSize << " -> " << m_blockSize << std::endl;
+
+ m_buffers = new float *[m_channels];
+
+ for (size_t i = 0; i < m_channels; ++i) {
+ m_queue.push_back(new RingBuffer(m_blockSize + m_inputBlockSize));
+ m_buffers[i] = new float[m_blockSize];
+ }
+
+ bool success = m_plugin->initialise(m_channels, m_stepSize, m_blockSize);
+
+// std::cerr << "PluginBufferingAdapter::initialise: success = " << success << std::endl;
+
+ if (success) {
+ // Re-query outputs; properties such as bin count may have
+ // changed on initialise
+ m_outputs.clear();
+ (void)getOutputDescriptors();
+ }
+
+ return success;
+}
+
+PluginBufferingAdapter::OutputList
+PluginBufferingAdapter::Impl::getOutputDescriptors() const
+{
+ if (m_outputs.empty()) {
+// std::cerr << "PluginBufferingAdapter::getOutputDescriptors: querying anew" << std::endl;
+
+ m_outputs = m_plugin->getOutputDescriptors();
+ }
+
+ PluginBufferingAdapter::OutputList outs = m_outputs;
+
+ for (size_t i = 0; i < outs.size(); ++i) {
+
+ switch (outs[i].sampleType) {
+
+ case OutputDescriptor::OneSamplePerStep:
+ outs[i].sampleType = OutputDescriptor::FixedSampleRate;
+ outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
+ m_rewriteOutputTimes[i] = true;
+ break;
+
+ case OutputDescriptor::FixedSampleRate:
+ if (outs[i].sampleRate == 0.f) {
+ outs[i].sampleRate = (1.f / m_inputSampleRate) * m_stepSize;
+ }
+ // We actually only need to rewrite output times for
+ // features that don't have timestamps already, but we
+ // can't tell from here whether our features will have
+ // timestamps or not
+ m_rewriteOutputTimes[i] = true;
+ break;
+
+ case OutputDescriptor::VariableSampleRate:
+ m_rewriteOutputTimes[i] = false;
+ break;
+ }
+ }
+
+ return outs;
+}
+
+void
+PluginBufferingAdapter::Impl::setParameter(std::string name, float value)
+{
+ m_plugin->setParameter(name, value);
+
+ // Re-query outputs; properties such as bin count may have changed
+ m_outputs.clear();
+ (void)getOutputDescriptors();
+}
+
+void
+PluginBufferingAdapter::Impl::selectProgram(std::string name)
+{
+ m_plugin->selectProgram(name);
+
+ // Re-query outputs; properties such as bin count may have changed
+ m_outputs.clear();
+ (void)getOutputDescriptors();
+}
+
+void
+PluginBufferingAdapter::Impl::reset()
+{
+ m_frame = 0;
+ m_unrun = true;
+
+ for (size_t i = 0; i < m_queue.size(); ++i) {
+ m_queue[i]->reset();
+ }
+
+ m_plugin->reset();
+}
+
+PluginBufferingAdapter::FeatureSet
+PluginBufferingAdapter::Impl::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ if (m_inputStepSize == 0) {
+ std::cerr << "PluginBufferingAdapter::process: ERROR: Plugin has not been initialised" << std::endl;
+ return FeatureSet();
+ }
+
+ FeatureSet allFeatureSets;
+
+ if (m_unrun) {
+ m_frame = RealTime::realTime2Frame(timestamp,
+ int(m_inputSampleRate + 0.5));
+ m_unrun = false;
+ }
+
+ // queue the new input
+
+ for (size_t i = 0; i < m_channels; ++i) {
+ int written = m_queue[i]->write(inputBuffers[i], m_inputBlockSize);
+ if (written < int(m_inputBlockSize) && i == 0) {
+ std::cerr << "WARNING: PluginBufferingAdapter::Impl::process: "
+ << "Buffer overflow: wrote " << written
+ << " of " << m_inputBlockSize
+ << " input samples (for plugin step size "
+ << m_stepSize << ", block size " << m_blockSize << ")"
+ << std::endl;
+ }
+ }
+
+ // process as much as we can
+
+ while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
+ processBlock(allFeatureSets);
+ }
+
+ return allFeatureSets;
+}
+
+PluginBufferingAdapter::FeatureSet
+PluginBufferingAdapter::Impl::getRemainingFeatures()
+{
+ FeatureSet allFeatureSets;
+
+ // process remaining samples in queue
+ while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
+ processBlock(allFeatureSets);
+ }
+
+ // pad any last samples remaining and process
+ if (m_queue[0]->getReadSpace() > 0) {
+ for (size_t i = 0; i < m_channels; ++i) {
+ m_queue[i]->zero(m_blockSize - m_queue[i]->getReadSpace());
+ }
+ processBlock(allFeatureSets);
+ }
+
+ // get remaining features
+
+ FeatureSet featureSet = m_plugin->getRemainingFeatures();
+
+ for (map<int, FeatureList>::iterator iter = featureSet.begin();
+ iter != featureSet.end(); ++iter) {
+ FeatureList featureList = iter->second;
+ for (size_t i = 0; i < featureList.size(); ++i) {
+ allFeatureSets[iter->first].push_back(featureList[i]);
+ }
+ }
+
+ return allFeatureSets;
+}
+
+void
+PluginBufferingAdapter::Impl::processBlock(FeatureSet& allFeatureSets)
+{
+ for (size_t i = 0; i < m_channels; ++i) {
+ m_queue[i]->peek(m_buffers[i], m_blockSize);
+ }
+
+ long frame = m_frame;
+ RealTime timestamp = RealTime::frame2RealTime
+ (frame, int(m_inputSampleRate + 0.5));
+
+ FeatureSet featureSet = m_plugin->process(m_buffers, timestamp);
+
+ for (FeatureSet::iterator iter = featureSet.begin();
+ iter != featureSet.end(); ++iter) {
+
+ int outputNo = iter->first;
+
+ if (m_rewriteOutputTimes[outputNo]) {
+
+ FeatureList featureList = iter->second;
+
+ for (size_t i = 0; i < featureList.size(); ++i) {
+
+ switch (m_outputs[outputNo].sampleType) {
+
+ case OutputDescriptor::OneSamplePerStep:
+ // use our internal timestamp, always
+ featureList[i].timestamp = timestamp;
+ featureList[i].hasTimestamp = true;
+ break;
+
+ case OutputDescriptor::FixedSampleRate:
+ // use our internal timestamp if feature lacks one
+ if (!featureList[i].hasTimestamp) {
+ featureList[i].timestamp = timestamp;
+ featureList[i].hasTimestamp = true;
+ }
+ break;
+
+ case OutputDescriptor::VariableSampleRate:
+ break; // plugin must set timestamp
+
+ default:
+ break;
+ }
+
+ allFeatureSets[outputNo].push_back(featureList[i]);
+ }
+ } else {
+ for (size_t i = 0; i < iter->second.size(); ++i) {
+ allFeatureSets[outputNo].push_back(iter->second[i]);
+ }
+ }
+ }
+
+ // step forward
+
+ for (size_t i = 0; i < m_channels; ++i) {
+ m_queue[i]->skip(m_stepSize);
+ }
+
+ // increment internal frame counter each time we step forward
+ m_frame += m_stepSize;
+}
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginBufferingAdapter.cpp)
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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-hostsdk/PluginChannelAdapter.h>
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginChannelAdapter.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginChannelAdapter::Impl
+{
+public:
+ Impl(Plugin *plugin);
+ ~Impl();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+ FeatureSet processInterleaved(const float *inputBuffers, RealTime timestamp);
+
+protected:
+ Plugin *m_plugin;
+ size_t m_blockSize;
+ size_t m_inputChannels;
+ size_t m_pluginChannels;
+ float **m_buffer;
+ float **m_deinterleave;
+ const float **m_forwardPtrs;
+};
+
+PluginChannelAdapter::PluginChannelAdapter(Plugin *plugin) :
+ PluginWrapper(plugin)
+{
+ m_impl = new Impl(plugin);
+}
+
+PluginChannelAdapter::~PluginChannelAdapter()
+{
+ delete m_impl;
+}
+
+bool
+PluginChannelAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ return m_impl->initialise(channels, stepSize, blockSize);
+}
+
+PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ return m_impl->process(inputBuffers, timestamp);
+}
+
+PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::processInterleaved(const float *inputBuffers,
+ RealTime timestamp)
+{
+ return m_impl->processInterleaved(inputBuffers, timestamp);
+}
+
+PluginChannelAdapter::Impl::Impl(Plugin *plugin) :
+ m_plugin(plugin),
+ m_blockSize(0),
+ m_inputChannels(0),
+ m_pluginChannels(0),
+ m_buffer(0),
+ m_deinterleave(0),
+ m_forwardPtrs(0)
+{
+}
+
+PluginChannelAdapter::Impl::~Impl()
+{
+ // the adapter will delete the plugin
+
+ if (m_buffer) {
+ if (m_inputChannels > m_pluginChannels) {
+ delete[] m_buffer[0];
+ } else {
+ for (size_t i = 0; i < m_pluginChannels - m_inputChannels; ++i) {
+ delete[] m_buffer[i];
+ }
+ }
+ delete[] m_buffer;
+ m_buffer = 0;
+ }
+
+ if (m_deinterleave) {
+ for (size_t i = 0; i < m_inputChannels; ++i) {
+ delete[] m_deinterleave[i];
+ }
+ delete[] m_deinterleave;
+ m_deinterleave = 0;
+ }
+
+ if (m_forwardPtrs) {
+ delete[] m_forwardPtrs;
+ m_forwardPtrs = 0;
+ }
+}
+
+bool
+PluginChannelAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ m_blockSize = blockSize;
+
+ size_t minch = m_plugin->getMinChannelCount();
+ size_t maxch = m_plugin->getMaxChannelCount();
+
+ m_inputChannels = channels;
+
+ if (m_inputChannels < minch) {
+
+ m_forwardPtrs = new const float *[minch];
+
+ if (m_inputChannels > 1) {
+ // We need a set of zero-valued buffers to add to the
+ // forwarded pointers
+ m_buffer = new float*[minch - channels];
+ for (size_t i = 0; i < minch; ++i) {
+ m_buffer[i] = new float[blockSize];
+ for (size_t j = 0; j < blockSize; ++j) {
+ m_buffer[i][j] = 0.f;
+ }
+ }
+ }
+
+ m_pluginChannels = minch;
+
+// std::cerr << "PluginChannelAdapter::initialise: expanding " << m_inputChannels << " to " << m_pluginChannels << " for plugin" << std::endl;
+
+ } else if (m_inputChannels > maxch) {
+
+ // We only need m_buffer if we are mixing down to a single
+ // channel -- otherwise we can just forward the same float* as
+ // passed in to process(), expecting the excess to be ignored
+
+ if (maxch == 1) {
+ m_buffer = new float *[1];
+ m_buffer[0] = new float[blockSize];
+
+// std::cerr << "PluginChannelAdapter::initialise: mixing " << m_inputChannels << " to mono for plugin" << std::endl;
+
+ } else {
+
+// std::cerr << "PluginChannelAdapter::initialise: reducing " << m_inputChannels << " to " << m_pluginChannels << " for plugin" << std::endl;
+ }
+
+ m_pluginChannels = maxch;
+
+ } else {
+
+// std::cerr << "PluginChannelAdapter::initialise: accepting given number of channels (" << m_inputChannels << ")" << std::endl;
+ m_pluginChannels = m_inputChannels;
+ }
+
+ return m_plugin->initialise(m_pluginChannels, stepSize, blockSize);
+}
+
+PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::Impl::processInterleaved(const float *inputBuffers,
+ RealTime timestamp)
+{
+ if (!m_deinterleave) {
+ m_deinterleave = new float *[m_inputChannels];
+ for (size_t i = 0; i < m_inputChannels; ++i) {
+ m_deinterleave[i] = new float[m_blockSize];
+ }
+ }
+
+ for (size_t i = 0; i < m_inputChannels; ++i) {
+ for (size_t j = 0; j < m_blockSize; ++j) {
+ m_deinterleave[i][j] = inputBuffers[j * m_inputChannels + i];
+ }
+ }
+
+ return process(m_deinterleave, timestamp);
+}
+
+PluginChannelAdapter::FeatureSet
+PluginChannelAdapter::Impl::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+// std::cerr << "PluginChannelAdapter::process: " << m_inputChannels << " -> " << m_pluginChannels << " channels" << std::endl;
+
+ if (m_inputChannels < m_pluginChannels) {
+
+ if (m_inputChannels == 1) {
+ for (size_t i = 0; i < m_pluginChannels; ++i) {
+ m_forwardPtrs[i] = inputBuffers[0];
+ }
+ } else {
+ for (size_t i = 0; i < m_inputChannels; ++i) {
+ m_forwardPtrs[i] = inputBuffers[i];
+ }
+ for (size_t i = m_inputChannels; i < m_pluginChannels; ++i) {
+ m_forwardPtrs[i] = m_buffer[i - m_inputChannels];
+ }
+ }
+
+ return m_plugin->process(m_forwardPtrs, timestamp);
+
+ } else if (m_inputChannels > m_pluginChannels) {
+
+ if (m_pluginChannels == 1) {
+ for (size_t j = 0; j < m_blockSize; ++j) {
+ m_buffer[0][j] = inputBuffers[0][j];
+ }
+ for (size_t i = 1; i < m_inputChannels; ++i) {
+ for (size_t j = 0; j < m_blockSize; ++j) {
+ m_buffer[0][j] += inputBuffers[i][j];
+ }
+ }
+ for (size_t j = 0; j < m_blockSize; ++j) {
+ m_buffer[0][j] /= m_inputChannels;
+ }
+ return m_plugin->process(m_buffer, timestamp);
+ } else {
+ return m_plugin->process(inputBuffers, timestamp);
+ }
+
+ } else {
+
+ return m_plugin->process(inputBuffers, timestamp);
+ }
+}
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginChannelAdapter.cpp)
+
+
--- /dev/null
+/* -*- 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-hostsdk/PluginHostAdapter.h>
+#include <cstdlib>
+
+#if ( VAMP_SDK_MAJOR_VERSION != 2 || VAMP_SDK_MINOR_VERSION != 0 )
+#error Incorrect Vamp SDK header included (not the expected 2.0 SDK)
+#endif
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginHostAdapter.cpp)
+
+namespace Vamp
+{
+
+PluginHostAdapter::PluginHostAdapter(const VampPluginDescriptor *descriptor,
+ float inputSampleRate) :
+ Plugin(inputSampleRate),
+ m_descriptor(descriptor)
+{
+// std::cerr << "PluginHostAdapter::PluginHostAdapter (plugin = " << descriptor->name << ")" << std::endl;
+ m_handle = m_descriptor->instantiate(m_descriptor, inputSampleRate);
+ if (!m_handle) {
+// std::cerr << "WARNING: PluginHostAdapter: Plugin instantiation failed for plugin " << m_descriptor->name << std::endl;
+ }
+}
+
+PluginHostAdapter::~PluginHostAdapter()
+{
+// std::cerr << "PluginHostAdapter::~PluginHostAdapter (plugin = " << m_descriptor->name << ")" << std::endl;
+ if (m_handle) m_descriptor->cleanup(m_handle);
+}
+
+std::vector<std::string>
+PluginHostAdapter::getPluginPath()
+{
+ std::vector<std::string> path;
+ std::string envPath;
+
+ char *cpath = getenv("VAMP_PATH");
+ if (cpath) envPath = cpath;
+
+#ifdef _WIN32
+#define PATH_SEPARATOR ';'
+#define DEFAULT_VAMP_PATH "%ProgramFiles%\\Vamp Plugins"
+#else
+#define PATH_SEPARATOR ':'
+#ifdef __APPLE__
+#define DEFAULT_VAMP_PATH "$HOME/Library/Audio/Plug-Ins/Vamp:/Library/Audio/Plug-Ins/Vamp"
+#else
+#define DEFAULT_VAMP_PATH "$HOME/vamp:$HOME/.vamp:/usr/local/lib/vamp:/usr/lib/vamp"
+#endif
+#endif
+
+ if (envPath == "") {
+ envPath = DEFAULT_VAMP_PATH;
+ char *chome = getenv("HOME");
+ if (chome) {
+ std::string home(chome);
+ std::string::size_type f;
+ while ((f = envPath.find("$HOME")) != std::string::npos &&
+ f < envPath.length()) {
+ envPath.replace(f, 5, home);
+ }
+ }
+#ifdef _WIN32
+ char *cpfiles = getenv("ProgramFiles");
+ if (!cpfiles) cpfiles = (char *)"C:\\Program Files";
+ std::string pfiles(cpfiles);
+ std::string::size_type f;
+ while ((f = envPath.find("%ProgramFiles%")) != std::string::npos &&
+ f < envPath.length()) {
+ envPath.replace(f, 14, pfiles);
+ }
+#endif
+ }
+
+ std::string::size_type index = 0, newindex = 0;
+
+ while ((newindex = envPath.find(PATH_SEPARATOR, index)) < envPath.size()) {
+ path.push_back(envPath.substr(index, newindex - index));
+ index = newindex + 1;
+ }
+
+ path.push_back(envPath.substr(index));
+
+ return path;
+}
+
+bool
+PluginHostAdapter::initialise(size_t channels,
+ size_t stepSize,
+ size_t blockSize)
+{
+ if (!m_handle) return false;
+ return m_descriptor->initialise(m_handle, channels, stepSize, blockSize) ?
+ true : false;
+}
+
+void
+PluginHostAdapter::reset()
+{
+ if (!m_handle) {
+// std::cerr << "PluginHostAdapter::reset: no handle" << std::endl;
+ return;
+ }
+// std::cerr << "PluginHostAdapter::reset(" << m_handle << ")" << std::endl;
+ m_descriptor->reset(m_handle);
+}
+
+PluginHostAdapter::InputDomain
+PluginHostAdapter::getInputDomain() const
+{
+ if (m_descriptor->inputDomain == vampFrequencyDomain) {
+ return FrequencyDomain;
+ } else {
+ return TimeDomain;
+ }
+}
+
+unsigned int
+PluginHostAdapter::getVampApiVersion() const
+{
+ return m_descriptor->vampApiVersion;
+}
+
+std::string
+PluginHostAdapter::getIdentifier() const
+{
+ return m_descriptor->identifier;
+}
+
+std::string
+PluginHostAdapter::getName() const
+{
+ return m_descriptor->name;
+}
+
+std::string
+PluginHostAdapter::getDescription() const
+{
+ return m_descriptor->description;
+}
+
+std::string
+PluginHostAdapter::getMaker() const
+{
+ return m_descriptor->maker;
+}
+
+int
+PluginHostAdapter::getPluginVersion() const
+{
+ return m_descriptor->pluginVersion;
+}
+
+std::string
+PluginHostAdapter::getCopyright() const
+{
+ return m_descriptor->copyright;
+}
+
+PluginHostAdapter::ParameterList
+PluginHostAdapter::getParameterDescriptors() const
+{
+ ParameterList list;
+ for (unsigned int i = 0; i < m_descriptor->parameterCount; ++i) {
+ const VampParameterDescriptor *spd = m_descriptor->parameters[i];
+ ParameterDescriptor pd;
+ pd.identifier = spd->identifier;
+ pd.name = spd->name;
+ pd.description = spd->description;
+ pd.unit = spd->unit;
+ pd.minValue = spd->minValue;
+ pd.maxValue = spd->maxValue;
+ pd.defaultValue = spd->defaultValue;
+ pd.isQuantized = spd->isQuantized;
+ pd.quantizeStep = spd->quantizeStep;
+ if (pd.isQuantized && spd->valueNames) {
+ for (unsigned int j = 0; spd->valueNames[j]; ++j) {
+ pd.valueNames.push_back(spd->valueNames[j]);
+ }
+ }
+ list.push_back(pd);
+ }
+ return list;
+}
+
+float
+PluginHostAdapter::getParameter(std::string param) const
+{
+ if (!m_handle) return 0.0;
+
+ for (unsigned int i = 0; i < m_descriptor->parameterCount; ++i) {
+ if (param == m_descriptor->parameters[i]->identifier) {
+ return m_descriptor->getParameter(m_handle, i);
+ }
+ }
+
+ return 0.0;
+}
+
+void
+PluginHostAdapter::setParameter(std::string param,
+ float value)
+{
+ if (!m_handle) return;
+
+ for (unsigned int i = 0; i < m_descriptor->parameterCount; ++i) {
+ if (param == m_descriptor->parameters[i]->identifier) {
+ m_descriptor->setParameter(m_handle, i, value);
+ return;
+ }
+ }
+}
+
+PluginHostAdapter::ProgramList
+PluginHostAdapter::getPrograms() const
+{
+ ProgramList list;
+
+ for (unsigned int i = 0; i < m_descriptor->programCount; ++i) {
+ list.push_back(m_descriptor->programs[i]);
+ }
+
+ return list;
+}
+
+std::string
+PluginHostAdapter::getCurrentProgram() const
+{
+ if (!m_handle) return "";
+
+ int pn = m_descriptor->getCurrentProgram(m_handle);
+ return m_descriptor->programs[pn];
+}
+
+void
+PluginHostAdapter::selectProgram(std::string program)
+{
+ if (!m_handle) return;
+
+ for (unsigned int i = 0; i < m_descriptor->programCount; ++i) {
+ if (program == m_descriptor->programs[i]) {
+ m_descriptor->selectProgram(m_handle, i);
+ return;
+ }
+ }
+}
+
+size_t
+PluginHostAdapter::getPreferredStepSize() const
+{
+ if (!m_handle) return 0;
+ return m_descriptor->getPreferredStepSize(m_handle);
+}
+
+size_t
+PluginHostAdapter::getPreferredBlockSize() const
+{
+ if (!m_handle) return 0;
+ return m_descriptor->getPreferredBlockSize(m_handle);
+}
+
+size_t
+PluginHostAdapter::getMinChannelCount() const
+{
+ if (!m_handle) return 0;
+ return m_descriptor->getMinChannelCount(m_handle);
+}
+
+size_t
+PluginHostAdapter::getMaxChannelCount() const
+{
+ if (!m_handle) return 0;
+ return m_descriptor->getMaxChannelCount(m_handle);
+}
+
+PluginHostAdapter::OutputList
+PluginHostAdapter::getOutputDescriptors() const
+{
+ OutputList list;
+ if (!m_handle) {
+// std::cerr << "PluginHostAdapter::getOutputDescriptors: no handle " << std::endl;
+ return list;
+ }
+
+ unsigned int count = m_descriptor->getOutputCount(m_handle);
+
+ for (unsigned int i = 0; i < count; ++i) {
+ VampOutputDescriptor *sd = m_descriptor->getOutputDescriptor(m_handle, i);
+ OutputDescriptor d;
+ d.identifier = sd->identifier;
+ d.name = sd->name;
+ d.description = sd->description;
+ d.unit = sd->unit;
+ d.hasFixedBinCount = sd->hasFixedBinCount;
+ d.binCount = sd->binCount;
+ if (d.hasFixedBinCount && sd->binNames) {
+ for (unsigned int j = 0; j < sd->binCount; ++j) {
+ d.binNames.push_back(sd->binNames[j] ? sd->binNames[j] : "");
+ }
+ }
+ d.hasKnownExtents = sd->hasKnownExtents;
+ d.minValue = sd->minValue;
+ d.maxValue = sd->maxValue;
+ d.isQuantized = sd->isQuantized;
+ d.quantizeStep = sd->quantizeStep;
+
+ switch (sd->sampleType) {
+ case vampOneSamplePerStep:
+ d.sampleType = OutputDescriptor::OneSamplePerStep; break;
+ case vampFixedSampleRate:
+ d.sampleType = OutputDescriptor::FixedSampleRate; break;
+ case vampVariableSampleRate:
+ d.sampleType = OutputDescriptor::VariableSampleRate; break;
+ }
+
+ d.sampleRate = sd->sampleRate;
+
+ if (m_descriptor->vampApiVersion >= 2) {
+ d.hasDuration = sd->hasDuration;
+ } else {
+ d.hasDuration = false;
+ }
+
+ list.push_back(d);
+
+ m_descriptor->releaseOutputDescriptor(sd);
+ }
+
+ return list;
+}
+
+PluginHostAdapter::FeatureSet
+PluginHostAdapter::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ FeatureSet fs;
+ if (!m_handle) return fs;
+
+ int sec = timestamp.sec;
+ int nsec = timestamp.nsec;
+
+ VampFeatureList *features = m_descriptor->process(m_handle,
+ inputBuffers,
+ sec, nsec);
+
+ convertFeatures(features, fs);
+ m_descriptor->releaseFeatureSet(features);
+ return fs;
+}
+
+PluginHostAdapter::FeatureSet
+PluginHostAdapter::getRemainingFeatures()
+{
+ FeatureSet fs;
+ if (!m_handle) return fs;
+
+ VampFeatureList *features = m_descriptor->getRemainingFeatures(m_handle);
+
+ convertFeatures(features, fs);
+ m_descriptor->releaseFeatureSet(features);
+ return fs;
+}
+
+void
+PluginHostAdapter::convertFeatures(VampFeatureList *features,
+ FeatureSet &fs)
+{
+ if (!features) return;
+
+ unsigned int outputs = m_descriptor->getOutputCount(m_handle);
+
+ for (unsigned int i = 0; i < outputs; ++i) {
+
+ VampFeatureList &list = features[i];
+
+ if (list.featureCount > 0) {
+
+ Feature feature;
+ feature.values.reserve(list.features[0].v1.valueCount);
+
+ for (unsigned int j = 0; j < list.featureCount; ++j) {
+
+ feature.hasTimestamp = list.features[j].v1.hasTimestamp;
+ feature.timestamp = RealTime(list.features[j].v1.sec,
+ list.features[j].v1.nsec);
+ feature.hasDuration = false;
+
+ if (m_descriptor->vampApiVersion >= 2) {
+ unsigned int j2 = j + list.featureCount;
+ feature.hasDuration = list.features[j2].v2.hasDuration;
+ feature.duration = RealTime(list.features[j2].v2.durationSec,
+ list.features[j2].v2.durationNsec);
+ }
+
+ for (unsigned int k = 0; k < list.features[j].v1.valueCount; ++k) {
+ feature.values.push_back(list.features[j].v1.values[k]);
+ }
+
+ if (list.features[j].v1.label) {
+ feature.label = list.features[j].v1.label;
+ }
+
+ fs[i].push_back(feature);
+
+ if (list.features[j].v1.valueCount > 0) {
+ feature.values.clear();
+ }
+
+ if (list.features[j].v1.label) {
+ feature.label = "";
+ }
+ }
+ }
+ }
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginHostAdapter.cpp)
+
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ This file is based in part on Don Cross's public domain FFT
+ implementation.
+
+ 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-hostsdk/PluginInputDomainAdapter.h>
+
+#include <cmath>
+
+
+/**
+ * If you want to compile using FFTW instead of the built-in FFT
+ * implementation for the PluginInputDomainAdapter, define HAVE_FFTW3
+ * in the Makefile.
+ *
+ * Be aware that FFTW is licensed under the GPL -- unlike this SDK,
+ * which is provided under a more liberal BSD license in order to
+ * permit use in closed source applications. The use of FFTW would
+ * mean that your code would need to be licensed under the GPL as
+ * well. Do not define this symbol unless you understand and accept
+ * the implications of this.
+ *
+ * Parties such as Linux distribution packagers who redistribute this
+ * SDK for use in other programs should _not_ define this symbol, as
+ * it would change the effective licensing terms under which the SDK
+ * was available to third party developers.
+ *
+ * The default is not to use FFTW, and to use the built-in FFT instead.
+ *
+ * Note: The FFTW code uses FFTW_MEASURE, and so will perform badly on
+ * its first invocation unless the host has saved and restored FFTW
+ * wisdom (see the FFTW documentation).
+ */
+#ifdef HAVE_FFTW3
+#include <fftw3.h>
+#endif
+
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginInputDomainAdapter.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginInputDomainAdapter::Impl
+{
+public:
+ Impl(Plugin *plugin, float inputSampleRate);
+ ~Impl();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ size_t getPreferredStepSize() const;
+ size_t getPreferredBlockSize() const;
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ RealTime getTimestampAdjustment() const;
+
+protected:
+ Plugin *m_plugin;
+ float m_inputSampleRate;
+ int m_channels;
+ int m_blockSize;
+ float **m_freqbuf;
+
+ double *m_ri;
+ double *m_window;
+
+#ifdef HAVE_FFTW3
+ fftw_plan m_plan;
+ fftw_complex *m_cbuf;
+#else
+ double *m_ro;
+ double *m_io;
+ void fft(unsigned int n, bool inverse,
+ double *ri, double *ii, double *ro, double *io);
+#endif
+
+ size_t makeBlockSizeAcceptable(size_t) const;
+};
+
+PluginInputDomainAdapter::PluginInputDomainAdapter(Plugin *plugin) :
+ PluginWrapper(plugin)
+{
+ m_impl = new Impl(plugin, m_inputSampleRate);
+}
+
+PluginInputDomainAdapter::~PluginInputDomainAdapter()
+{
+ delete m_impl;
+}
+
+bool
+PluginInputDomainAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ return m_impl->initialise(channels, stepSize, blockSize);
+}
+
+Plugin::InputDomain
+PluginInputDomainAdapter::getInputDomain() const
+{
+ return TimeDomain;
+}
+
+size_t
+PluginInputDomainAdapter::getPreferredStepSize() const
+{
+ return m_impl->getPreferredStepSize();
+}
+
+size_t
+PluginInputDomainAdapter::getPreferredBlockSize() const
+{
+ return m_impl->getPreferredBlockSize();
+}
+
+Plugin::FeatureSet
+PluginInputDomainAdapter::process(const float *const *inputBuffers, RealTime timestamp)
+{
+ return m_impl->process(inputBuffers, timestamp);
+}
+
+RealTime
+PluginInputDomainAdapter::getTimestampAdjustment() const
+{
+ return m_impl->getTimestampAdjustment();
+}
+
+
+PluginInputDomainAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
+ m_plugin(plugin),
+ m_inputSampleRate(inputSampleRate),
+ m_channels(0),
+ m_blockSize(0),
+ m_freqbuf(0),
+ m_ri(0),
+ m_window(0),
+#ifdef HAVE_FFTW3
+ m_plan(0),
+ m_cbuf(0)
+#else
+ m_ro(0),
+ m_io(0)
+#endif
+{
+}
+
+PluginInputDomainAdapter::Impl::~Impl()
+{
+ // the adapter will delete the plugin
+
+ if (m_channels > 0) {
+ for (int c = 0; c < m_channels; ++c) {
+ delete[] m_freqbuf[c];
+ }
+ delete[] m_freqbuf;
+#ifdef HAVE_FFTW3
+ if (m_plan) {
+ fftw_destroy_plan(m_plan);
+ fftw_free(m_ri);
+ fftw_free(m_cbuf);
+ m_plan = 0;
+ }
+#else
+ delete[] m_ri;
+ delete[] m_ro;
+ delete[] m_io;
+#endif
+ delete[] m_window;
+ }
+}
+
+// for some visual studii apparently
+#ifndef M_PI
+#define M_PI 3.14159265358979232846
+#endif
+
+bool
+PluginInputDomainAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ if (m_plugin->getInputDomain() == TimeDomain) {
+
+ m_blockSize = int(blockSize);
+ m_channels = int(channels);
+
+ return m_plugin->initialise(channels, stepSize, blockSize);
+ }
+
+ if (blockSize < 2) {
+ std::cerr << "ERROR: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: blocksize < 2 not supported" << std::endl;
+ return false;
+ }
+
+ if (blockSize & (blockSize-1)) {
+ std::cerr << "ERROR: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: non-power-of-two\nblocksize " << blockSize << " not supported" << std::endl;
+ return false;
+ }
+
+ if (m_channels > 0) {
+ for (int c = 0; c < m_channels; ++c) {
+ delete[] m_freqbuf[c];
+ }
+ delete[] m_freqbuf;
+#ifdef HAVE_FFTW3
+ if (m_plan) {
+ fftw_destroy_plan(m_plan);
+ fftw_free(m_ri);
+ fftw_free(m_cbuf);
+ m_plan = 0;
+ }
+#else
+ delete[] m_ri;
+ delete[] m_ro;
+ delete[] m_io;
+#endif
+ delete[] m_window;
+ }
+
+ m_blockSize = int(blockSize);
+ m_channels = int(channels);
+
+ m_freqbuf = new float *[m_channels];
+ for (int c = 0; c < m_channels; ++c) {
+ m_freqbuf[c] = new float[m_blockSize + 2];
+ }
+ m_window = new double[m_blockSize];
+
+ for (int i = 0; i < m_blockSize; ++i) {
+ // Hanning window
+ m_window[i] = (0.50 - 0.50 * cos((2.0 * M_PI * i) / m_blockSize));
+ }
+
+#ifdef HAVE_FFTW3
+ m_ri = (double *)fftw_malloc(blockSize * sizeof(double));
+ m_cbuf = (fftw_complex *)fftw_malloc((blockSize/2 + 1) * sizeof(fftw_complex));
+ m_plan = fftw_plan_dft_r2c_1d(blockSize, m_ri, m_cbuf, FFTW_MEASURE);
+#else
+ m_ri = new double[m_blockSize];
+ m_ro = new double[m_blockSize];
+ m_io = new double[m_blockSize];
+#endif
+
+ return m_plugin->initialise(channels, stepSize, blockSize);
+}
+
+size_t
+PluginInputDomainAdapter::Impl::getPreferredStepSize() const
+{
+ size_t step = m_plugin->getPreferredStepSize();
+
+ if (step == 0 && (m_plugin->getInputDomain() == FrequencyDomain)) {
+ step = getPreferredBlockSize() / 2;
+ }
+
+ return step;
+}
+
+size_t
+PluginInputDomainAdapter::Impl::getPreferredBlockSize() const
+{
+ size_t block = m_plugin->getPreferredBlockSize();
+
+ if (m_plugin->getInputDomain() == FrequencyDomain) {
+ if (block == 0) {
+ block = 1024;
+ } else {
+ block = makeBlockSizeAcceptable(block);
+ }
+ }
+
+ return block;
+}
+
+size_t
+PluginInputDomainAdapter::Impl::makeBlockSizeAcceptable(size_t blockSize) const
+{
+ if (blockSize < 2) {
+
+ std::cerr << "WARNING: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: blocksize < 2 not" << std::endl
+ << "supported, increasing from " << blockSize << " to 2" << std::endl;
+ blockSize = 2;
+
+ } else if (blockSize & (blockSize-1)) {
+
+#ifdef HAVE_FFTW3
+ // not an issue with FFTW
+#else
+
+ // not a power of two, can't handle that with our built-in FFT
+ // implementation
+
+ size_t nearest = blockSize;
+ size_t power = 0;
+ while (nearest > 1) {
+ nearest >>= 1;
+ ++power;
+ }
+ nearest = 1;
+ while (power) {
+ nearest <<= 1;
+ --power;
+ }
+
+ if (blockSize - nearest > (nearest*2) - blockSize) {
+ nearest = nearest*2;
+ }
+
+ std::cerr << "WARNING: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: non-power-of-two\nblocksize " << blockSize << " not supported, using blocksize " << nearest << " instead" << std::endl;
+ blockSize = nearest;
+
+#endif
+ }
+
+ return blockSize;
+}
+
+RealTime
+PluginInputDomainAdapter::Impl::getTimestampAdjustment() const
+{
+ if (m_plugin->getInputDomain() == TimeDomain) {
+ return RealTime::zeroTime;
+ } else {
+ return RealTime::frame2RealTime
+ (m_blockSize/2, int(m_inputSampleRate + 0.5));
+ }
+}
+
+Plugin::FeatureSet
+PluginInputDomainAdapter::Impl::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ if (m_plugin->getInputDomain() == TimeDomain) {
+ return m_plugin->process(inputBuffers, timestamp);
+ }
+
+ // The timestamp supplied should be (according to the Vamp::Plugin
+ // spec) the time of the start of the time-domain input block.
+ // However, we want to pass to the plugin an FFT output calculated
+ // from the block of samples _centred_ on that timestamp.
+ //
+ // We have two options:
+ //
+ // 1. Buffer the input, calculating the fft of the values at the
+ // passed-in block minus blockSize/2 rather than starting at the
+ // passed-in block. So each time we call process on the plugin,
+ // we are passing in the same timestamp as was passed to our own
+ // process plugin, but not (the frequency domain representation
+ // of) the same set of samples. Advantages: avoids confusion in
+ // the host by ensuring the returned values have timestamps
+ // comparable with that passed in to this function (in fact this
+ // is pretty much essential for one-value-per-block outputs);
+ // consistent with hosts such as SV that deal with the
+ // frequency-domain transform themselves. Disadvantages: means
+ // making the not necessarily correct assumption that the samples
+ // preceding the first official block are all zero (or some other
+ // known value).
+ //
+ // 2. Increase the passed-in timestamps by half the blocksize. So
+ // when we call process, we are passing in the frequency domain
+ // representation of the same set of samples as passed to us, but
+ // with a different timestamp. Advantages: simplicity; avoids
+ // iffy assumption mentioned above. Disadvantages: inconsistency
+ // with SV in cases where stepSize != blockSize/2; potential
+ // confusion arising from returned timestamps being calculated
+ // from the adjusted input timestamps rather than the original
+ // ones (and inaccuracy where the returned timestamp is implied,
+ // as in one-value-per-block).
+ //
+ // Neither way is ideal, but I don't think either is strictly
+ // incorrect either. I think this is just a case where the same
+ // plugin can legitimately produce differing results from the same
+ // input data, depending on how that data is packaged.
+ //
+ // We'll go for option 2, adjusting the timestamps. Note in
+ // particular that this means some results can differ from those
+ // produced by SV.
+
+// std::cerr << "PluginInputDomainAdapter: sampleRate " << m_inputSampleRate << ", blocksize " << m_blockSize << ", adjusting time from " << timestamp;
+
+ timestamp = timestamp + getTimestampAdjustment();
+
+// std::cerr << " to " << timestamp << std::endl;
+
+ for (int c = 0; c < m_channels; ++c) {
+
+ for (int i = 0; i < m_blockSize; ++i) {
+ m_ri[i] = double(inputBuffers[c][i]) * m_window[i];
+ }
+
+ for (int i = 0; i < m_blockSize/2; ++i) {
+ // FFT shift
+ double value = m_ri[i];
+ m_ri[i] = m_ri[i + m_blockSize/2];
+ m_ri[i + m_blockSize/2] = value;
+ }
+
+#ifdef HAVE_FFTW3
+
+ fftw_execute(m_plan);
+
+ for (int i = 0; i <= m_blockSize/2; ++i) {
+ m_freqbuf[c][i * 2] = float(m_cbuf[i][0]);
+ m_freqbuf[c][i * 2 + 1] = float(m_cbuf[i][1]);
+ }
+
+#else
+
+ fft(m_blockSize, false, m_ri, 0, m_ro, m_io);
+
+ for (int i = 0; i <= m_blockSize/2; ++i) {
+ m_freqbuf[c][i * 2] = float(m_ro[i]);
+ m_freqbuf[c][i * 2 + 1] = float(m_io[i]);
+ }
+
+#endif
+ }
+
+ return m_plugin->process(m_freqbuf, timestamp);
+}
+
+#ifndef HAVE_FFTW3
+
+void
+PluginInputDomainAdapter::Impl::fft(unsigned int n, bool inverse,
+ double *ri, double *ii, double *ro, double *io)
+{
+ if (!ri || !ro || !io) return;
+
+ unsigned int bits;
+ unsigned int i, j, k, m;
+ unsigned int blockSize, blockEnd;
+
+ double tr, ti;
+
+ if (n < 2) return;
+ if (n & (n-1)) return;
+
+ double angle = 2.0 * M_PI;
+ if (inverse) angle = -angle;
+
+ for (i = 0; ; ++i) {
+ if (n & (1 << i)) {
+ bits = i;
+ break;
+ }
+ }
+
+ static unsigned int tableSize = 0;
+ static int *table = 0;
+
+ if (tableSize != n) {
+
+ delete[] table;
+
+ table = new int[n];
+
+ for (i = 0; i < n; ++i) {
+
+ m = i;
+
+ for (j = k = 0; j < bits; ++j) {
+ k = (k << 1) | (m & 1);
+ m >>= 1;
+ }
+
+ table[i] = k;
+ }
+
+ tableSize = n;
+ }
+
+ if (ii) {
+ for (i = 0; i < n; ++i) {
+ ro[table[i]] = ri[i];
+ io[table[i]] = ii[i];
+ }
+ } else {
+ for (i = 0; i < n; ++i) {
+ ro[table[i]] = ri[i];
+ io[table[i]] = 0.0;
+ }
+ }
+
+ blockEnd = 1;
+
+ for (blockSize = 2; blockSize <= n; blockSize <<= 1) {
+
+ double delta = angle / (double)blockSize;
+ double sm2 = -sin(-2 * delta);
+ double sm1 = -sin(-delta);
+ double cm2 = cos(-2 * delta);
+ double cm1 = cos(-delta);
+ double w = 2 * cm1;
+ double ar[3], ai[3];
+
+ for (i = 0; i < n; i += blockSize) {
+
+ ar[2] = cm2;
+ ar[1] = cm1;
+
+ ai[2] = sm2;
+ ai[1] = sm1;
+
+ for (j = i, m = 0; m < blockEnd; j++, m++) {
+
+ ar[0] = w * ar[1] - ar[2];
+ ar[2] = ar[1];
+ ar[1] = ar[0];
+
+ ai[0] = w * ai[1] - ai[2];
+ ai[2] = ai[1];
+ ai[1] = ai[0];
+
+ k = j + blockEnd;
+ tr = ar[0] * ro[k] - ai[0] * io[k];
+ ti = ar[0] * io[k] + ai[0] * ro[k];
+
+ ro[k] = ro[j] - tr;
+ io[k] = io[j] - ti;
+
+ ro[j] += tr;
+ io[j] += ti;
+ }
+ }
+
+ blockEnd = blockSize;
+ }
+
+ if (inverse) {
+
+ double denom = (double)n;
+
+ for (i = 0; i < n; i++) {
+ ro[i] /= denom;
+ io[i] /= denom;
+ }
+ }
+}
+
+#endif
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginInputDomainAdapter.cpp)
+
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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-hostsdk/PluginHostAdapter.h>
+#include <vamp-hostsdk/PluginLoader.h>
+#include <vamp-hostsdk/PluginInputDomainAdapter.h>
+#include <vamp-hostsdk/PluginChannelAdapter.h>
+#include <vamp-hostsdk/PluginBufferingAdapter.h>
+
+#include <fstream>
+#include <cctype> // tolower
+
+#include <cstring>
+
+#ifdef _WIN32
+
+#include <windows.h>
+#include <tchar.h>
+#define PLUGIN_SUFFIX "dll"
+
+#else /* ! _WIN32 */
+
+#include <dirent.h>
+#include <dlfcn.h>
+
+#ifdef __APPLE__
+#define PLUGIN_SUFFIX "dylib"
+#else /* ! __APPLE__ */
+#define PLUGIN_SUFFIX "so"
+#endif /* ! __APPLE__ */
+
+#endif /* ! _WIN32 */
+
+using namespace std;
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginLoader.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginLoader::Impl
+{
+public:
+ Impl();
+ virtual ~Impl();
+
+ PluginKeyList listPlugins();
+
+ Plugin *loadPlugin(PluginKey key,
+ float inputSampleRate,
+ int adapterFlags);
+
+ PluginKey composePluginKey(string libraryName, string identifier);
+
+ PluginCategoryHierarchy getPluginCategory(PluginKey key);
+
+ string getLibraryPathForPlugin(PluginKey key);
+
+ static void setInstanceToClean(PluginLoader *instance);
+
+protected:
+ class PluginDeletionNotifyAdapter : public PluginWrapper {
+ public:
+ PluginDeletionNotifyAdapter(Plugin *plugin, Impl *loader);
+ virtual ~PluginDeletionNotifyAdapter();
+ protected:
+ Impl *m_loader;
+ };
+
+ class InstanceCleaner {
+ public:
+ InstanceCleaner() : m_instance(0) { }
+ ~InstanceCleaner() { delete m_instance; }
+ void setInstance(PluginLoader *instance) { m_instance = instance; }
+ protected:
+ PluginLoader *m_instance;
+ };
+
+ virtual void pluginDeleted(PluginDeletionNotifyAdapter *adapter);
+
+ map<PluginKey, string> m_pluginLibraryNameMap;
+ bool m_allPluginsEnumerated;
+ void enumeratePlugins(PluginKey forPlugin = "");
+
+ map<PluginKey, PluginCategoryHierarchy> m_taxonomy;
+ void generateTaxonomy();
+
+ map<Plugin *, void *> m_pluginLibraryHandleMap;
+
+ bool decomposePluginKey(PluginKey key,
+ string &libraryName, string &identifier);
+
+ void *loadLibrary(string path);
+ void unloadLibrary(void *handle);
+ void *lookupInLibrary(void *handle, const char *symbol);
+
+ string splicePath(string a, string b);
+ vector<string> listFiles(string dir, string ext);
+
+ static InstanceCleaner m_cleaner;
+};
+
+PluginLoader *
+PluginLoader::m_instance = 0;
+
+PluginLoader::Impl::InstanceCleaner
+PluginLoader::Impl::m_cleaner;
+
+PluginLoader::PluginLoader()
+{
+ m_impl = new Impl();
+}
+
+PluginLoader::~PluginLoader()
+{
+ delete m_impl;
+}
+
+PluginLoader *
+PluginLoader::getInstance()
+{
+ if (!m_instance) {
+ // The cleaner doesn't own the instance, because we leave the
+ // instance pointer in the base class for binary backwards
+ // compatibility reasons and to avoid waste
+ m_instance = new PluginLoader();
+ Impl::setInstanceToClean(m_instance);
+ }
+ return m_instance;
+}
+
+vector<PluginLoader::PluginKey>
+PluginLoader::listPlugins()
+{
+ return m_impl->listPlugins();
+}
+
+Plugin *
+PluginLoader::loadPlugin(PluginKey key,
+ float inputSampleRate,
+ int adapterFlags)
+{
+ return m_impl->loadPlugin(key, inputSampleRate, adapterFlags);
+}
+
+PluginLoader::PluginKey
+PluginLoader::composePluginKey(string libraryName, string identifier)
+{
+ return m_impl->composePluginKey(libraryName, identifier);
+}
+
+PluginLoader::PluginCategoryHierarchy
+PluginLoader::getPluginCategory(PluginKey key)
+{
+ return m_impl->getPluginCategory(key);
+}
+
+string
+PluginLoader::getLibraryPathForPlugin(PluginKey key)
+{
+ return m_impl->getLibraryPathForPlugin(key);
+}
+
+PluginLoader::Impl::Impl() :
+ m_allPluginsEnumerated(false)
+{
+}
+
+PluginLoader::Impl::~Impl()
+{
+}
+
+void
+PluginLoader::Impl::setInstanceToClean(PluginLoader *instance)
+{
+ m_cleaner.setInstance(instance);
+}
+
+vector<PluginLoader::PluginKey>
+PluginLoader::Impl::listPlugins()
+{
+ if (!m_allPluginsEnumerated) enumeratePlugins();
+
+ vector<PluginKey> plugins;
+ for (map<PluginKey, string>::iterator mi = m_pluginLibraryNameMap.begin();
+ mi != m_pluginLibraryNameMap.end(); ++mi) {
+ plugins.push_back(mi->first);
+ }
+
+ return plugins;
+}
+
+void
+PluginLoader::Impl::enumeratePlugins(PluginKey forPlugin)
+{
+ vector<string> path = PluginHostAdapter::getPluginPath();
+
+ string libraryName, identifier;
+ if (forPlugin != "") {
+ if (!decomposePluginKey(forPlugin, libraryName, identifier)) {
+ std::cerr << "WARNING: Vamp::HostExt::PluginLoader: Invalid plugin key \""
+ << forPlugin << "\" in enumerate" << std::endl;
+ return;
+ }
+ }
+
+ for (size_t i = 0; i < path.size(); ++i) {
+
+ vector<string> files = listFiles(path[i], PLUGIN_SUFFIX);
+
+ for (vector<string>::iterator fi = files.begin();
+ fi != files.end(); ++fi) {
+
+ if (libraryName != "") {
+ // libraryName is lowercased and lacking an extension,
+ // as it came from the plugin key
+ string temp = *fi;
+ for (size_t i = 0; i < temp.length(); ++i) {
+ temp[i] = tolower(temp[i]);
+ }
+ string::size_type pi = temp.find('.');
+ if (pi == string::npos) {
+ if (libraryName != temp) continue;
+ } else {
+ if (libraryName != temp.substr(0, pi)) continue;
+ }
+ }
+
+ string fullPath = path[i];
+ fullPath = splicePath(fullPath, *fi);
+ void *handle = loadLibrary(fullPath);
+ if (!handle) continue;
+
+ VampGetPluginDescriptorFunction fn =
+ (VampGetPluginDescriptorFunction)lookupInLibrary
+ (handle, "vampGetPluginDescriptor");
+
+ if (!fn) {
+ unloadLibrary(handle);
+ continue;
+ }
+
+ int index = 0;
+ const VampPluginDescriptor *descriptor = 0;
+
+ while ((descriptor = fn(VAMP_API_VERSION, index))) {
+ ++index;
+ if (identifier != "") {
+ if (descriptor->identifier != identifier) continue;
+ }
+ PluginKey key = composePluginKey(*fi, descriptor->identifier);
+// std::cerr << "enumerate: " << key << " (path: " << fullPath << ")" << std::endl;
+ if (m_pluginLibraryNameMap.find(key) ==
+ m_pluginLibraryNameMap.end()) {
+ m_pluginLibraryNameMap[key] = fullPath;
+ }
+ }
+
+ unloadLibrary(handle);
+ }
+ }
+
+ if (forPlugin == "") m_allPluginsEnumerated = true;
+}
+
+PluginLoader::PluginKey
+PluginLoader::Impl::composePluginKey(string libraryName, string identifier)
+{
+ string basename = libraryName;
+
+ string::size_type li = basename.rfind('/');
+ if (li != string::npos) basename = basename.substr(li + 1);
+
+ li = basename.find('.');
+ if (li != string::npos) basename = basename.substr(0, li);
+
+ for (size_t i = 0; i < basename.length(); ++i) {
+ basename[i] = tolower(basename[i]);
+ }
+
+ return basename + ":" + identifier;
+}
+
+bool
+PluginLoader::Impl::decomposePluginKey(PluginKey key,
+ string &libraryName,
+ string &identifier)
+{
+ string::size_type ki = key.find(':');
+ if (ki == string::npos) {
+ return false;
+ }
+
+ libraryName = key.substr(0, ki);
+ identifier = key.substr(ki + 1);
+ return true;
+}
+
+PluginLoader::PluginCategoryHierarchy
+PluginLoader::Impl::getPluginCategory(PluginKey plugin)
+{
+ if (m_taxonomy.empty()) generateTaxonomy();
+ if (m_taxonomy.find(plugin) == m_taxonomy.end()) {
+ return PluginCategoryHierarchy();
+ }
+ return m_taxonomy[plugin];
+}
+
+string
+PluginLoader::Impl::getLibraryPathForPlugin(PluginKey plugin)
+{
+ if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
+ if (m_allPluginsEnumerated) return "";
+ enumeratePlugins(plugin);
+ }
+ if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
+ return "";
+ }
+ return m_pluginLibraryNameMap[plugin];
+}
+
+Plugin *
+PluginLoader::Impl::loadPlugin(PluginKey key,
+ float inputSampleRate, int adapterFlags)
+{
+ string libname, identifier;
+ if (!decomposePluginKey(key, libname, identifier)) {
+ std::cerr << "Vamp::HostExt::PluginLoader: Invalid plugin key \""
+ << key << "\" in loadPlugin" << std::endl;
+ return 0;
+ }
+
+ string fullPath = getLibraryPathForPlugin(key);
+ if (fullPath == "") return 0;
+
+ void *handle = loadLibrary(fullPath);
+ if (!handle) return 0;
+
+ VampGetPluginDescriptorFunction fn =
+ (VampGetPluginDescriptorFunction)lookupInLibrary
+ (handle, "vampGetPluginDescriptor");
+
+ if (!fn) {
+ unloadLibrary(handle);
+ return 0;
+ }
+
+ int index = 0;
+ const VampPluginDescriptor *descriptor = 0;
+
+ while ((descriptor = fn(VAMP_API_VERSION, index))) {
+
+ if (string(descriptor->identifier) == identifier) {
+
+ Vamp::PluginHostAdapter *plugin =
+ new Vamp::PluginHostAdapter(descriptor, inputSampleRate);
+
+ Plugin *adapter = new PluginDeletionNotifyAdapter(plugin, this);
+
+ m_pluginLibraryHandleMap[adapter] = handle;
+
+ if (adapterFlags & ADAPT_INPUT_DOMAIN) {
+ if (adapter->getInputDomain() == Plugin::FrequencyDomain) {
+ adapter = new PluginInputDomainAdapter(adapter);
+ }
+ }
+
+ if (adapterFlags & ADAPT_BUFFER_SIZE) {
+ adapter = new PluginBufferingAdapter(adapter);
+ }
+
+ if (adapterFlags & ADAPT_CHANNEL_COUNT) {
+ adapter = new PluginChannelAdapter(adapter);
+ }
+
+ return adapter;
+ }
+
+ ++index;
+ }
+
+ cerr << "Vamp::HostExt::PluginLoader: Plugin \""
+ << identifier << "\" not found in library \""
+ << fullPath << "\"" << endl;
+
+ return 0;
+}
+
+void
+PluginLoader::Impl::generateTaxonomy()
+{
+// cerr << "PluginLoader::Impl::generateTaxonomy" << endl;
+
+ vector<string> path = PluginHostAdapter::getPluginPath();
+ string libfragment = "/lib/";
+ vector<string> catpath;
+
+ string suffix = "cat";
+
+ for (vector<string>::iterator i = path.begin();
+ i != path.end(); ++i) {
+
+ // It doesn't matter that we're using literal forward-slash in
+ // this bit, as it's only relevant if the path contains
+ // "/lib/", which is only meaningful and only plausible on
+ // systems with forward-slash delimiters
+
+ string dir = *i;
+ string::size_type li = dir.find(libfragment);
+
+ if (li != string::npos) {
+ catpath.push_back
+ (dir.substr(0, li)
+ + "/share/"
+ + dir.substr(li + libfragment.length()));
+ }
+
+ catpath.push_back(dir);
+ }
+
+ char buffer[1024];
+
+ for (vector<string>::iterator i = catpath.begin();
+ i != catpath.end(); ++i) {
+
+ vector<string> files = listFiles(*i, suffix);
+
+ for (vector<string>::iterator fi = files.begin();
+ fi != files.end(); ++fi) {
+
+ string filepath = splicePath(*i, *fi);
+ ifstream is(filepath.c_str(), ifstream::in | ifstream::binary);
+
+ if (is.fail()) {
+// cerr << "failed to open: " << filepath << endl;
+ continue;
+ }
+
+// cerr << "opened: " << filepath << endl;
+
+ while (!!is.getline(buffer, 1024)) {
+
+ string line(buffer);
+
+// cerr << "line = " << line << endl;
+
+ string::size_type di = line.find("::");
+ if (di == string::npos) continue;
+
+ string id = line.substr(0, di);
+ string encodedCat = line.substr(di + 2);
+
+ if (id.substr(0, 5) != "vamp:") continue;
+ id = id.substr(5);
+
+ while (encodedCat.length() >= 1 &&
+ encodedCat[encodedCat.length()-1] == '\r') {
+ encodedCat = encodedCat.substr(0, encodedCat.length()-1);
+ }
+
+// cerr << "id = " << id << ", cat = " << encodedCat << endl;
+
+ PluginCategoryHierarchy category;
+ string::size_type ai;
+ while ((ai = encodedCat.find(" > ")) != string::npos) {
+ category.push_back(encodedCat.substr(0, ai));
+ encodedCat = encodedCat.substr(ai + 3);
+ }
+ if (encodedCat != "") category.push_back(encodedCat);
+
+ m_taxonomy[id] = category;
+ }
+ }
+ }
+}
+
+void *
+PluginLoader::Impl::loadLibrary(string path)
+{
+ void *handle = 0;
+#ifdef _WIN32
+ handle = LoadLibrary(path.c_str());
+ if (!handle) {
+ cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
+ << path << "\"" << endl;
+ }
+#else
+ handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
+ if (!handle) {
+ cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
+ << path << "\": " << dlerror() << endl;
+ }
+#endif
+ return handle;
+}
+
+void
+PluginLoader::Impl::unloadLibrary(void *handle)
+{
+#ifdef _WIN32
+ FreeLibrary((HINSTANCE)handle);
+#else
+ dlclose(handle);
+#endif
+}
+
+void *
+PluginLoader::Impl::lookupInLibrary(void *handle, const char *symbol)
+{
+#ifdef _WIN32
+ return (void *)GetProcAddress((HINSTANCE)handle, symbol);
+#else
+ return (void *)dlsym(handle, symbol);
+#endif
+}
+
+string
+PluginLoader::Impl::splicePath(string a, string b)
+{
+#ifdef _WIN32
+ return a + "\\" + b;
+#else
+ return a + "/" + b;
+#endif
+}
+
+vector<string>
+PluginLoader::Impl::listFiles(string dir, string extension)
+{
+ vector<string> files;
+
+#ifdef _WIN32
+
+ string expression = dir + "\\*." + extension;
+ WIN32_FIND_DATA data;
+ HANDLE fh = FindFirstFile(expression.c_str(), &data);
+ if (fh == INVALID_HANDLE_VALUE) return files;
+
+ bool ok = true;
+ while (ok) {
+ files.push_back(data.cFileName);
+ ok = FindNextFile(fh, &data);
+ }
+
+ FindClose(fh);
+
+#else
+
+ size_t extlen = extension.length();
+ DIR *d = opendir(dir.c_str());
+ if (!d) return files;
+
+ struct dirent *e = 0;
+ while ((e = readdir(d))) {
+
+ if (!e->d_name) continue;
+
+ size_t len = strlen(e->d_name);
+ if (len < extlen + 2 ||
+ e->d_name + len - extlen - 1 != "." + extension) {
+ continue;
+ }
+
+ files.push_back(e->d_name);
+ }
+
+ closedir(d);
+#endif
+
+ return files;
+}
+
+void
+PluginLoader::Impl::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
+{
+ void *handle = m_pluginLibraryHandleMap[adapter];
+ if (handle) unloadLibrary(handle);
+ m_pluginLibraryHandleMap.erase(adapter);
+}
+
+PluginLoader::Impl::PluginDeletionNotifyAdapter::PluginDeletionNotifyAdapter(Plugin *plugin,
+ Impl *loader) :
+ PluginWrapper(plugin),
+ m_loader(loader)
+{
+}
+
+PluginLoader::Impl::PluginDeletionNotifyAdapter::~PluginDeletionNotifyAdapter()
+{
+ // We need to delete the plugin before calling pluginDeleted, as
+ // the delete call may require calling through to the descriptor
+ // (for e.g. cleanup) but pluginDeleted may unload the required
+ // library for the call. To prevent a double deletion when our
+ // parent's destructor runs (after this one), be sure to set
+ // m_plugin to 0 after deletion.
+ delete m_plugin;
+ m_plugin = 0;
+
+ if (m_loader) m_loader->pluginDeleted(this);
+}
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginLoader.cpp)
+
--- /dev/null
+/* -*- 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-2008 Chris Cannam and QMUL.
+
+ 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-hostsdk/PluginSummarisingAdapter.h>
+
+#include <map>
+#include <algorithm>
+#include <cmath>
+#include <climits>
+
+//#define DEBUG_PLUGIN_SUMMARISING_ADAPTER 1
+//#define DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT 1
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginSummarisingAdapter.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginSummarisingAdapter::Impl
+{
+public:
+ Impl(Plugin *plugin, float inputSampleRate);
+ ~Impl();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ void reset();
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+ FeatureSet getRemainingFeatures();
+
+ void setSummarySegmentBoundaries(const SegmentBoundaries &);
+
+ FeatureList getSummaryForOutput(int output,
+ SummaryType type,
+ AveragingMethod avg);
+
+ FeatureSet getSummaryForAllOutputs(SummaryType type,
+ AveragingMethod avg);
+
+protected:
+ Plugin *m_plugin;
+ float m_inputSampleRate;
+ size_t m_stepSize;
+ size_t m_blockSize;
+
+ SegmentBoundaries m_boundaries;
+
+ typedef std::vector<float> ValueList;
+
+ struct Result { // smaller than Feature
+ RealTime time;
+ RealTime duration;
+ ValueList values; // bin number -> value
+ };
+
+ typedef std::vector<Result> ResultList;
+
+ struct OutputAccumulator {
+ int bins;
+ ResultList results;
+ OutputAccumulator() : bins(0) { }
+ };
+
+ typedef std::map<int, OutputAccumulator> OutputAccumulatorMap;
+ OutputAccumulatorMap m_accumulators; // output number -> accumulator
+
+ typedef std::map<RealTime, OutputAccumulator> SegmentAccumulatorMap;
+ typedef std::map<int, SegmentAccumulatorMap> OutputSegmentAccumulatorMap;
+ OutputSegmentAccumulatorMap m_segmentedAccumulators; // output -> segmented
+
+ typedef std::map<int, RealTime> OutputTimestampMap;
+ OutputTimestampMap m_prevTimestamps; // output number -> timestamp
+ OutputTimestampMap m_prevDurations; // output number -> durations
+
+ struct OutputBinSummary {
+
+ int count;
+
+ // extents
+ double minimum;
+ double maximum;
+ double sum;
+
+ // sample-average results
+ double median;
+ double mode;
+ double variance;
+
+ // continuous-time average results
+ double median_c;
+ double mode_c;
+ double mean_c;
+ double variance_c;
+ };
+
+ typedef std::map<int, OutputBinSummary> OutputSummary;
+ typedef std::map<RealTime, OutputSummary> SummarySegmentMap;
+ typedef std::map<int, SummarySegmentMap> OutputSummarySegmentMap;
+
+ OutputSummarySegmentMap m_summaries;
+
+ bool m_reduced;
+ RealTime m_endTime;
+
+ void accumulate(const FeatureSet &fs, RealTime, bool final);
+ void accumulate(int output, const Feature &f, RealTime, bool final);
+ void accumulateFinalDurations();
+ void findSegmentBounds(RealTime t, RealTime &start, RealTime &end);
+ void segment();
+ void reduce();
+
+ std::string getSummaryLabel(SummaryType type, AveragingMethod avg);
+};
+
+static RealTime INVALID_DURATION(INT_MIN, INT_MIN);
+
+PluginSummarisingAdapter::PluginSummarisingAdapter(Plugin *plugin) :
+ PluginWrapper(plugin)
+{
+ m_impl = new Impl(plugin, m_inputSampleRate);
+}
+
+PluginSummarisingAdapter::~PluginSummarisingAdapter()
+{
+ delete m_impl;
+}
+
+bool
+PluginSummarisingAdapter::initialise(size_t channels,
+ size_t stepSize, size_t blockSize)
+{
+ return
+ PluginWrapper::initialise(channels, stepSize, blockSize) &&
+ m_impl->initialise(channels, stepSize, blockSize);
+}
+
+void
+PluginSummarisingAdapter::reset()
+{
+ m_impl->reset();
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::process(const float *const *inputBuffers, RealTime timestamp)
+{
+ return m_impl->process(inputBuffers, timestamp);
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::getRemainingFeatures()
+{
+ return m_impl->getRemainingFeatures();
+}
+
+void
+PluginSummarisingAdapter::setSummarySegmentBoundaries(const SegmentBoundaries &b)
+{
+ m_impl->setSummarySegmentBoundaries(b);
+}
+
+Plugin::FeatureList
+PluginSummarisingAdapter::getSummaryForOutput(int output,
+ SummaryType type,
+ AveragingMethod avg)
+{
+ return m_impl->getSummaryForOutput(output, type, avg);
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::getSummaryForAllOutputs(SummaryType type,
+ AveragingMethod avg)
+{
+ return m_impl->getSummaryForAllOutputs(type, avg);
+}
+
+PluginSummarisingAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
+ m_plugin(plugin),
+ m_inputSampleRate(inputSampleRate),
+ m_reduced(false)
+{
+}
+
+PluginSummarisingAdapter::Impl::~Impl()
+{
+}
+
+bool
+PluginSummarisingAdapter::Impl::initialise(size_t channels,
+ size_t stepSize, size_t blockSize)
+{
+ m_stepSize = stepSize;
+ m_blockSize = blockSize;
+ return true;
+}
+
+void
+PluginSummarisingAdapter::Impl::reset()
+{
+ m_accumulators.clear();
+ m_segmentedAccumulators.clear();
+ m_prevTimestamps.clear();
+ m_prevDurations.clear();
+ m_summaries.clear();
+ m_reduced = false;
+ m_endTime = RealTime();
+ m_plugin->reset();
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::Impl::process(const float *const *inputBuffers,
+ RealTime timestamp)
+{
+ if (m_reduced) {
+ std::cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << std::endl;
+ }
+ FeatureSet fs = m_plugin->process(inputBuffers, timestamp);
+ accumulate(fs, timestamp, false);
+ m_endTime = timestamp +
+ RealTime::frame2RealTime(m_stepSize, int(m_inputSampleRate + 0.5));
+ return fs;
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::Impl::getRemainingFeatures()
+{
+ if (m_reduced) {
+ std::cerr << "WARNING: Cannot call PluginSummarisingAdapter::process() or getRemainingFeatures() after one of the getSummary methods" << std::endl;
+ }
+ FeatureSet fs = m_plugin->getRemainingFeatures();
+ accumulate(fs, m_endTime, true);
+ return fs;
+}
+
+void
+PluginSummarisingAdapter::Impl::setSummarySegmentBoundaries(const SegmentBoundaries &b)
+{
+ m_boundaries = b;
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "PluginSummarisingAdapter::setSummarySegmentBoundaries: boundaries are:" << std::endl;
+ for (SegmentBoundaries::const_iterator i = m_boundaries.begin();
+ i != m_boundaries.end(); ++i) {
+ std::cerr << *i << " ";
+ }
+ std::cerr << std::endl;
+#endif
+}
+
+Plugin::FeatureList
+PluginSummarisingAdapter::Impl::getSummaryForOutput(int output,
+ SummaryType type,
+ AveragingMethod avg)
+{
+ if (!m_reduced) {
+ accumulateFinalDurations();
+ segment();
+ reduce();
+ m_reduced = true;
+ }
+
+ bool continuous = (avg == ContinuousTimeAverage);
+
+ FeatureList fl;
+ for (SummarySegmentMap::const_iterator i = m_summaries[output].begin();
+ i != m_summaries[output].end(); ++i) {
+
+ Feature f;
+
+ f.hasTimestamp = true;
+ f.timestamp = i->first;
+
+ f.hasDuration = true;
+ SummarySegmentMap::const_iterator ii = i;
+ if (++ii == m_summaries[output].end()) {
+ f.duration = m_endTime - f.timestamp;
+ } else {
+ f.duration = ii->first - f.timestamp;
+ }
+
+ f.label = getSummaryLabel(type, avg);
+
+ for (OutputSummary::const_iterator j = i->second.begin();
+ j != i->second.end(); ++j) {
+
+ // these will be ordered by bin number, and no bin numbers
+ // will be missing except at the end (because of the way
+ // the accumulators were initially filled in accumulate())
+
+ const OutputBinSummary &summary = j->second;
+ double result = 0.f;
+
+ switch (type) {
+
+ case Minimum:
+ result = summary.minimum;
+ break;
+
+ case Maximum:
+ result = summary.maximum;
+ break;
+
+ case Mean:
+ if (continuous) {
+ result = summary.mean_c;
+ } else if (summary.count) {
+ result = summary.sum / summary.count;
+ }
+ break;
+
+ case Median:
+ if (continuous) result = summary.median_c;
+ else result = summary.median;
+ break;
+
+ case Mode:
+ if (continuous) result = summary.mode_c;
+ else result = summary.mode;
+ break;
+
+ case Sum:
+ result = summary.sum;
+ break;
+
+ case Variance:
+ if (continuous) result = summary.variance_c;
+ else result = summary.variance;
+ break;
+
+ case StandardDeviation:
+ if (continuous) result = sqrtf(summary.variance_c);
+ else result = sqrtf(summary.variance);
+ break;
+
+ case Count:
+ result = summary.count;
+ break;
+
+ case UnknownSummaryType:
+ break;
+
+ default:
+ break;
+ }
+
+ f.values.push_back(result);
+ }
+
+ fl.push_back(f);
+ }
+ return fl;
+}
+
+Plugin::FeatureSet
+PluginSummarisingAdapter::Impl::getSummaryForAllOutputs(SummaryType type,
+ AveragingMethod avg)
+{
+ if (!m_reduced) {
+ accumulateFinalDurations();
+ segment();
+ reduce();
+ m_reduced = true;
+ }
+
+ FeatureSet fs;
+ for (OutputSummarySegmentMap::const_iterator i = m_summaries.begin();
+ i != m_summaries.end(); ++i) {
+ fs[i->first] = getSummaryForOutput(i->first, type, avg);
+ }
+ return fs;
+}
+
+void
+PluginSummarisingAdapter::Impl::accumulate(const FeatureSet &fs,
+ RealTime timestamp,
+ bool final)
+{
+ for (FeatureSet::const_iterator i = fs.begin(); i != fs.end(); ++i) {
+ for (FeatureList::const_iterator j = i->second.begin();
+ j != i->second.end(); ++j) {
+ if (j->hasTimestamp) {
+ accumulate(i->first, *j, j->timestamp, final);
+ } else {
+ //!!! is this correct?
+ accumulate(i->first, *j, timestamp, final);
+ }
+ }
+ }
+}
+
+std::string
+PluginSummarisingAdapter::Impl::getSummaryLabel(SummaryType type,
+ AveragingMethod avg)
+{
+ std::string label;
+ std::string avglabel;
+
+ if (avg == SampleAverage) avglabel = ", sample average";
+ else avglabel = ", continuous-time average";
+
+ switch (type) {
+ case Minimum: label = "(minimum value)"; break;
+ case Maximum: label = "(maximum value)"; break;
+ case Mean: label = "(mean value" + avglabel + ")"; break;
+ case Median: label = "(median value" + avglabel + ")"; break;
+ case Mode: label = "(modal value" + avglabel + ")"; break;
+ case Sum: label = "(sum)"; break;
+ case Variance: label = "(variance" + avglabel + ")"; break;
+ case StandardDeviation: label = "(standard deviation" + avglabel + ")"; break;
+ case Count: label = "(count)"; break;
+ case UnknownSummaryType: label = "(unknown summary)"; break;
+ }
+
+ return label;
+}
+
+void
+PluginSummarisingAdapter::Impl::accumulate(int output,
+ const Feature &f,
+ RealTime timestamp,
+ bool final)
+{
+ // What should happen if a feature's duration spans a segment
+ // boundary? I think we probably want to chop it, and pretend
+ // that it appears in both. A very long feature (e.g. key, if the
+ // whole audio is in a single key) might span many or all
+ // segments, and we want that to be reflected in the results
+ // (e.g. it is the modal key in all of those segments, not just
+ // the first). This is actually quite complicated to do.
+
+ // If features spanning a boundary should be chopped, then we need
+ // to have per-segment accumulators (and the feature value goes
+ // into both -- with a separate phase to split the accumulator up
+ // into segments).
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "output " << output << ": timestamp " << timestamp << ", prev timestamp " << m_prevTimestamps[output] << ", final " << final << std::endl;
+#endif
+
+ // At each process step, accumulate() is called once for each
+ // feature on each output within that process's returned feature
+ // list, and with the timestamp passed in being that of the start
+ // of the process block.
+
+ // At the end (in getRemainingFeatures), accumulate() is called
+ // once for each feature on each output within the feature list
+ // returned by getRemainingFeatures, and with the timestamp being
+ // the same as the last process block and final set to true.
+
+ // (What if getRemainingFeatures doesn't return any features? We
+ // still need to ensure that the final duration is written. Need
+ // a separate function to close the durations.)
+
+ // At each call, we pull out the value for the feature and stuff
+ // it into the accumulator's appropriate values array; and we
+ // calculate the duration for the _previous_ feature, or pull it
+ // from the prevDurations array if the previous feature had a
+ // duration in its structure, and stuff that into the
+ // accumulator's appropriate durations array.
+
+ if (m_prevDurations.find(output) != m_prevDurations.end()) {
+
+ // Not the first time accumulate has been called for this
+ // output -- there has been a previous feature
+
+ RealTime prevDuration;
+
+ // Note that m_prevDurations[output] only contains the
+ // duration field that was contained in the previous feature.
+ // If it didn't have an explicit duration,
+ // m_prevDurations[output] should be INVALID_DURATION and we
+ // will have to calculate the duration from the previous and
+ // current timestamps.
+
+ if (m_prevDurations[output] != INVALID_DURATION) {
+ prevDuration = m_prevDurations[output];
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "Previous duration from previous feature: " << prevDuration << std::endl;
+#endif
+ } else {
+ prevDuration = timestamp - m_prevTimestamps[output];
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "Previous duration from diff: " << timestamp << " - "
+ << m_prevTimestamps[output] << std::endl;
+#endif
+ }
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "output " << output << ": ";
+ std::cerr << "Pushing previous duration as " << prevDuration << std::endl;
+#endif
+
+ m_accumulators[output].results
+ [m_accumulators[output].results.size() - 1]
+ .duration = prevDuration;
+ }
+
+ if (f.hasDuration) m_prevDurations[output] = f.duration;
+ else m_prevDurations[output] = INVALID_DURATION;
+
+ m_prevTimestamps[output] = timestamp;
+
+ if (f.hasDuration) {
+ RealTime et = timestamp;
+ et = et + f.duration;
+ if (et > m_endTime) m_endTime = et;
+ }
+
+ Result result;
+ result.time = timestamp;
+ result.duration = INVALID_DURATION;
+
+ if (int(f.values.size()) > m_accumulators[output].bins) {
+ m_accumulators[output].bins = f.values.size();
+ }
+
+ for (int i = 0; i < int(f.values.size()); ++i) {
+ result.values.push_back(f.values[i]);
+ }
+
+ m_accumulators[output].results.push_back(result);
+}
+
+void
+PluginSummarisingAdapter::Impl::accumulateFinalDurations()
+{
+ for (OutputTimestampMap::iterator i = m_prevTimestamps.begin();
+ i != m_prevTimestamps.end(); ++i) {
+
+ int output = i->first;
+
+ int acount = m_accumulators[output].results.size();
+
+ if (acount == 0) continue;
+
+ RealTime prevTimestamp = i->second;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "output " << output << ": ";
+#endif
+
+ if (m_prevDurations.find(output) != m_prevDurations.end() &&
+ m_prevDurations[output] != INVALID_DURATION) {
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "Pushing final duration from feature as " << m_prevDurations[output] << std::endl;
+#endif
+
+ m_accumulators[output].results[acount - 1].duration =
+ m_prevDurations[output];
+
+ } else {
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "Pushing final duration from diff as " << m_endTime << " - " << m_prevTimestamps[output] << std::endl;
+#endif
+
+ m_accumulators[output].results[acount - 1].duration =
+ m_endTime - m_prevTimestamps[output];
+ }
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "so duration for result no " << acount-1 << " is "
+ << m_accumulators[output].results[acount-1].duration
+ << std::endl;
+#endif
+ }
+}
+
+void
+PluginSummarisingAdapter::Impl::findSegmentBounds(RealTime t,
+ RealTime &start,
+ RealTime &end)
+{
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "findSegmentBounds: t = " << t << std::endl;
+#endif
+
+ SegmentBoundaries::const_iterator i = std::upper_bound
+ (m_boundaries.begin(), m_boundaries.end(), t);
+
+ start = RealTime::zeroTime;
+ end = m_endTime;
+
+ if (i != m_boundaries.end()) {
+ end = *i;
+ }
+
+ if (i != m_boundaries.begin()) {
+ start = *--i;
+ }
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "findSegmentBounds: " << t << " is in segment " << start << " -> " << end << std::endl;
+#endif
+}
+
+void
+PluginSummarisingAdapter::Impl::segment()
+{
+ SegmentBoundaries::iterator boundaryitr = m_boundaries.begin();
+ RealTime segmentStart = RealTime::zeroTime;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "segment: starting" << std::endl;
+#endif
+
+ for (OutputAccumulatorMap::iterator i = m_accumulators.begin();
+ i != m_accumulators.end(); ++i) {
+
+ int output = i->first;
+ OutputAccumulator &source = i->second;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "segment: total results for output " << output << " = "
+ << source.results.size() << std::endl;
+#endif
+
+ // This is basically nonsense if the results have no values
+ // (i.e. their times and counts are the only things of
+ // interest)... but perhaps it's the user's problem if they
+ // ask for segmentation (or any summary at all) in that case
+
+ for (int n = 0; n < int(source.results.size()); ++n) {
+
+ // This result spans source.results[n].time to
+ // source.results[n].time + source.results[n].duration.
+ // We need to dispose it into segments appropriately
+
+ RealTime resultStart = source.results[n].time;
+ RealTime resultEnd = resultStart + source.results[n].duration;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "output: " << output << ", result start = " << resultStart << ", end = " << resultEnd << std::endl;
+#endif
+
+ RealTime segmentStart = RealTime::zeroTime;
+ RealTime segmentEnd = resultEnd - RealTime(1, 0);
+
+ RealTime prevSegmentStart = segmentStart - RealTime(1, 0);
+
+ while (segmentEnd < resultEnd) {
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "segment end " << segmentEnd << " < result end "
+ << resultEnd << " (with result start " << resultStart << ")" << std::endl;
+#endif
+
+ findSegmentBounds(resultStart, segmentStart, segmentEnd);
+
+ if (segmentStart == prevSegmentStart) {
+ // This can happen when we reach the end of the
+ // input, if a feature's end time overruns the
+ // input audio end time
+ break;
+ }
+ prevSegmentStart = segmentStart;
+
+ RealTime chunkStart = resultStart;
+ if (chunkStart < segmentStart) chunkStart = segmentStart;
+
+ RealTime chunkEnd = resultEnd;
+ if (chunkEnd > segmentEnd) chunkEnd = segmentEnd;
+
+ m_segmentedAccumulators[output][segmentStart].bins = source.bins;
+
+ Result chunk;
+ chunk.time = chunkStart;
+ chunk.duration = chunkEnd - chunkStart;
+ chunk.values = source.results[n].values;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER_SEGMENT
+ std::cerr << "chunk for segment " << segmentStart << ": from " << chunk.time << ", duration " << chunk.duration << std::endl;
+#endif
+
+ m_segmentedAccumulators[output][segmentStart].results
+ .push_back(chunk);
+
+ resultStart = chunkEnd;
+ }
+ }
+ }
+}
+
+struct ValueDurationFloatPair
+{
+ float value;
+ float duration;
+
+ ValueDurationFloatPair() : value(0), duration(0) { }
+ ValueDurationFloatPair(float v, float d) : value(v), duration(d) { }
+ ValueDurationFloatPair &operator=(const ValueDurationFloatPair &p) {
+ value = p.value;
+ duration = p.duration;
+ return *this;
+ }
+ bool operator<(const ValueDurationFloatPair &p) const {
+ return value < p.value;
+ }
+};
+
+static double toSec(const RealTime &r)
+{
+ return r.sec + double(r.nsec) / 1000000000.0;
+}
+
+void
+PluginSummarisingAdapter::Impl::reduce()
+{
+ for (OutputSegmentAccumulatorMap::iterator i =
+ m_segmentedAccumulators.begin();
+ i != m_segmentedAccumulators.end(); ++i) {
+
+ int output = i->first;
+ SegmentAccumulatorMap &segments = i->second;
+
+ for (SegmentAccumulatorMap::iterator j = segments.begin();
+ j != segments.end(); ++j) {
+
+ RealTime segmentStart = j->first;
+ OutputAccumulator &accumulator = j->second;
+
+ int sz = accumulator.results.size();
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "reduce: segment starting at " << segmentStart
+ << " on output " << output << " has " << sz << " result(s)" << std::endl;
+#endif
+
+ double totalDuration = 0.0;
+ //!!! is this right?
+ if (sz > 0) {
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "last time = " << accumulator.results[sz-1].time
+ << ", duration = " << accumulator.results[sz-1].duration
+ << " (step = " << m_stepSize << ", block = " << m_blockSize << ")"
+ << std::endl;
+#endif
+ totalDuration = toSec((accumulator.results[sz-1].time +
+ accumulator.results[sz-1].duration) -
+ segmentStart);
+ }
+
+ for (int bin = 0; bin < accumulator.bins; ++bin) {
+
+ // work on all values over time for a single bin
+
+ OutputBinSummary summary;
+
+ summary.count = sz;
+
+ summary.minimum = 0.f;
+ summary.maximum = 0.f;
+
+ summary.median = 0.f;
+ summary.mode = 0.f;
+ summary.sum = 0.f;
+ summary.variance = 0.f;
+
+ summary.median_c = 0.f;
+ summary.mode_c = 0.f;
+ summary.mean_c = 0.f;
+ summary.variance_c = 0.f;
+
+ if (sz == 0) continue;
+
+ std::vector<ValueDurationFloatPair> valvec;
+
+ for (int k = 0; k < sz; ++k) {
+ while (int(accumulator.results[k].values.size()) <
+ accumulator.bins) {
+ accumulator.results[k].values.push_back(0.f);
+ }
+ }
+
+ for (int k = 0; k < sz; ++k) {
+ float value = accumulator.results[k].values[bin];
+ valvec.push_back(ValueDurationFloatPair
+ (value,
+ toSec(accumulator.results[k].duration)));
+ }
+
+ std::sort(valvec.begin(), valvec.end());
+
+ summary.minimum = valvec[0].value;
+ summary.maximum = valvec[sz-1].value;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "total duration = " << totalDuration << std::endl;
+#endif
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+/*
+ std::cerr << "value vector for medians:" << std::endl;
+ for (int k = 0; k < sz; ++k) {
+ std::cerr << "(" << valvec[k].value << "," << valvec[k].duration << ") ";
+ }
+ std::cerr << std::endl;
+*/
+#endif
+
+ if (sz % 2 == 1) {
+ summary.median = valvec[sz/2].value;
+ } else {
+ summary.median = (valvec[sz/2].value + valvec[sz/2 + 1].value) / 2;
+ }
+
+ double duracc = 0.0;
+ summary.median_c = valvec[sz-1].value;
+
+ for (int k = 0; k < sz; ++k) {
+ duracc += valvec[k].duration;
+ if (duracc > totalDuration/2) {
+ summary.median_c = valvec[k].value;
+ break;
+ }
+ }
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "median_c = " << summary.median_c << std::endl;
+ std::cerr << "median = " << summary.median << std::endl;
+#endif
+
+ std::map<float, int> distribution;
+
+ for (int k = 0; k < sz; ++k) {
+ summary.sum += accumulator.results[k].values[bin];
+ distribution[accumulator.results[k].values[bin]] += 1;
+ }
+
+ int md = 0;
+
+ for (std::map<float, int>::iterator di = distribution.begin();
+ di != distribution.end(); ++di) {
+ if (di->second > md) {
+ md = di->second;
+ summary.mode = di->first;
+ }
+ }
+
+ distribution.clear();
+
+ std::map<float, double> distribution_c;
+
+ for (int k = 0; k < sz; ++k) {
+ distribution_c[accumulator.results[k].values[bin]]
+ += toSec(accumulator.results[k].duration);
+ }
+
+ double mrd = 0.0;
+
+ for (std::map<float, double>::iterator di = distribution_c.begin();
+ di != distribution_c.end(); ++di) {
+ if (di->second > mrd) {
+ mrd = di->second;
+ summary.mode_c = di->first;
+ }
+ }
+
+ distribution_c.clear();
+
+ if (totalDuration > 0.0) {
+
+ double sum_c = 0.0;
+
+ for (int k = 0; k < sz; ++k) {
+ double value = accumulator.results[k].values[bin]
+ * toSec(accumulator.results[k].duration);
+ sum_c += value;
+ }
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "mean_c = " << sum_c << " / " << totalDuration << " = "
+ << sum_c / totalDuration << " (sz = " << sz << ")" << std::endl;
+#endif
+
+ summary.mean_c = sum_c / totalDuration;
+
+ for (int k = 0; k < sz; ++k) {
+ double value = accumulator.results[k].values[bin];
+// * toSec(accumulator.results[k].duration);
+ summary.variance_c +=
+ (value - summary.mean_c) * (value - summary.mean_c)
+ * toSec(accumulator.results[k].duration);
+ }
+
+// summary.variance_c /= summary.count;
+ summary.variance_c /= totalDuration;
+ }
+
+ double mean = summary.sum / summary.count;
+
+#ifdef DEBUG_PLUGIN_SUMMARISING_ADAPTER
+ std::cerr << "mean = " << summary.sum << " / " << summary.count << " = "
+ << summary.sum / summary.count << std::endl;
+#endif
+
+ for (int k = 0; k < sz; ++k) {
+ float value = accumulator.results[k].values[bin];
+ summary.variance += (value - mean) * (value - mean);
+ }
+ summary.variance /= summary.count;
+
+ m_summaries[output][segmentStart][bin] = summary;
+ }
+ }
+ }
+
+ m_segmentedAccumulators.clear();
+ m_accumulators.clear();
+}
+
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginSummarisingAdapter.cpp)
+
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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-hostsdk/PluginWrapper.h>
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginWrapper.cpp)
+
+namespace Vamp {
+
+namespace HostExt {
+
+class PluginRateExtractor : public Plugin
+{
+public:
+ PluginRateExtractor() : Plugin(0) { }
+ float getRate() const { return m_inputSampleRate; }
+};
+
+PluginWrapper::PluginWrapper(Plugin *plugin) :
+ Plugin(((PluginRateExtractor *)plugin)->getRate()),
+ m_plugin(plugin)
+{
+}
+
+PluginWrapper::~PluginWrapper()
+{
+ delete m_plugin;
+}
+
+bool
+PluginWrapper::initialise(size_t channels, size_t stepSize, size_t blockSize)
+{
+ return m_plugin->initialise(channels, stepSize, blockSize);
+}
+
+void
+PluginWrapper::reset()
+{
+ m_plugin->reset();
+}
+
+Plugin::InputDomain
+PluginWrapper::getInputDomain() const
+{
+ return m_plugin->getInputDomain();
+}
+
+unsigned int
+PluginWrapper::getVampApiVersion() const
+{
+ return m_plugin->getVampApiVersion();
+}
+
+std::string
+PluginWrapper::getIdentifier() const
+{
+ return m_plugin->getIdentifier();
+}
+
+std::string
+PluginWrapper::getName() const
+{
+ return m_plugin->getName();
+}
+
+std::string
+PluginWrapper::getDescription() const
+{
+ return m_plugin->getDescription();
+}
+
+std::string
+PluginWrapper::getMaker() const
+{
+ return m_plugin->getMaker();
+}
+
+int
+PluginWrapper::getPluginVersion() const
+{
+ return m_plugin->getPluginVersion();
+}
+
+std::string
+PluginWrapper::getCopyright() const
+{
+ return m_plugin->getCopyright();
+}
+
+PluginBase::ParameterList
+PluginWrapper::getParameterDescriptors() const
+{
+ return m_plugin->getParameterDescriptors();
+}
+
+float
+PluginWrapper::getParameter(std::string parameter) const
+{
+ return m_plugin->getParameter(parameter);
+}
+
+void
+PluginWrapper::setParameter(std::string parameter, float value)
+{
+ m_plugin->setParameter(parameter, value);
+}
+
+PluginBase::ProgramList
+PluginWrapper::getPrograms() const
+{
+ return m_plugin->getPrograms();
+}
+
+std::string
+PluginWrapper::getCurrentProgram() const
+{
+ return m_plugin->getCurrentProgram();
+}
+
+void
+PluginWrapper::selectProgram(std::string program)
+{
+ m_plugin->selectProgram(program);
+}
+
+size_t
+PluginWrapper::getPreferredStepSize() const
+{
+ return m_plugin->getPreferredStepSize();
+}
+
+size_t
+PluginWrapper::getPreferredBlockSize() const
+{
+ return m_plugin->getPreferredBlockSize();
+}
+
+size_t
+PluginWrapper::getMinChannelCount() const
+{
+ return m_plugin->getMinChannelCount();
+}
+
+size_t PluginWrapper::getMaxChannelCount() const
+{
+ return m_plugin->getMaxChannelCount();
+}
+
+Plugin::OutputList
+PluginWrapper::getOutputDescriptors() const
+{
+ return m_plugin->getOutputDescriptors();
+}
+
+Plugin::FeatureSet
+PluginWrapper::process(const float *const *inputBuffers, RealTime timestamp)
+{
+ return m_plugin->process(inputBuffers, timestamp);
+}
+
+Plugin::FeatureSet
+PluginWrapper::getRemainingFeatures()
+{
+ return m_plugin->getRemainingFeatures();
+}
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginWrapper.cpp)
--- /dev/null
+/* -*- 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-hostsdk/RealTime.h>
+#include "../vamp-sdk/RealTime.cpp"
+
--- /dev/null
+/* -*- 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-sdk/PluginAdapter.h>
+
+#include <cstring>
+#include <cstdlib>
+
+#if ( VAMP_SDK_MAJOR_VERSION != 2 || VAMP_SDK_MINOR_VERSION != 0 )
+#error Incorrect Vamp SDK header included (not the expected 2.0 SDK)
+#endif
+
+
+//#define DEBUG_PLUGIN_ADAPTER 1
+
+_VAMP_SDK_PLUGSPACE_BEGIN(PluginAdapter.cpp)
+
+namespace Vamp {
+
+class PluginAdapterBase::Impl
+{
+public:
+ Impl(PluginAdapterBase *);
+ ~Impl();
+
+ const VampPluginDescriptor *getDescriptor();
+
+protected:
+ PluginAdapterBase *m_base;
+
+ static VampPluginHandle vampInstantiate(const VampPluginDescriptor *desc,
+ float inputSampleRate);
+
+ static void vampCleanup(VampPluginHandle handle);
+
+ static int vampInitialise(VampPluginHandle handle, unsigned int channels,
+ unsigned int stepSize, unsigned int blockSize);
+
+ static void vampReset(VampPluginHandle handle);
+
+ static float vampGetParameter(VampPluginHandle handle, int param);
+ static void vampSetParameter(VampPluginHandle handle, int param, float value);
+
+ static unsigned int vampGetCurrentProgram(VampPluginHandle handle);
+ static void vampSelectProgram(VampPluginHandle handle, unsigned int program);
+
+ static unsigned int vampGetPreferredStepSize(VampPluginHandle handle);
+ static unsigned int vampGetPreferredBlockSize(VampPluginHandle handle);
+ static unsigned int vampGetMinChannelCount(VampPluginHandle handle);
+ static unsigned int vampGetMaxChannelCount(VampPluginHandle handle);
+
+ static unsigned int vampGetOutputCount(VampPluginHandle handle);
+
+ static VampOutputDescriptor *vampGetOutputDescriptor(VampPluginHandle handle,
+ unsigned int i);
+
+ static void vampReleaseOutputDescriptor(VampOutputDescriptor *desc);
+
+ static VampFeatureList *vampProcess(VampPluginHandle handle,
+ const float *const *inputBuffers,
+ int sec,
+ int nsec);
+
+ static VampFeatureList *vampGetRemainingFeatures(VampPluginHandle handle);
+
+ static void vampReleaseFeatureSet(VampFeatureList *fs);
+
+ void checkOutputMap(Plugin *plugin);
+ void markOutputsChanged(Plugin *plugin);
+
+ void cleanup(Plugin *plugin);
+ unsigned int getOutputCount(Plugin *plugin);
+ VampOutputDescriptor *getOutputDescriptor(Plugin *plugin,
+ unsigned int i);
+ VampFeatureList *process(Plugin *plugin,
+ const float *const *inputBuffers,
+ int sec, int nsec);
+ VampFeatureList *getRemainingFeatures(Plugin *plugin);
+ VampFeatureList *convertFeatures(Plugin *plugin,
+ const Plugin::FeatureSet &features);
+
+ // maps both plugins and descriptors to adapters
+ typedef std::map<const void *, Impl *> AdapterMap;
+ static AdapterMap *m_adapterMap;
+ static Impl *lookupAdapter(VampPluginHandle);
+
+ bool m_populated;
+ VampPluginDescriptor m_descriptor;
+ Plugin::ParameterList m_parameters;
+ Plugin::ProgramList m_programs;
+
+ typedef std::map<Plugin *, Plugin::OutputList *> OutputMap;
+ OutputMap m_pluginOutputs;
+
+ std::map<Plugin *, VampFeatureList *> m_fs;
+ std::map<Plugin *, std::vector<size_t> > m_fsizes;
+ std::map<Plugin *, std::vector<std::vector<size_t> > > m_fvsizes;
+ void resizeFS(Plugin *plugin, int n);
+ void resizeFL(Plugin *plugin, int n, size_t sz);
+ void resizeFV(Plugin *plugin, int n, int j, size_t sz);
+};
+
+PluginAdapterBase::PluginAdapterBase()
+{
+ m_impl = new Impl(this);
+}
+
+PluginAdapterBase::~PluginAdapterBase()
+{
+ delete m_impl;
+}
+
+const VampPluginDescriptor *
+PluginAdapterBase::getDescriptor()
+{
+ return m_impl->getDescriptor();
+}
+
+PluginAdapterBase::Impl::Impl(PluginAdapterBase *base) :
+ m_base(base),
+ m_populated(false)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl[" << this << "]::Impl" << std::endl;
+#endif
+}
+
+const VampPluginDescriptor *
+PluginAdapterBase::Impl::getDescriptor()
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl[" << this << "]::getDescriptor" << std::endl;
+#endif
+
+ if (m_populated) return &m_descriptor;
+
+ Plugin *plugin = m_base->createPlugin(48000);
+
+ if (plugin->getVampApiVersion() != VAMP_API_VERSION) {
+ std::cerr << "Vamp::PluginAdapterBase::Impl::getDescriptor: ERROR: "
+ << "API version " << plugin->getVampApiVersion()
+ << " for\nplugin \"" << plugin->getIdentifier() << "\" "
+ << "differs from version "
+ << VAMP_API_VERSION << " for adapter.\n"
+ << "This plugin is probably linked against a different version of the Vamp SDK\n"
+ << "from the version it was compiled with. It will need to be re-linked correctly\n"
+ << "before it can be used." << std::endl;
+ delete plugin;
+ return 0;
+ }
+
+ m_parameters = plugin->getParameterDescriptors();
+ m_programs = plugin->getPrograms();
+
+ m_descriptor.vampApiVersion = plugin->getVampApiVersion();
+ m_descriptor.identifier = strdup(plugin->getIdentifier().c_str());
+ m_descriptor.name = strdup(plugin->getName().c_str());
+ m_descriptor.description = strdup(plugin->getDescription().c_str());
+ m_descriptor.maker = strdup(plugin->getMaker().c_str());
+ m_descriptor.pluginVersion = plugin->getPluginVersion();
+ m_descriptor.copyright = strdup(plugin->getCopyright().c_str());
+
+ m_descriptor.parameterCount = m_parameters.size();
+ m_descriptor.parameters = (const VampParameterDescriptor **)
+ malloc(m_parameters.size() * sizeof(VampParameterDescriptor));
+
+ unsigned int i;
+
+ for (i = 0; i < m_parameters.size(); ++i) {
+ VampParameterDescriptor *desc = (VampParameterDescriptor *)
+ malloc(sizeof(VampParameterDescriptor));
+ desc->identifier = strdup(m_parameters[i].identifier.c_str());
+ desc->name = strdup(m_parameters[i].name.c_str());
+ desc->description = strdup(m_parameters[i].description.c_str());
+ desc->unit = strdup(m_parameters[i].unit.c_str());
+ desc->minValue = m_parameters[i].minValue;
+ desc->maxValue = m_parameters[i].maxValue;
+ desc->defaultValue = m_parameters[i].defaultValue;
+ desc->isQuantized = m_parameters[i].isQuantized;
+ desc->quantizeStep = m_parameters[i].quantizeStep;
+ desc->valueNames = 0;
+ if (desc->isQuantized && !m_parameters[i].valueNames.empty()) {
+ desc->valueNames = (const char **)
+ malloc((m_parameters[i].valueNames.size()+1) * sizeof(char *));
+ for (unsigned int j = 0; j < m_parameters[i].valueNames.size(); ++j) {
+ desc->valueNames[j] = strdup(m_parameters[i].valueNames[j].c_str());
+ }
+ desc->valueNames[m_parameters[i].valueNames.size()] = 0;
+ }
+ m_descriptor.parameters[i] = desc;
+ }
+
+ m_descriptor.programCount = m_programs.size();
+ m_descriptor.programs = (const char **)
+ malloc(m_programs.size() * sizeof(const char *));
+
+ for (i = 0; i < m_programs.size(); ++i) {
+ m_descriptor.programs[i] = strdup(m_programs[i].c_str());
+ }
+
+ if (plugin->getInputDomain() == Plugin::FrequencyDomain) {
+ m_descriptor.inputDomain = vampFrequencyDomain;
+ } else {
+ m_descriptor.inputDomain = vampTimeDomain;
+ }
+
+ m_descriptor.instantiate = vampInstantiate;
+ m_descriptor.cleanup = vampCleanup;
+ m_descriptor.initialise = vampInitialise;
+ m_descriptor.reset = vampReset;
+ m_descriptor.getParameter = vampGetParameter;
+ m_descriptor.setParameter = vampSetParameter;
+ m_descriptor.getCurrentProgram = vampGetCurrentProgram;
+ m_descriptor.selectProgram = vampSelectProgram;
+ m_descriptor.getPreferredStepSize = vampGetPreferredStepSize;
+ m_descriptor.getPreferredBlockSize = vampGetPreferredBlockSize;
+ m_descriptor.getMinChannelCount = vampGetMinChannelCount;
+ m_descriptor.getMaxChannelCount = vampGetMaxChannelCount;
+ m_descriptor.getOutputCount = vampGetOutputCount;
+ m_descriptor.getOutputDescriptor = vampGetOutputDescriptor;
+ m_descriptor.releaseOutputDescriptor = vampReleaseOutputDescriptor;
+ m_descriptor.process = vampProcess;
+ m_descriptor.getRemainingFeatures = vampGetRemainingFeatures;
+ m_descriptor.releaseFeatureSet = vampReleaseFeatureSet;
+
+ if (!m_adapterMap) {
+ m_adapterMap = new AdapterMap;
+ }
+ (*m_adapterMap)[&m_descriptor] = this;
+
+ delete plugin;
+
+ m_populated = true;
+ return &m_descriptor;
+}
+
+PluginAdapterBase::Impl::~Impl()
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl[" << this << "]::~Impl" << std::endl;
+#endif
+
+ if (!m_populated) return;
+
+ free((void *)m_descriptor.identifier);
+ free((void *)m_descriptor.name);
+ free((void *)m_descriptor.description);
+ free((void *)m_descriptor.maker);
+ free((void *)m_descriptor.copyright);
+
+ for (unsigned int i = 0; i < m_descriptor.parameterCount; ++i) {
+ const VampParameterDescriptor *desc = m_descriptor.parameters[i];
+ free((void *)desc->identifier);
+ free((void *)desc->name);
+ free((void *)desc->description);
+ free((void *)desc->unit);
+ if (desc->valueNames) {
+ for (unsigned int j = 0; desc->valueNames[j]; ++j) {
+ free((void *)desc->valueNames[j]);
+ }
+ free((void *)desc->valueNames);
+ }
+ }
+ free((void *)m_descriptor.parameters);
+
+ for (unsigned int i = 0; i < m_descriptor.programCount; ++i) {
+ free((void *)m_descriptor.programs[i]);
+ }
+ free((void *)m_descriptor.programs);
+
+ if (m_adapterMap) {
+
+ m_adapterMap->erase(&m_descriptor);
+
+ if (m_adapterMap->empty()) {
+ delete m_adapterMap;
+ m_adapterMap = 0;
+ }
+ }
+}
+
+PluginAdapterBase::Impl *
+PluginAdapterBase::Impl::lookupAdapter(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::lookupAdapter(" << handle << ")" << std::endl;
+#endif
+
+ if (!m_adapterMap) return 0;
+ AdapterMap::const_iterator i = m_adapterMap->find(handle);
+ if (i == m_adapterMap->end()) return 0;
+ return i->second;
+}
+
+VampPluginHandle
+PluginAdapterBase::Impl::vampInstantiate(const VampPluginDescriptor *desc,
+ float inputSampleRate)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << ")" << std::endl;
+#endif
+
+ if (!m_adapterMap) {
+ m_adapterMap = new AdapterMap();
+ }
+
+ if (m_adapterMap->find(desc) == m_adapterMap->end()) {
+ std::cerr << "WARNING: PluginAdapterBase::Impl::vampInstantiate: Descriptor " << desc << " not in adapter map" << std::endl;
+ return 0;
+ }
+
+ Impl *adapter = (*m_adapterMap)[desc];
+ if (desc != &adapter->m_descriptor) return 0;
+
+ Plugin *plugin = adapter->m_base->createPlugin(inputSampleRate);
+ if (plugin) {
+ (*m_adapterMap)[plugin] = adapter;
+ }
+
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampInstantiate(" << desc << "): returning handle " << plugin << std::endl;
+#endif
+
+ return plugin;
+}
+
+void
+PluginAdapterBase::Impl::vampCleanup(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampCleanup(" << handle << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) {
+ delete ((Plugin *)handle);
+ return;
+ }
+ adapter->cleanup(((Plugin *)handle));
+}
+
+int
+PluginAdapterBase::Impl::vampInitialise(VampPluginHandle handle,
+ unsigned int channels,
+ unsigned int stepSize,
+ unsigned int blockSize)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampInitialise(" << handle << ", " << channels << ", " << stepSize << ", " << blockSize << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return 0;
+ bool result = ((Plugin *)handle)->initialise(channels, stepSize, blockSize);
+ adapter->markOutputsChanged((Plugin *)handle);
+ return result ? 1 : 0;
+}
+
+void
+PluginAdapterBase::Impl::vampReset(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampReset(" << handle << ")" << std::endl;
+#endif
+
+ ((Plugin *)handle)->reset();
+}
+
+float
+PluginAdapterBase::Impl::vampGetParameter(VampPluginHandle handle,
+ int param)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetParameter(" << handle << ", " << param << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return 0.0;
+ Plugin::ParameterList &list = adapter->m_parameters;
+ return ((Plugin *)handle)->getParameter(list[param].identifier);
+}
+
+void
+PluginAdapterBase::Impl::vampSetParameter(VampPluginHandle handle,
+ int param, float value)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampSetParameter(" << handle << ", " << param << ", " << value << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return;
+ Plugin::ParameterList &list = adapter->m_parameters;
+ ((Plugin *)handle)->setParameter(list[param].identifier, value);
+ adapter->markOutputsChanged((Plugin *)handle);
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetCurrentProgram(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetCurrentProgram(" << handle << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return 0;
+ Plugin::ProgramList &list = adapter->m_programs;
+ std::string program = ((Plugin *)handle)->getCurrentProgram();
+ for (unsigned int i = 0; i < list.size(); ++i) {
+ if (list[i] == program) return i;
+ }
+ return 0;
+}
+
+void
+PluginAdapterBase::Impl::vampSelectProgram(VampPluginHandle handle,
+ unsigned int program)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampSelectProgram(" << handle << ", " << program << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return;
+
+ Plugin::ProgramList &list = adapter->m_programs;
+ ((Plugin *)handle)->selectProgram(list[program]);
+
+ adapter->markOutputsChanged((Plugin *)handle);
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetPreferredStepSize(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetPreferredStepSize(" << handle << ")" << std::endl;
+#endif
+
+ return ((Plugin *)handle)->getPreferredStepSize();
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetPreferredBlockSize(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetPreferredBlockSize(" << handle << ")" << std::endl;
+#endif
+
+ return ((Plugin *)handle)->getPreferredBlockSize();
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetMinChannelCount(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetMinChannelCount(" << handle << ")" << std::endl;
+#endif
+
+ return ((Plugin *)handle)->getMinChannelCount();
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetMaxChannelCount(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetMaxChannelCount(" << handle << ")" << std::endl;
+#endif
+
+ return ((Plugin *)handle)->getMaxChannelCount();
+}
+
+unsigned int
+PluginAdapterBase::Impl::vampGetOutputCount(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetOutputCount(" << handle << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+
+// std::cerr << "vampGetOutputCount: handle " << handle << " -> adapter "<< adapter << std::endl;
+
+ if (!adapter) return 0;
+ return adapter->getOutputCount((Plugin *)handle);
+}
+
+VampOutputDescriptor *
+PluginAdapterBase::Impl::vampGetOutputDescriptor(VampPluginHandle handle,
+ unsigned int i)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetOutputDescriptor(" << handle << ", " << i << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+
+// std::cerr << "vampGetOutputDescriptor: handle " << handle << " -> adapter "<< adapter << std::endl;
+
+ if (!adapter) return 0;
+ return adapter->getOutputDescriptor((Plugin *)handle, i);
+}
+
+void
+PluginAdapterBase::Impl::vampReleaseOutputDescriptor(VampOutputDescriptor *desc)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampReleaseOutputDescriptor(" << desc << ")" << std::endl;
+#endif
+
+ if (desc->identifier) free((void *)desc->identifier);
+ if (desc->name) free((void *)desc->name);
+ if (desc->description) free((void *)desc->description);
+ if (desc->unit) free((void *)desc->unit);
+ if (desc->hasFixedBinCount && desc->binNames) {
+ for (unsigned int i = 0; i < desc->binCount; ++i) {
+ if (desc->binNames[i]) {
+ free((void *)desc->binNames[i]);
+ }
+ }
+ }
+ if (desc->binNames) free((void *)desc->binNames);
+ free((void *)desc);
+}
+
+VampFeatureList *
+PluginAdapterBase::Impl::vampProcess(VampPluginHandle handle,
+ const float *const *inputBuffers,
+ int sec,
+ int nsec)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampProcess(" << handle << ", " << sec << ", " << nsec << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return 0;
+ return adapter->process((Plugin *)handle, inputBuffers, sec, nsec);
+}
+
+VampFeatureList *
+PluginAdapterBase::Impl::vampGetRemainingFeatures(VampPluginHandle handle)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampGetRemainingFeatures(" << handle << ")" << std::endl;
+#endif
+
+ Impl *adapter = lookupAdapter(handle);
+ if (!adapter) return 0;
+ return adapter->getRemainingFeatures((Plugin *)handle);
+}
+
+void
+PluginAdapterBase::Impl::vampReleaseFeatureSet(VampFeatureList *fs)
+{
+#ifdef DEBUG_PLUGIN_ADAPTER
+ std::cerr << "PluginAdapterBase::Impl::vampReleaseFeatureSet" << std::endl;
+#endif
+}
+
+void
+PluginAdapterBase::Impl::cleanup(Plugin *plugin)
+{
+ if (m_fs.find(plugin) != m_fs.end()) {
+ size_t outputCount = 0;
+ if (m_pluginOutputs[plugin]) {
+ outputCount = m_pluginOutputs[plugin]->size();
+ }
+ VampFeatureList *list = m_fs[plugin];
+ for (unsigned int i = 0; i < outputCount; ++i) {
+ for (unsigned int j = 0; j < m_fsizes[plugin][i]; ++j) {
+ if (list[i].features[j].v1.label) {
+ free(list[i].features[j].v1.label);
+ }
+ if (list[i].features[j].v1.values) {
+ free(list[i].features[j].v1.values);
+ }
+ }
+ if (list[i].features) free(list[i].features);
+ }
+ m_fs.erase(plugin);
+ m_fsizes.erase(plugin);
+ m_fvsizes.erase(plugin);
+ }
+
+ if (m_pluginOutputs.find(plugin) != m_pluginOutputs.end()) {
+ delete m_pluginOutputs[plugin];
+ m_pluginOutputs.erase(plugin);
+ }
+
+ if (m_adapterMap) {
+ m_adapterMap->erase(plugin);
+
+ if (m_adapterMap->empty()) {
+ delete m_adapterMap;
+ m_adapterMap = 0;
+ }
+ }
+
+ delete ((Plugin *)plugin);
+}
+
+void
+PluginAdapterBase::Impl::checkOutputMap(Plugin *plugin)
+{
+ OutputMap::iterator i = m_pluginOutputs.find(plugin);
+
+ if (i == m_pluginOutputs.end() || !i->second) {
+
+ m_pluginOutputs[plugin] = new Plugin::OutputList
+ (plugin->getOutputDescriptors());
+
+// std::cerr << "PluginAdapterBase::Impl::checkOutputMap: Have " << m_pluginOutputs[plugin]->size() << " outputs for plugin " << plugin->getIdentifier() << std::endl;
+ }
+}
+
+void
+PluginAdapterBase::Impl::markOutputsChanged(Plugin *plugin)
+{
+ OutputMap::iterator i = m_pluginOutputs.find(plugin);
+
+// std::cerr << "PluginAdapterBase::Impl::markOutputsChanged" << std::endl;
+
+ if (i != m_pluginOutputs.end()) {
+
+ Plugin::OutputList *list = i->second;
+ m_pluginOutputs.erase(i);
+ delete list;
+ }
+}
+
+unsigned int
+PluginAdapterBase::Impl::getOutputCount(Plugin *plugin)
+{
+ checkOutputMap(plugin);
+
+ return m_pluginOutputs[plugin]->size();
+}
+
+VampOutputDescriptor *
+PluginAdapterBase::Impl::getOutputDescriptor(Plugin *plugin,
+ unsigned int i)
+{
+ checkOutputMap(plugin);
+
+ Plugin::OutputDescriptor &od =
+ (*m_pluginOutputs[plugin])[i];
+
+ VampOutputDescriptor *desc = (VampOutputDescriptor *)
+ malloc(sizeof(VampOutputDescriptor));
+
+ desc->identifier = strdup(od.identifier.c_str());
+ desc->name = strdup(od.name.c_str());
+ desc->description = strdup(od.description.c_str());
+ desc->unit = strdup(od.unit.c_str());
+ desc->hasFixedBinCount = od.hasFixedBinCount;
+ desc->binCount = od.binCount;
+
+ if (od.hasFixedBinCount && od.binCount > 0
+ // We would like to do "&& !od.binNames.empty()" here -- but we
+ // can't, because it will crash older versions of the host adapter
+ // which try to copy the names across whenever the bin count is
+ // non-zero, regardless of whether they exist or not
+ ) {
+ desc->binNames = (const char **)
+ malloc(od.binCount * sizeof(const char *));
+
+ for (unsigned int i = 0; i < od.binCount; ++i) {
+ if (i < od.binNames.size()) {
+ desc->binNames[i] = strdup(od.binNames[i].c_str());
+ } else {
+ desc->binNames[i] = 0;
+ }
+ }
+ } else {
+ desc->binNames = 0;
+ }
+
+ desc->hasKnownExtents = od.hasKnownExtents;
+ desc->minValue = od.minValue;
+ desc->maxValue = od.maxValue;
+ desc->isQuantized = od.isQuantized;
+ desc->quantizeStep = od.quantizeStep;
+
+ switch (od.sampleType) {
+ case Plugin::OutputDescriptor::OneSamplePerStep:
+ desc->sampleType = vampOneSamplePerStep; break;
+ case Plugin::OutputDescriptor::FixedSampleRate:
+ desc->sampleType = vampFixedSampleRate; break;
+ case Plugin::OutputDescriptor::VariableSampleRate:
+ desc->sampleType = vampVariableSampleRate; break;
+ }
+
+ desc->sampleRate = od.sampleRate;
+ desc->hasDuration = od.hasDuration;
+
+ return desc;
+}
+
+VampFeatureList *
+PluginAdapterBase::Impl::process(Plugin *plugin,
+ const float *const *inputBuffers,
+ int sec, int nsec)
+{
+// std::cerr << "PluginAdapterBase::Impl::process" << std::endl;
+ RealTime rt(sec, nsec);
+ checkOutputMap(plugin);
+ return convertFeatures(plugin, plugin->process(inputBuffers, rt));
+}
+
+VampFeatureList *
+PluginAdapterBase::Impl::getRemainingFeatures(Plugin *plugin)
+{
+// std::cerr << "PluginAdapterBase::Impl::getRemainingFeatures" << std::endl;
+ checkOutputMap(plugin);
+ return convertFeatures(plugin, plugin->getRemainingFeatures());
+}
+
+VampFeatureList *
+PluginAdapterBase::Impl::convertFeatures(Plugin *plugin,
+ const Plugin::FeatureSet &features)
+{
+ int lastN = -1;
+
+ int outputCount = 0;
+ if (m_pluginOutputs[plugin]) outputCount = m_pluginOutputs[plugin]->size();
+
+ resizeFS(plugin, outputCount);
+ VampFeatureList *fs = m_fs[plugin];
+
+// std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: sizeof(Feature) == " << sizeof(Plugin::Feature) << ", sizeof(VampFeature) == " << sizeof(VampFeature) << ", sizeof(VampFeatureList) == " << sizeof(VampFeatureList) << std::endl;
+
+ for (Plugin::FeatureSet::const_iterator fi = features.begin();
+ fi != features.end(); ++fi) {
+
+ int n = fi->first;
+
+// std::cerr << "PluginAdapterBase::Impl::convertFeatures: n = " << n << std::endl;
+
+ if (n >= int(outputCount)) {
+ std::cerr << "WARNING: PluginAdapterBase::Impl::convertFeatures: Too many outputs from plugin (" << n+1 << ", only should be " << outputCount << ")" << std::endl;
+ continue;
+ }
+
+ if (n > lastN + 1) {
+ for (int i = lastN + 1; i < n; ++i) {
+ fs[i].featureCount = 0;
+ }
+ }
+
+ const Plugin::FeatureList &fl = fi->second;
+
+ size_t sz = fl.size();
+ if (sz > m_fsizes[plugin][n]) resizeFL(plugin, n, sz);
+ fs[n].featureCount = sz;
+
+ for (size_t j = 0; j < sz; ++j) {
+
+// std::cerr << "PluginAdapterBase::Impl::convertFeatures: j = " << j << std::endl;
+
+ VampFeature *feature = &fs[n].features[j].v1;
+
+ feature->hasTimestamp = fl[j].hasTimestamp;
+ feature->sec = fl[j].timestamp.sec;
+ feature->nsec = fl[j].timestamp.nsec;
+ feature->valueCount = fl[j].values.size();
+
+ VampFeatureV2 *v2 = &fs[n].features[j + sz].v2;
+
+ v2->hasDuration = fl[j].hasDuration;
+ v2->durationSec = fl[j].duration.sec;
+ v2->durationNsec = fl[j].duration.nsec;
+
+ if (feature->label) free(feature->label);
+
+ if (fl[j].label.empty()) {
+ feature->label = 0;
+ } else {
+ feature->label = strdup(fl[j].label.c_str());
+ }
+
+ if (feature->valueCount > m_fvsizes[plugin][n][j]) {
+ resizeFV(plugin, n, j, feature->valueCount);
+ }
+
+ for (unsigned int k = 0; k < feature->valueCount; ++k) {
+// std::cerr << "PluginAdapterBase::Impl::convertFeatures: k = " << k << std::endl;
+ feature->values[k] = fl[j].values[k];
+ }
+ }
+
+ lastN = n;
+ }
+
+ if (lastN == -1) return 0;
+
+ if (int(outputCount) > lastN + 1) {
+ for (int i = lastN + 1; i < int(outputCount); ++i) {
+ fs[i].featureCount = 0;
+ }
+ }
+
+// std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: have " << outputCount << " outputs" << std::endl;
+// for (int i = 0; i < outputCount; ++i) {
+// std::cerr << "PluginAdapter(v2)::convertFeatures: NOTE: output " << i << " has " << fs[i].featureCount << " features" << std::endl;
+// }
+
+
+ return fs;
+}
+
+void
+PluginAdapterBase::Impl::resizeFS(Plugin *plugin, int n)
+{
+// std::cerr << "PluginAdapterBase::Impl::resizeFS(" << plugin << ", " << n << ")" << std::endl;
+
+ int i = m_fsizes[plugin].size();
+ if (i >= n) return;
+
+// std::cerr << "resizing from " << i << std::endl;
+
+ m_fs[plugin] = (VampFeatureList *)realloc
+ (m_fs[plugin], n * sizeof(VampFeatureList));
+
+ while (i < n) {
+ m_fs[plugin][i].featureCount = 0;
+ m_fs[plugin][i].features = 0;
+ m_fsizes[plugin].push_back(0);
+ m_fvsizes[plugin].push_back(std::vector<size_t>());
+ i++;
+ }
+}
+
+void
+PluginAdapterBase::Impl::resizeFL(Plugin *plugin, int n, size_t sz)
+{
+// std::cerr << "PluginAdapterBase::Impl::resizeFL(" << plugin << ", " << n << ", "
+// << sz << ")" << std::endl;
+
+ size_t i = m_fsizes[plugin][n];
+ if (i >= sz) return;
+
+// std::cerr << "resizing from " << i << std::endl;
+
+ m_fs[plugin][n].features = (VampFeatureUnion *)realloc
+ (m_fs[plugin][n].features, 2 * sz * sizeof(VampFeatureUnion));
+
+ while (m_fsizes[plugin][n] < sz) {
+ m_fs[plugin][n].features[m_fsizes[plugin][n]].v1.hasTimestamp = 0;
+ m_fs[plugin][n].features[m_fsizes[plugin][n]].v1.valueCount = 0;
+ m_fs[plugin][n].features[m_fsizes[plugin][n]].v1.values = 0;
+ m_fs[plugin][n].features[m_fsizes[plugin][n]].v1.label = 0;
+ m_fs[plugin][n].features[m_fsizes[plugin][n] + sz].v2.hasDuration = 0;
+ m_fvsizes[plugin][n].push_back(0);
+ m_fsizes[plugin][n]++;
+ }
+}
+
+void
+PluginAdapterBase::Impl::resizeFV(Plugin *plugin, int n, int j, size_t sz)
+{
+// std::cerr << "PluginAdapterBase::Impl::resizeFV(" << plugin << ", " << n << ", "
+// << j << ", " << sz << ")" << std::endl;
+
+ size_t i = m_fvsizes[plugin][n][j];
+ if (i >= sz) return;
+
+// std::cerr << "resizing from " << i << std::endl;
+
+ m_fs[plugin][n].features[j].v1.values = (float *)realloc
+ (m_fs[plugin][n].features[j].v1.values, sz * sizeof(float));
+
+ m_fvsizes[plugin][n][j] = sz;
+}
+
+PluginAdapterBase::Impl::AdapterMap *
+PluginAdapterBase::Impl::m_adapterMap = 0;
+
+}
+
+_VAMP_SDK_PLUGSPACE_END(PluginAdapter.cpp)
+
--- /dev/null
+/* -*- 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.
+*/
+
+/*
+ This is a modified version of a source file from the
+ Rosegarden MIDI and audio sequencer and notation editor.
+ This file copyright 2000-2006 Chris Cannam.
+ Relicensed by the author as detailed above.
+*/
+
+#include <iostream>
+
+#if (__GNUC__ < 3)
+#include <strstream>
+#define stringstream strstream
+#else
+#include <sstream>
+#endif
+
+using std::cerr;
+using std::endl;
+
+#ifndef _WIN32
+#include <sys/time.h>
+#endif
+
+#include <vamp-sdk/RealTime.h>
+
+_VAMP_SDK_PLUGSPACE_BEGIN(RealTime.cpp)
+
+namespace Vamp {
+
+// A RealTime consists of two ints that must be at least 32 bits each.
+// A signed 32-bit int can store values exceeding +/- 2 billion. This
+// means we can safely use our lower int for nanoseconds, as there are
+// 1 billion nanoseconds in a second and we need to handle double that
+// because of the implementations of addition etc that we use.
+//
+// The maximum valid RealTime on a 32-bit system is somewhere around
+// 68 years: 999999999 nanoseconds longer than the classic Unix epoch.
+
+#define ONE_BILLION 1000000000
+
+RealTime::RealTime(int s, int n) :
+ sec(s), nsec(n)
+{
+ if (sec == 0) {
+ while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
+ while (nsec >= ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
+ } else if (sec < 0) {
+ while (nsec <= -ONE_BILLION) { nsec += ONE_BILLION; --sec; }
+ while (nsec > 0) { nsec -= ONE_BILLION; ++sec; }
+ } else {
+ while (nsec >= ONE_BILLION) { nsec -= ONE_BILLION; ++sec; }
+ while (nsec < 0) { nsec += ONE_BILLION; --sec; }
+ }
+}
+
+RealTime
+RealTime::fromSeconds(double sec)
+{
+ return RealTime(int(sec), int((sec - int(sec)) * ONE_BILLION + 0.5));
+}
+
+RealTime
+RealTime::fromMilliseconds(int msec)
+{
+ return RealTime(msec / 1000, (msec % 1000) * 1000000);
+}
+
+#ifndef _WIN32
+RealTime
+RealTime::fromTimeval(const struct timeval &tv)
+{
+ return RealTime(tv.tv_sec, tv.tv_usec * 1000);
+}
+#endif
+
+std::ostream &operator<<(std::ostream &out, const RealTime &rt)
+{
+ if (rt < RealTime::zeroTime) {
+ out << "-";
+ } else {
+ out << " ";
+ }
+
+ int s = (rt.sec < 0 ? -rt.sec : rt.sec);
+ int n = (rt.nsec < 0 ? -rt.nsec : rt.nsec);
+
+ out << s << ".";
+
+ int nn(n);
+ if (nn == 0) out << "00000000";
+ else while (nn < (ONE_BILLION / 10)) {
+ out << "0";
+ nn *= 10;
+ }
+
+ out << n << "R";
+ return out;
+}
+
+std::string
+RealTime::toString() const
+{
+ std::stringstream out;
+ out << *this;
+
+#if (__GNUC__ < 3)
+ out << std::ends;
+#endif
+
+ std::string s = out.str();
+
+ // remove trailing R
+ return s.substr(0, s.length() - 1);
+}
+
+std::string
+RealTime::toText(bool fixedDp) const
+{
+ if (*this < RealTime::zeroTime) return "-" + (-*this).toText();
+
+ std::stringstream out;
+
+ if (sec >= 3600) {
+ out << (sec / 3600) << ":";
+ }
+
+ if (sec >= 60) {
+ out << (sec % 3600) / 60 << ":";
+ }
+
+ if (sec >= 10) {
+ out << ((sec % 60) / 10);
+ }
+
+ out << (sec % 10);
+
+ int ms = msec();
+
+ if (ms != 0) {
+ out << ".";
+ out << (ms / 100);
+ ms = ms % 100;
+ if (ms != 0) {
+ out << (ms / 10);
+ ms = ms % 10;
+ } else if (fixedDp) {
+ out << "0";
+ }
+ if (ms != 0) {
+ out << ms;
+ } else if (fixedDp) {
+ out << "0";
+ }
+ } else if (fixedDp) {
+ out << ".000";
+ }
+
+#if (__GNUC__ < 3)
+ out << std::ends;
+#endif
+
+ std::string s = out.str();
+
+ return s;
+}
+
+
+RealTime
+RealTime::operator/(int d) const
+{
+ int secdiv = sec / d;
+ int secrem = sec % d;
+
+ double nsecdiv = (double(nsec) + ONE_BILLION * double(secrem)) / d;
+
+ return RealTime(secdiv, int(nsecdiv + 0.5));
+}
+
+double
+RealTime::operator/(const RealTime &r) const
+{
+ double lTotal = double(sec) * ONE_BILLION + double(nsec);
+ double rTotal = double(r.sec) * ONE_BILLION + double(r.nsec);
+
+ if (rTotal == 0) return 0.0;
+ else return lTotal/rTotal;
+}
+
+long
+RealTime::realTime2Frame(const RealTime &time, unsigned int sampleRate)
+{
+ if (time < zeroTime) return -realTime2Frame(-time, sampleRate);
+ double s = time.sec + double(time.nsec + 1) / 1000000000.0;
+ return long(s * sampleRate);
+}
+
+RealTime
+RealTime::frame2RealTime(long frame, unsigned int sampleRate)
+{
+ if (frame < 0) return -frame2RealTime(-frame, sampleRate);
+
+ RealTime rt;
+ rt.sec = frame / long(sampleRate);
+ frame -= rt.sec * long(sampleRate);
+ rt.nsec = (int)(((double(frame) * 1000000.0) / sampleRate) * 1000.0);
+ return rt;
+}
+
+const RealTime RealTime::zeroTime(0,0);
+
+}
+
+_VAMP_SDK_PLUGSPACE_END(RealTime.cpp)
+
+
+
--- /dev/null
+/* -*- 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 _VAMP_HOSTSDK_PLUGIN_H_
+#define _VAMP_HOSTSDK_PLUGIN_H_
+
+// Do not include vamp-sdk/Plugin.h directly from host code. Always
+// use this header instead.
+
+#include "hostguard.h"
+
+#include <vamp-sdk/Plugin.h>
+
+#endif
--- /dev/null
+/* -*- 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 _VAMP_HOSTSDK_PLUGIN_BASE_H_
+#define _VAMP_HOSTSDK_PLUGIN_BASE_H_
+
+// Do not include vamp-sdk/PluginBase.h directly from host code.
+// Always use this header instead.
+
+#include "hostguard.h"
+
+#include <vamp-sdk/PluginBase.h>
+
+#endif
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+ This file by Mark Levy and Chris Cannam, Copyright 2007-2008 QMUL.
+
+ 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 _VAMP_PLUGIN_BUFFERING_ADAPTER_H_
+#define _VAMP_PLUGIN_BUFFERING_ADAPTER_H_
+
+#include "hostguard.h"
+#include "PluginWrapper.h"
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginBufferingAdapter.h)
+
+namespace Vamp {
+
+namespace HostExt {
+
+/**
+ * \class PluginBufferingAdapter PluginBufferingAdapter.h <vamp-hostsdk/PluginBufferingAdapter.h>
+ *
+ * PluginBufferingAdapter is a Vamp plugin adapter that allows plugins
+ * to be used by a host supplying an audio stream in non-overlapping
+ * buffers of arbitrary size.
+ *
+ * A host using PluginBufferingAdapter may ignore the preferred step
+ * and block size reported by the plugin, and still expect the plugin
+ * to run. The value of blockSize and stepSize passed to initialise
+ * should be the size of the buffer which the host will supply; the
+ * stepSize should be equal to the blockSize.
+ *
+ * If the internal step size used for the plugin differs from that
+ * supplied by the host, the adapter will modify the sample type and
+ * rate specifications for the plugin outputs appropriately, and set
+ * timestamps on the output features for outputs that formerly used a
+ * different sample rate specification. This is necessary in order to
+ * obtain correct time stamping.
+ *
+ * In other respects, the PluginBufferingAdapter behaves identically
+ * to the plugin that it wraps. The wrapped plugin will be deleted
+ * when the wrapper is deleted.
+ */
+
+class PluginBufferingAdapter : public PluginWrapper
+{
+public:
+ /**
+ * Construct a PluginBufferingAdapter wrapping the given plugin.
+ * The adapter takes ownership of the plugin, which will be
+ * deleted when the adapter is deleted.
+ */
+ PluginBufferingAdapter(Plugin *plugin);
+ virtual ~PluginBufferingAdapter();
+
+ /**
+ * Return the preferred step size for this adapter.
+ *
+ * Because of the way this adapter works, its preferred step size
+ * will always be the same as its preferred block size. This may
+ * or may not be the same as the preferred step size of the
+ * underlying plugin, which may be obtained by calling
+ * getPluginPreferredStepSize().
+ */
+ size_t getPreferredStepSize() const;
+
+ /**
+ * Return the preferred block size for this adapter.
+ *
+ * This may or may not be the same as the preferred block size of
+ * the underlying plugin, which may be obtained by calling
+ * getPluginPreferredBlockSize().
+ *
+ * Note that this adapter may be initialised with any block size,
+ * not just its supposedly preferred one.
+ */
+ size_t getPreferredBlockSize() const;
+
+ /**
+ * Initialise the adapter (and therefore the plugin) for the given
+ * number of channels. Initialise the adapter for the given step
+ * and block size, which must be equal.
+ *
+ * The step and block size used for the underlying plugin will
+ * depend on its preferences, or any values previously passed to
+ * setPluginStepSize and setPluginBlockSize.
+ */
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ /**
+ * Return the preferred step size of the plugin wrapped by this
+ * adapter.
+ *
+ * This is included mainly for informational purposes. This value
+ * is not likely to be a valid step size for the adapter itself,
+ * and it is not usually of any use in interpreting the results
+ * (because the adapter re-writes OneSamplePerStep outputs to
+ * FixedSampleRate so that the hop size no longer needs to be
+ * known beforehand in order to interpret them).
+ */
+ size_t getPluginPreferredStepSize() const;
+
+ /**
+ * Return the preferred block size of the plugin wrapped by this
+ * adapter.
+ *
+ * This is included mainly for informational purposes.
+ */
+ size_t getPluginPreferredBlockSize() const;
+
+ /**
+ * Set the step size that will be used for the underlying plugin
+ * when initialise() is called. If this is not set, the plugin's
+ * own preferred step size will be used. You will not usually
+ * need to call this function. If you do call it, it must be
+ * before the first call to initialise().
+ */
+ void setPluginStepSize(size_t stepSize);
+
+ /**
+ * Set the block size that will be used for the underlying plugin
+ * when initialise() is called. If this is not set, the plugin's
+ * own preferred block size will be used. You will not usually
+ * need to call this function. If you do call it, it must be
+ * before the first call to initialise().
+ */
+ void setPluginBlockSize(size_t blockSize);
+
+ /**
+ * Return the step and block sizes that were actually used when
+ * initialising the underlying plugin.
+ *
+ * This is included mainly for informational purposes. You will
+ * not usually need to call this function. If this is called
+ * before initialise(), it will return 0 for both values. If it
+ * is called after a failed call to initialise(), it will return
+ * the values that were used in the failed call to the plugin's
+ * initialise() function.
+ */
+ void getActualStepAndBlockSizes(size_t &stepSize, size_t &blockSize);
+
+ void setParameter(std::string, float);
+ void selectProgram(std::string);
+
+ OutputList getOutputDescriptors() const;
+
+ void reset();
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ FeatureSet getRemainingFeatures();
+
+protected:
+ class Impl;
+ Impl *m_impl;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginBufferingAdapter.h)
+
+#endif
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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 _VAMP_PLUGIN_CHANNEL_ADAPTER_H_
+#define _VAMP_PLUGIN_CHANNEL_ADAPTER_H_
+
+#include "hostguard.h"
+#include "PluginWrapper.h"
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginChannelAdapter.h)
+
+namespace Vamp {
+
+namespace HostExt {
+
+/**
+ * \class PluginChannelAdapter PluginChannelAdapter.h <vamp-hostsdk/PluginChannelAdapter.h>
+ *
+ * PluginChannelAdapter is a Vamp plugin adapter that implements a
+ * policy for management of plugins that expect a different number of
+ * input channels from the number actually available in the source
+ * audio data.
+ *
+ * A host using PluginChannelAdapter may ignore the getMinChannelCount
+ * and getMaxChannelCount reported by the plugin, and still expect the
+ * plugin to run.
+ *
+ * PluginChannelAdapter implements the following policy:
+ *
+ * - If the plugin supports the provided number of channels directly,
+ * PluginChannelAdapter will just run the plugin as normal.
+ *
+ * - If the plugin only supports exactly one channel but more than
+ * one channel is provided, PluginChannelAdapter will use the mean of
+ * the channels. This ensures that the resulting values remain
+ * within the same magnitude range as expected for mono data.
+ *
+ * - If the plugin requires more than one channel but exactly one is
+ * provided, the provided channel will be duplicated across all the
+ * plugin input channels.
+ *
+ * If none of the above apply:
+ *
+ * - If the plugin requires more channels than are provided, the
+ * minimum acceptable number of channels will be produced by adding
+ * empty (zero valued) channels to those provided.
+ *
+ * - If the plugin requires fewer channels than are provided, the
+ * maximum acceptable number of channels will be produced by
+ * discarding the excess channels.
+ *
+ * Hosts requiring a different channel policy from the above will need
+ * to implement it themselves, instead of using PluginChannelAdapter.
+ *
+ * Note that PluginChannelAdapter does not override the minimum and
+ * maximum channel counts returned by the wrapped plugin. The host
+ * will need to be aware that it is using a PluginChannelAdapter, and
+ * be prepared to ignore these counts as necessary. (This contrasts
+ * with the approach used in PluginInputDomainAdapter, which aims to
+ * make the host completely unaware of which underlying input domain
+ * is in fact in use.)
+ *
+ * (The rationale for this is that a host may wish to use the
+ * PluginChannelAdapter but still discriminate in some way on the
+ * basis of the number of channels actually supported. For example, a
+ * simple stereo audio host may prefer to reject plugins that require
+ * more than two channels on the grounds that doesn't actually
+ * understand what they are for, rather than allow the channel adapter
+ * to make a potentially meaningless channel conversion for them.)
+ *
+ * In every respect other than its management of channels, the
+ * PluginChannelAdapter behaves identically to the plugin that it
+ * wraps. The wrapped plugin will be deleted when the wrapper is
+ * deleted.
+ *
+ * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
+ */
+
+class PluginChannelAdapter : public PluginWrapper
+{
+public:
+ /**
+ * Construct a PluginChannelAdapter wrapping the given plugin.
+ * The adapter takes ownership of the plugin, which will be
+ * deleted when the adapter is deleted.
+ */
+ PluginChannelAdapter(Plugin *plugin);
+ virtual ~PluginChannelAdapter();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ /**
+ * Call process(), providing interleaved audio data with the
+ * number of channels passed to initialise(). The adapter will
+ * de-interleave into temporary buffers as appropriate before
+ * calling process().
+ *
+ * \note This function was introduced in version 1.4 of the Vamp
+ * plugin SDK.
+ */
+ FeatureSet processInterleaved(const float *inputBuffer, RealTime timestamp);
+
+protected:
+ class Impl;
+ Impl *m_impl;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginChannelAdapter.h)
+
+#endif
--- /dev/null
+/* -*- 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 _VAMP_PLUGIN_HOST_ADAPTER_H_
+#define _VAMP_PLUGIN_HOST_ADAPTER_H_
+
+#include "hostguard.h"
+#include "Plugin.h"
+
+#include <vamp/vamp.h>
+
+#include <vector>
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginHostAdapter.h)
+
+namespace Vamp {
+
+/**
+ * \class PluginHostAdapter PluginHostAdapter.h <vamp-hostsdk/PluginHostAdapter.h>
+ *
+ * PluginHostAdapter is a wrapper class that a Vamp host can use to
+ * make the C-language VampPluginDescriptor object appear as a C++
+ * Vamp::Plugin object.
+ *
+ * The Vamp API is defined in vamp/vamp.h as a C API. The C++ objects
+ * used for convenience by plugins and hosts actually communicate
+ * using the C low-level API, but the details of this communication
+ * are handled seamlessly by the Vamp SDK implementation provided the
+ * plugin and host use the proper C++ wrapper objects.
+ *
+ * See also PluginAdapter, the plugin-side wrapper that makes a C++
+ * plugin object available using the C query API.
+ */
+
+class PluginHostAdapter : public Plugin
+{
+public:
+ PluginHostAdapter(const VampPluginDescriptor *descriptor,
+ float inputSampleRate);
+ virtual ~PluginHostAdapter();
+
+ static std::vector<std::string> getPluginPath();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+ void reset();
+
+ InputDomain getInputDomain() const;
+
+ unsigned int getVampApiVersion() const;
+ std::string getIdentifier() const;
+ std::string getName() const;
+ std::string getDescription() const;
+ std::string getMaker() const;
+ int getPluginVersion() const;
+ std::string getCopyright() const;
+
+ ParameterList getParameterDescriptors() const;
+ float getParameter(std::string) const;
+ void setParameter(std::string, float);
+
+ ProgramList getPrograms() const;
+ std::string getCurrentProgram() const;
+ void selectProgram(std::string);
+
+ size_t getPreferredStepSize() const;
+ size_t getPreferredBlockSize() const;
+
+ size_t getMinChannelCount() const;
+ size_t getMaxChannelCount() const;
+
+ OutputList getOutputDescriptors() const;
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ FeatureSet getRemainingFeatures();
+
+protected:
+ void convertFeatures(VampFeatureList *, FeatureSet &);
+
+ const VampPluginDescriptor *m_descriptor;
+ VampPluginHandle m_handle;
+};
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginHostAdapter.h)
+
+#endif
+
+
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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 _VAMP_PLUGIN_INPUT_DOMAIN_ADAPTER_H_
+#define _VAMP_PLUGIN_INPUT_DOMAIN_ADAPTER_H_
+
+#include "hostguard.h"
+#include "PluginWrapper.h"
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginInputDomainAdapter.h)
+
+namespace Vamp {
+
+namespace HostExt {
+
+/**
+ * \class PluginInputDomainAdapter PluginInputDomainAdapter.h <vamp-hostsdk/PluginInputDomainAdapter.h>
+ *
+ * PluginInputDomainAdapter is a Vamp plugin adapter that converts
+ * time-domain input into frequency-domain input for plugins that need
+ * it. This permits a host to use time- and frequency-domain plugins
+ * interchangeably without needing to handle the conversion itself.
+ *
+ * This adapter uses a basic Hanning windowed FFT that supports
+ * power-of-two block sizes only. If a frequency domain plugin
+ * requests a non-power-of-two blocksize, the adapter will adjust it
+ * to a nearby power of two instead. Thus, getPreferredBlockSize()
+ * will always return a power of two if the wrapped plugin is a
+ * frequency domain one. If the plugin doesn't accept the adjusted
+ * power of two block size, initialise() will fail.
+ *
+ * The adapter provides no way for the host to discover whether the
+ * underlying plugin is actually a time or frequency domain plugin
+ * (except that if the preferred block size is not a power of two, it
+ * must be a time domain plugin).
+ *
+ * The FFT implementation is simple and self-contained, but unlikely
+ * to be the fastest available: a host can usually do better if it
+ * cares enough.
+ *
+ * In every respect other than its input domain handling, the
+ * PluginInputDomainAdapter behaves identically to the plugin that it
+ * wraps. The wrapped plugin will be deleted when the wrapper is
+ * deleted.
+ *
+ * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
+ */
+
+class PluginInputDomainAdapter : public PluginWrapper
+{
+public:
+ /**
+ * Construct a PluginInputDomainAdapter wrapping the given plugin.
+ * The adapter takes ownership of the plugin, which will be
+ * deleted when the adapter is deleted.
+ */
+ PluginInputDomainAdapter(Plugin *plugin);
+ virtual ~PluginInputDomainAdapter();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ InputDomain getInputDomain() const;
+
+ size_t getPreferredStepSize() const;
+ size_t getPreferredBlockSize() const;
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ /**
+ * Return the amount by which the timestamps supplied to process()
+ * are being incremented when they are passed to the plugin's own
+ * process() implementation.
+ *
+ * The Vamp API mandates that the timestamp passed to the plugin
+ * for time-domain input should be the time of the first sample in
+ * the block, but the timestamp passed for frequency-domain input
+ * should be the timestamp of the centre of the block.
+ *
+ * The PluginInputDomainAdapter adjusts its timestamps properly so
+ * that the plugin receives correct times, but in some
+ * circumstances (such as for establishing the correct timing of
+ * implicitly-timed features, i.e. features without their own
+ * timestamps) the host may need to be aware that this adjustment
+ * is taking place.
+ *
+ * If the plugin requires time-domain input, this function will
+ * return zero. The result of calling this function before
+ * initialise() has been called is undefined.
+ */
+ RealTime getTimestampAdjustment() const;
+
+protected:
+ class Impl;
+ Impl *m_impl;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginInputDomainAdapter.h)
+
+#endif
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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 _VAMP_PLUGIN_LOADER_H_
+#define _VAMP_PLUGIN_LOADER_H_
+
+#include <vector>
+#include <string>
+#include <map>
+
+#include "hostguard.h"
+#include "PluginWrapper.h"
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginLoader.h)
+
+namespace Vamp {
+
+class Plugin;
+
+namespace HostExt {
+
+/**
+ * \class PluginLoader PluginLoader.h <vamp-hostsdk/PluginLoader.h>
+ *
+ * Vamp::HostExt::PluginLoader is a convenience class for discovering
+ * and loading Vamp plugins using the typical plugin-path, library
+ * naming, and categorisation conventions described in the Vamp SDK
+ * documentation. This class is intended to greatly simplify the task
+ * of becoming a Vamp plugin host for any C++ application.
+ *
+ * Hosts are not required by the Vamp specification to use the same
+ * plugin search path and naming conventions as implemented by this
+ * class, and are certainly not required to use this actual class.
+ * But we do strongly recommend it.
+ *
+ * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
+ */
+
+class PluginLoader
+{
+public:
+ /**
+ * Obtain a pointer to the singleton instance of PluginLoader.
+ * Use this to obtain your loader object.
+ */
+ static PluginLoader *getInstance();
+
+ /**
+ * PluginKey is a string type that is used to identify a plugin
+ * uniquely within the scope of "the current system". It consists
+ * of the lower-cased base name of the plugin library, a colon
+ * separator, and the identifier string for the plugin. It is
+ * only meaningful in the context of a given plugin path (the one
+ * returned by PluginHostAdapter::getPluginPath()).
+ *
+ * Use composePluginKey() to construct a plugin key from a known
+ * plugin library name and identifier.
+ *
+ * Note: the fact that the library component of the key is
+ * lower-cased implies that library names are matched
+ * case-insensitively by the PluginLoader class, regardless of the
+ * case sensitivity of the underlying filesystem. (Plugin
+ * identifiers _are_ case sensitive, however.) Also, it is not
+ * possible to portably extract a working library name from a
+ * plugin key, as the result may fail on case-sensitive
+ * filesystems. Use getLibraryPathForPlugin() instead.
+ */
+ typedef std::string PluginKey;
+
+ /**
+ * PluginKeyList is a sequence of plugin keys, such as returned by
+ * listPlugins().
+ */
+ typedef std::vector<PluginKey> PluginKeyList;
+
+ /**
+ * PluginCategoryHierarchy is a sequence of general->specific
+ * category names, as may be associated with a single plugin.
+ * This sequence describes the location of a plugin within a
+ * category forest, containing the human-readable names of the
+ * plugin's category tree root, followed by each of the nodes down
+ * to the leaf containing the plugin.
+ *
+ * \see getPluginCategory()
+ */
+ typedef std::vector<std::string> PluginCategoryHierarchy;
+
+ /**
+ * Search for all available Vamp plugins, and return a list of
+ * them in the order in which they were found.
+ */
+ PluginKeyList listPlugins();
+
+ /**
+ * AdapterFlags contains a set of values that may be OR'd together
+ * to indicate in which circumstances PluginLoader should use a
+ * plugin adapter to make a plugin easier to use for a host that
+ * does not want to cater for complex features.
+ *
+ * The available flags are:
+ *
+ * ADAPT_INPUT_DOMAIN - If the plugin expects frequency domain
+ * input, wrap it in a PluginInputDomainAdapter that automatically
+ * converts the plugin to one that expects time-domain input.
+ * This enables a host to accommodate time- and frequency-domain
+ * plugins without needing to do any conversion itself.
+ *
+ * ADAPT_CHANNEL_COUNT - Wrap the plugin in a PluginChannelAdapter
+ * to handle any mismatch between the number of channels of audio
+ * the plugin can handle and the number available in the host.
+ * This enables a host to use plugins that may require the input
+ * to be mixed down to mono, etc., without having to worry about
+ * doing that itself.
+ *
+ * ADAPT_BUFFER_SIZE - Wrap the plugin in a PluginBufferingAdapter
+ * permitting the host to provide audio input using any block
+ * size, with no overlap, regardless of the plugin's preferred
+ * block size (suitable for hosts that read from non-seekable
+ * streaming media, for example). This adapter introduces some
+ * run-time overhead and also changes the semantics of the plugin
+ * slightly (see the PluginBufferingAdapter header documentation
+ * for details).
+ *
+ * ADAPT_ALL_SAFE - Perform all available adaptations that are
+ * meaningful for the plugin and "safe". Currently this means to
+ * ADAPT_INPUT_DOMAIN if the plugin wants FrequencyDomain input;
+ * ADAPT_CHANNEL_COUNT always; and ADAPT_BUFFER_SIZE never.
+ *
+ * ADAPT_ALL - Perform all available adaptations that are
+ * meaningful for the plugin.
+ *
+ * See PluginInputDomainAdapter, PluginChannelAdapter and
+ * PluginBufferingAdapter for more details of the classes that the
+ * loader may use if these flags are set.
+ */
+ enum AdapterFlags {
+
+ ADAPT_INPUT_DOMAIN = 0x01,
+ ADAPT_CHANNEL_COUNT = 0x02,
+ ADAPT_BUFFER_SIZE = 0x04,
+
+ ADAPT_ALL_SAFE = 0x03,
+
+ ADAPT_ALL = 0xff
+ };
+
+ /**
+ * Load a Vamp plugin, given its identifying key. If the plugin
+ * could not be loaded, returns 0.
+ *
+ * The returned plugin should be deleted (using the standard C++
+ * delete keyword) after use.
+ *
+ * \param adapterFlags a bitwise OR of the values in the AdapterFlags
+ * enumeration, indicating under which circumstances an adapter should be
+ * used to wrap the original plugin. If adapterFlags is 0, no
+ * optional adapters will be used. Otherwise, the returned plugin
+ * may be of an adapter class type which will behave identically
+ * to the original plugin, apart from any particular features
+ * implemented by the adapter itself.
+ *
+ * \see AdapterFlags, PluginInputDomainAdapter, PluginChannelAdapter
+ */
+ Plugin *loadPlugin(PluginKey key,
+ float inputSampleRate,
+ int adapterFlags = 0);
+
+ /**
+ * Given a Vamp plugin library name and plugin identifier, return
+ * the corresponding plugin key in a form suitable for passing in to
+ * loadPlugin().
+ */
+ PluginKey composePluginKey(std::string libraryName,
+ std::string identifier);
+
+ /**
+ * Return the category hierarchy for a Vamp plugin, given its
+ * identifying key.
+ *
+ * If the plugin has no category information, return an empty
+ * hierarchy.
+ *
+ * \see PluginCategoryHierarchy
+ */
+ PluginCategoryHierarchy getPluginCategory(PluginKey plugin);
+
+ /**
+ * Return the file path of the dynamic library from which the
+ * given plugin will be loaded (if available).
+ */
+ std::string getLibraryPathForPlugin(PluginKey plugin);
+
+protected:
+ PluginLoader();
+ virtual ~PluginLoader();
+
+ class Impl;
+ Impl *m_impl;
+
+ static PluginLoader *m_instance;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginLoader.h)
+
+#endif
+
--- /dev/null
+/* -*- 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-2008 Chris Cannam and QMUL.
+
+ 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 _VAMP_PLUGIN_SUMMARISING_ADAPTER_H_
+#define _VAMP_PLUGIN_SUMMARISING_ADAPTER_H_
+
+#include "hostguard.h"
+#include "PluginWrapper.h"
+
+#include <set>
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginSummarisingAdapter.h)
+
+namespace Vamp {
+
+namespace HostExt {
+
+/**
+ * \class PluginSummarisingAdapter PluginSummarisingAdapter.h <vamp-hostsdk/PluginSummarisingAdapter.h>
+ *
+ * PluginSummarisingAdapter is a Vamp plugin adapter that provides
+ * summarisation methods such as mean and median averages of output
+ * features, for use in any context where an available plugin produces
+ * individual values but the result that is actually needed is some
+ * sort of aggregate.
+ *
+ * To make use of PluginSummarisingAdapter, the host should configure,
+ * initialise and run the plugin through the adapter interface just as
+ * normal. Then, after the process and getRemainingFeatures methods
+ * have been properly called and processing is complete, the host may
+ * call getSummaryForOutput or getSummaryForAllOutputs to obtain
+ * summarised features: averages, maximum values, etc, depending on
+ * the SummaryType passed to the function.
+ *
+ * By default PluginSummarisingAdapter calculates a single summary of
+ * each output's feature across the whole duration of processed audio.
+ * A host needing summaries of sub-segments of the whole audio may
+ * call setSummarySegmentBoundaries before retrieving the summaries,
+ * providing a list of times such that one summary will be provided
+ * for each segment between two consecutive times.
+ *
+ * PluginSummarisingAdapter is straightforward rather than fast. It
+ * calculates all of the summary types for all outputs always, and
+ * then returns only the ones that are requested. It is designed on
+ * the basis that, for most features, summarising and storing
+ * summarised results is far cheaper than calculating the results in
+ * the first place. If this is not true for your particular feature,
+ * PluginSummarisingAdapter may not be the best approach for you.
+ *
+ * \note This class was introduced in version 2.0 of the Vamp plugin SDK.
+ */
+
+class PluginSummarisingAdapter : public PluginWrapper
+{
+public:
+ /**
+ * Construct a PluginSummarisingAdapter wrapping the given plugin.
+ * The adapter takes ownership of the plugin, which will be
+ * deleted when the adapter is deleted.
+ */
+ PluginSummarisingAdapter(Plugin *plugin);
+ virtual ~PluginSummarisingAdapter();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+
+ void reset();
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+ FeatureSet getRemainingFeatures();
+
+ typedef std::set<RealTime> SegmentBoundaries;
+
+ /**
+ * Specify a series of segment boundaries, such that one summary
+ * will be returned for each of the contiguous intra-boundary
+ * segments. This function must be called before
+ * getSummaryForOutput or getSummaryForAllOutputs.
+ *
+ * Note that you cannot retrieve results with multiple different
+ * segmentations by repeatedly calling this function followed by
+ * one of the getSummary functions. The summaries are all
+ * calculated at the first call to any getSummary function, and
+ * once the summaries have been calculated, they remain
+ * calculated.
+ */
+ void setSummarySegmentBoundaries(const SegmentBoundaries &);
+
+ enum SummaryType {
+ Minimum = 0,
+ Maximum = 1,
+ Mean = 2,
+ Median = 3,
+ Mode = 4,
+ Sum = 5,
+ Variance = 6,
+ StandardDeviation = 7,
+ Count = 8,
+
+ UnknownSummaryType = 999
+ };
+
+ /**
+ * AveragingMethod indicates how the adapter should handle
+ * average-based summaries of features whose results are not
+ * equally spaced in time.
+ *
+ * If SampleAverage is specified, summary types based on averages
+ * will be calculated by treating each result individually without
+ * regard to its time: for example, the mean will be the sum of
+ * all values divided by the number of values.
+ *
+ * If ContinuousTimeAverage is specified, each feature will be
+ * considered to have a duration, either as specified in the
+ * feature's duration field, or until the following feature: thus,
+ * for example, the mean will be the sum of the products of values
+ * and durations, divided by the total duration.
+ *
+ * Although SampleAverage is useful for many types of feature,
+ * ContinuousTimeAverage is essential for some situations, for
+ * example finding the result that spans the largest proportion of
+ * the input given a feature that emits a new result only when the
+ * value changes (the modal value integrated over time).
+ */
+ enum AveragingMethod {
+ SampleAverage = 0,
+ ContinuousTimeAverage = 1,
+ };
+
+ /**
+ * Return summaries of the features that were returned on the
+ * given output, using the given SummaryType and AveragingMethod.
+ *
+ * The plugin must have been fully run (process() and
+ * getRemainingFeatures() calls all made as appropriate) before
+ * this function is called.
+ */
+ FeatureList getSummaryForOutput(int output,
+ SummaryType type,
+ AveragingMethod method = SampleAverage);
+
+ /**
+ * Return summaries of the features that were returned on all of
+ * the plugin's outputs, using the given SummaryType and
+ * AveragingMethod.
+ *
+ * The plugin must have been fully run (process() and
+ * getRemainingFeatures() calls all made as appropriate) before
+ * this function is called.
+ */
+ FeatureSet getSummaryForAllOutputs(SummaryType type,
+ AveragingMethod method = SampleAverage);
+
+protected:
+ class Impl;
+ Impl *m_impl;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginSummarisingAdapter.h)
+
+#endif
--- /dev/null
+/* -*- 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-2007 Chris Cannam and QMUL.
+
+ 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 _VAMP_PLUGIN_WRAPPER_H_
+#define _VAMP_PLUGIN_WRAPPER_H_
+
+#include "hostguard.h"
+#include <vamp-hostsdk/Plugin.h>
+
+_VAMP_SDK_HOSTSPACE_BEGIN(PluginWrapper.h)
+
+namespace Vamp {
+
+namespace HostExt {
+
+/**
+ * \class PluginWrapper PluginWrapper.h <vamp-hostsdk/PluginWrapper.h>
+ *
+ * PluginWrapper is a simple base class for adapter plugins. It takes
+ * a pointer to a "to be wrapped" Vamp plugin on construction, and
+ * provides implementations of all the Vamp plugin methods that simply
+ * delegate through to the wrapped plugin. A subclass can therefore
+ * override only the methods that are meaningful for the particular
+ * adapter.
+ *
+ * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
+ */
+
+class PluginWrapper : public Plugin
+{
+public:
+ virtual ~PluginWrapper();
+
+ bool initialise(size_t channels, size_t stepSize, size_t blockSize);
+ void reset();
+
+ InputDomain getInputDomain() const;
+
+ unsigned int getVampApiVersion() const;
+ std::string getIdentifier() const;
+ std::string getName() const;
+ std::string getDescription() const;
+ std::string getMaker() const;
+ int getPluginVersion() const;
+ std::string getCopyright() const;
+
+ ParameterList getParameterDescriptors() const;
+ float getParameter(std::string) const;
+ void setParameter(std::string, float);
+
+ ProgramList getPrograms() const;
+ std::string getCurrentProgram() const;
+ void selectProgram(std::string);
+
+ size_t getPreferredStepSize() const;
+ size_t getPreferredBlockSize() const;
+
+ size_t getMinChannelCount() const;
+ size_t getMaxChannelCount() const;
+
+ OutputList getOutputDescriptors() const;
+
+ FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
+
+ FeatureSet getRemainingFeatures();
+
+ /**
+ * Return a pointer to the plugin wrapper of type WrapperType
+ * surrounding this wrapper's plugin, if present.
+ *
+ * This is useful in situations where a plugin is wrapped by
+ * multiple different wrappers (one inside another) and the host
+ * wants to call some wrapper-specific function on one of the
+ * layers without having to care about the order in which they are
+ * wrapped. For example, the plugin returned by
+ * PluginLoader::loadPlugin may have more than one wrapper; if the
+ * host wanted to query or fine-tune some property of one of them,
+ * it would be hard to do so without knowing the order of the
+ * wrappers. This function therefore gives direct access to the
+ * wrapper of a particular type.
+ */
+ template <typename WrapperType>
+ WrapperType *getWrapper() {
+ WrapperType *w = dynamic_cast<WrapperType *>(this);
+ if (w) return w;
+ PluginWrapper *pw = dynamic_cast<PluginWrapper *>(m_plugin);
+ if (pw) return pw->getWrapper<WrapperType>();
+ return 0;
+ }
+
+protected:
+ PluginWrapper(Plugin *plugin); // I take ownership of plugin
+ Plugin *m_plugin;
+};
+
+}
+
+}
+
+_VAMP_SDK_HOSTSPACE_END(PluginWrapper.h)
+
+#endif
--- /dev/null
+/* -*- 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 _VAMP_HOSTSDK_REALTIME_H_
+#define _VAMP_HOSTSDK_REALTIME_H_
+
+// Do not include vamp-sdk/RealTime.h directly from host code. Always
+// use this header instead.
+
+#include "hostguard.h"
+#include <vamp-sdk/RealTime.h>
+
+#endif
--- /dev/null
+/* -*- 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 _VAMP_HOSTSDK_HOSTGUARD_H_
+#define _VAMP_HOSTSDK_HOSTGUARD_H_
+
+#ifdef _VAMP_IN_PLUGINSDK
+#error You have included headers from both vamp-sdk and vamp-hostsdk in the same source file. Please include only vamp-sdk headers in plugin code, and only vamp-hostsdk headers in host code.
+#else
+
+#define _VAMP_IN_HOSTSDK
+
+#ifdef _VAMP_NO_HOST_NAMESPACE
+#define _VAMP_SDK_HOSTSPACE_BEGIN(h)
+#define _VAMP_SDK_HOSTSPACE_END(h)
+#define _VAMP_SDK_PLUGSPACE_BEGIN(h)
+#define _VAMP_SDK_PLUGSPACE_END(h)
+#else
+#define _VAMP_SDK_HOSTSPACE_BEGIN(h) \
+ namespace _VampHost {
+
+#define _VAMP_SDK_HOSTSPACE_END(h) \
+ } \
+ using namespace _VampHost;
+#define _VAMP_SDK_PLUGSPACE_BEGIN(h) \
+ namespace _VampHost {
+
+#define _VAMP_SDK_PLUGSPACE_END(h) \
+ } \
+ using namespace _VampHost;
+#endif
+
+#endif
+
+#endif
+
--- /dev/null
+/* -*- 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 _VAMP_HOSTSDK_SINGLE_INCLUDE_H_
+#define _VAMP_HOSTSDK_SINGLE_INCLUDE_H_
+
+#include "PluginBase.h"
+#include "PluginBufferingAdapter.h"
+#include "PluginChannelAdapter.h"
+#include "Plugin.h"
+#include "PluginHostAdapter.h"
+#include "PluginInputDomainAdapter.h"
+#include "PluginLoader.h"
+#include "PluginSummarisingAdapter.h"
+#include "PluginWrapper.h"
+#include "RealTime.h"
+
+#endif
+
+
authorization.
*/
-#ifndef _VAMP_PLUGIN_H_
-#define _VAMP_PLUGIN_H_
-
-#include "PluginBase.h"
-#include "RealTime.h"
+#ifndef _VAMP_SDK_PLUGIN_H_
+#define _VAMP_SDK_PLUGIN_H_
#include <string>
#include <vector>
#include <map>
+#include "PluginBase.h"
+#include "RealTime.h"
+
+#include "plugguard.h"
+_VAMP_SDK_PLUGSPACE_BEGIN(Plugin.h)
+
namespace Vamp {
/**
/**
* The name of the output, in computer-usable form. Should be
* reasonably short and without whitespace or punctuation, using
- * the characters [a-zA-Z0-9_] only.
+ * the characters [a-zA-Z0-9_-] only.
* Example: "zero_crossing_count"
*/
std::string identifier;
* this to zero if that behaviour is not desired.
*/
float sampleRate;
+
+ /**
+ * True if the returned results for this output are known to
+ * have a duration field.
+ */
+ bool hasDuration;
+
+ OutputDescriptor() : // defaults for mandatory non-class-type members
+ hasFixedBinCount(false), hasKnownExtents(false), isQuantized(false),
+ sampleType(OneSamplePerStep), hasDuration(false) { }
};
typedef std::vector<OutputDescriptor> OutputList;
{
/**
* True if an output feature has its own timestamp. This is
- * mandatory if the output has VariableSampleRate, and is
- * likely to be disregarded otherwise.
+ * mandatory if the output has VariableSampleRate, optional if
+ * the output has FixedSampleRate, and unused if the output
+ * has OneSamplePerStep.
*/
bool hasTimestamp;
/**
* Timestamp of the output feature. This is mandatory if the
- * output has VariableSampleRate, and is likely to be
- * disregarded otherwise. Undefined if hasTimestamp is false.
+ * output has VariableSampleRate or if the output has
+ * FixedSampleRate and hasTimestamp is true, and unused
+ * otherwise.
*/
RealTime timestamp;
+
+ /**
+ * True if an output feature has a specified duration. This
+ * is optional if the output has VariableSampleRate or
+ * FixedSampleRate, and and unused if the output has
+ * OneSamplePerStep.
+ */
+ bool hasDuration;
+
+ /**
+ * Duration of the output feature. This is mandatory if the
+ * output has VariableSampleRate or FixedSampleRate and
+ * hasDuration is true, and unused otherwise.
+ */
+ RealTime duration;
/**
* Results for a single sample of this feature. If the output
* Label for the sample of this feature.
*/
std::string label;
+
+ Feature() : // defaults for mandatory non-class-type members
+ hasTimestamp(false), hasDuration(false) { }
};
typedef std::vector<Feature> FeatureList;
+
typedef std::map<int, FeatureList> FeatureSet; // key is output no
/**
* If the plugin's inputDomain is TimeDomain, inputBuffers will
* point to one array of floats per input channel, and each of
* these arrays will contain blockSize consecutive audio samples
- * (the host will zero-pad as necessary). The timestamp will be
- * the real time in seconds of the start of the supplied block of
- * samples.
+ * (the host will zero-pad as necessary). The timestamp in this
+ * case will be the real time in seconds of the start of the
+ * supplied block of samples.
*
* If the plugin's inputDomain is FrequencyDomain, inputBuffers
* will point to one array of floats per input channel, and each
}
+_VAMP_SDK_PLUGSPACE_END(Plugin.h)
+
#endif
#ifndef _VAMP_PLUGIN_ADAPTER_H_
#define _VAMP_PLUGIN_ADAPTER_H_
+#include <map>
#include <vamp/vamp.h>
#include "Plugin.h"
-#include <map>
+#include "plugguard.h"
+_VAMP_SDK_PLUGSPACE_BEGIN(PluginAdapter.h)
namespace Vamp {
}
+_VAMP_SDK_PLUGSPACE_END(PluginAdapter.h)
+
#endif
authorization.
*/
-#ifndef _VAMP_PLUGIN_BASE_H_
-#define _VAMP_PLUGIN_BASE_H_
+#ifndef _VAMP_SDK_PLUGIN_BASE_H_
+#define _VAMP_SDK_PLUGIN_BASE_H_
#include <string>
#include <vector>
-#define VAMP_SDK_VERSION "1.1"
+#define VAMP_SDK_VERSION "2.0"
+#define VAMP_SDK_MAJOR_VERSION 2
+#define VAMP_SDK_MINOR_VERSION 0
+
+#include "plugguard.h"
+_VAMP_SDK_PLUGSPACE_BEGIN(PluginBase.h)
namespace Vamp {
/**
* Get the Vamp API compatibility level of the plugin.
*/
- virtual unsigned int getVampApiVersion() const { return 1; }
+ virtual unsigned int getVampApiVersion() const { return 2; }
/**
* Get the computer-usable name of the plugin. This should be
* reasonably short and contain no whitespace or punctuation
- * characters. It may only contain the characters [a-zA-Z0-9_].
+ * characters. It may only contain the characters [a-zA-Z0-9_-].
* This is the authoritative way for a program to identify a
* plugin within a given library.
*
/**
* The name of the parameter, in computer-usable form. Should
* be reasonably short, and may only contain the characters
- * [a-zA-Z0-9_].
+ * [a-zA-Z0-9_-].
*/
std::string identifier;
* encoded in the names.
*/
std::vector<std::string> valueNames;
+
+ ParameterDescriptor() : // the defaults are invalid: you must set them
+ minValue(0), maxValue(0), defaultValue(0), isQuantized(false) { }
};
typedef std::vector<ParameterDescriptor> ParameterList;
}
+_VAMP_SDK_PLUGSPACE_END(PluginBase.h)
+
#endif
struct timeval;
#endif
+#include "plugguard.h"
+_VAMP_SDK_PLUGSPACE_BEGIN(RealTime.h)
+
namespace Vamp {
/**
std::ostream &operator<<(std::ostream &out, const RealTime &rt);
}
+
+_VAMP_SDK_PLUGSPACE_END(RealTime.h)
#endif
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
- This file by Mark Levy and 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 <vector>
-#include <map>
-
-#include "PluginBufferingAdapter.h"
-
-using std::vector;
-using std::map;
-
-namespace Vamp {
-
-namespace HostExt {
-
-class PluginBufferingAdapter::Impl
-{
-public:
- Impl(Plugin *plugin, float inputSampleRate);
- ~Impl();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- OutputList getOutputDescriptors() const;
-
- void reset();
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
- FeatureSet getRemainingFeatures();
-
-protected:
- class RingBuffer
- {
- public:
- RingBuffer(int n) :
- m_buffer(new float[n+1]), m_writer(0), m_reader(0), m_size(n+1) { }
- virtual ~RingBuffer() { delete[] m_buffer; }
-
- int getSize() const { return m_size-1; }
- void reset() { m_writer = 0; m_reader = 0; }
-
- int getReadSpace() const {
- int writer = m_writer, reader = m_reader, space;
- if (writer > reader) space = writer - reader;
- else if (writer < reader) space = (writer + m_size) - reader;
- else space = 0;
- return space;
- }
-
- int getWriteSpace() const {
- int writer = m_writer;
- int reader = m_reader;
- int space = (reader + m_size - writer - 1);
- if (space >= m_size) space -= m_size;
- return space;
- }
-
- int peek(float *destination, int n) const {
-
- int available = getReadSpace();
-
- if (n > available) {
- for (int i = available; i < n; ++i) {
- destination[i] = 0.f;
- }
- n = available;
- }
- if (n == 0) return n;
-
- int reader = m_reader;
- int here = m_size - reader;
- const float *const bufbase = m_buffer + reader;
-
- if (here >= n) {
- for (int i = 0; i < n; ++i) {
- destination[i] = bufbase[i];
- }
- } else {
- for (int i = 0; i < here; ++i) {
- destination[i] = bufbase[i];
- }
- float *const destbase = destination + here;
- const int nh = n - here;
- for (int i = 0; i < nh; ++i) {
- destbase[i] = m_buffer[i];
- }
- }
-
- return n;
- }
-
- int skip(int n) {
-
- int available = getReadSpace();
- if (n > available) {
- n = available;
- }
- if (n == 0) return n;
-
- int reader = m_reader;
- reader += n;
- while (reader >= m_size) reader -= m_size;
- m_reader = reader;
- return n;
- }
-
- int write(const float *source, int n) {
-
- int available = getWriteSpace();
- if (n > available) {
- n = available;
- }
- if (n == 0) return n;
-
- int writer = m_writer;
- int here = m_size - writer;
- float *const bufbase = m_buffer + writer;
-
- if (here >= n) {
- for (int i = 0; i < n; ++i) {
- bufbase[i] = source[i];
- }
- } else {
- for (int i = 0; i < here; ++i) {
- bufbase[i] = source[i];
- }
- const int nh = n - here;
- const float *const srcbase = source + here;
- float *const buf = m_buffer;
- for (int i = 0; i < nh; ++i) {
- buf[i] = srcbase[i];
- }
- }
-
- writer += n;
- while (writer >= m_size) writer -= m_size;
- m_writer = writer;
-
- return n;
- }
-
- int zero(int n) {
-
- int available = getWriteSpace();
- if (n > available) {
- n = available;
- }
- if (n == 0) return n;
-
- int writer = m_writer;
- int here = m_size - writer;
- float *const bufbase = m_buffer + writer;
-
- if (here >= n) {
- for (int i = 0; i < n; ++i) {
- bufbase[i] = 0.f;
- }
- } else {
- for (int i = 0; i < here; ++i) {
- bufbase[i] = 0.f;
- }
- const int nh = n - here;
- for (int i = 0; i < nh; ++i) {
- m_buffer[i] = 0.f;
- }
- }
-
- writer += n;
- while (writer >= m_size) writer -= m_size;
- m_writer = writer;
-
- return n;
- }
-
- protected:
- float *m_buffer;
- int m_writer;
- int m_reader;
- int m_size;
-
- private:
- RingBuffer(const RingBuffer &); // not provided
- RingBuffer &operator=(const RingBuffer &); // not provided
- };
-
- Plugin *m_plugin;
- size_t m_inputStepSize;
- size_t m_inputBlockSize;
- size_t m_stepSize;
- size_t m_blockSize;
- size_t m_channels;
- vector<RingBuffer *> m_queue;
- float **m_buffers;
- float m_inputSampleRate;
- RealTime m_timestamp;
- bool m_unrun;
- OutputList m_outputs;
-
- void processBlock(FeatureSet& allFeatureSets, RealTime timestamp);
-};
-
-PluginBufferingAdapter::PluginBufferingAdapter(Plugin *plugin) :
- PluginWrapper(plugin)
-{
- m_impl = new Impl(plugin, m_inputSampleRate);
-}
-
-PluginBufferingAdapter::~PluginBufferingAdapter()
-{
- delete m_impl;
-}
-
-bool
-PluginBufferingAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- return m_impl->initialise(channels, stepSize, blockSize);
-}
-
-PluginBufferingAdapter::OutputList
-PluginBufferingAdapter::getOutputDescriptors() const
-{
- return m_impl->getOutputDescriptors();
-}
-
-void
-PluginBufferingAdapter::reset()
-{
- m_impl->reset();
-}
-
-PluginBufferingAdapter::FeatureSet
-PluginBufferingAdapter::process(const float *const *inputBuffers,
- RealTime timestamp)
-{
- return m_impl->process(inputBuffers, timestamp);
-}
-
-PluginBufferingAdapter::FeatureSet
-PluginBufferingAdapter::getRemainingFeatures()
-{
- return m_impl->getRemainingFeatures();
-}
-
-PluginBufferingAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
- m_plugin(plugin),
- m_inputStepSize(0),
- m_inputBlockSize(0),
- m_stepSize(0),
- m_blockSize(0),
- m_channels(0),
- m_queue(0),
- m_buffers(0),
- m_inputSampleRate(inputSampleRate),
- m_timestamp(RealTime::zeroTime),
- m_unrun(true)
-{
- m_outputs = plugin->getOutputDescriptors();
-}
-
-PluginBufferingAdapter::Impl::~Impl()
-{
- // the adapter will delete the plugin
-
- for (size_t i = 0; i < m_channels; ++i) {
- delete m_queue[i];
- delete[] m_buffers[i];
- }
- delete[] m_buffers;
-}
-
-size_t
-PluginBufferingAdapter::getPreferredStepSize() const
-{
- return getPreferredBlockSize();
-}
-
-bool
-PluginBufferingAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- if (stepSize != blockSize) {
- std::cerr << "PluginBufferingAdapter::initialise: input stepSize must be equal to blockSize for this adapter (stepSize = " << stepSize << ", blockSize = " << blockSize << ")" << std::endl;
- return false;
- }
-
- m_channels = channels;
- m_inputStepSize = stepSize;
- m_inputBlockSize = blockSize;
-
- // use the step and block sizes which the plugin prefers
- m_stepSize = m_plugin->getPreferredStepSize();
- m_blockSize = m_plugin->getPreferredBlockSize();
-
- // or sensible defaults if it has no preference
- if (m_blockSize == 0) {
- m_blockSize = 1024;
- }
- if (m_stepSize == 0) {
- if (m_plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain) {
- m_stepSize = m_blockSize/2;
- } else {
- m_stepSize = m_blockSize;
- }
- } else if (m_stepSize > m_blockSize) {
- if (m_plugin->getInputDomain() == Vamp::Plugin::FrequencyDomain) {
- m_blockSize = m_stepSize * 2;
- } else {
- m_blockSize = m_stepSize;
- }
- }
-
- // std::cerr << "PluginBufferingAdapter::initialise: stepSize " << m_inputStepSize << " -> " << m_stepSize
- // << ", blockSize " << m_inputBlockSize << " -> " << m_blockSize << std::endl;
-
- // current implementation breaks if step is greater than block
- if (m_stepSize > m_blockSize) {
- std::cerr << "PluginBufferingAdapter::initialise: plugin's preferred stepSize greater than blockSize, giving up!" << std::endl;
- return false;
- }
-
- m_buffers = new float *[m_channels];
-
- for (size_t i = 0; i < m_channels; ++i) {
- m_queue.push_back(new RingBuffer(m_blockSize + m_inputBlockSize));
- m_buffers[i] = new float[m_blockSize];
- }
-
- return m_plugin->initialise(m_channels, m_stepSize, m_blockSize);
-}
-
-PluginBufferingAdapter::OutputList
-PluginBufferingAdapter::Impl::getOutputDescriptors() const
-{
- OutputList outs = m_plugin->getOutputDescriptors();
- for (size_t i = 0; i < outs.size(); ++i) {
- if (outs[i].sampleType == OutputDescriptor::OneSamplePerStep) {
- outs[i].sampleRate = 1.f / m_stepSize;
- }
- outs[i].sampleType = OutputDescriptor::VariableSampleRate;
- }
- return outs;
-}
-
-void
-PluginBufferingAdapter::Impl::reset()
-{
- m_timestamp = RealTime::zeroTime;
- m_unrun = true;
-
- for (size_t i = 0; i < m_queue.size(); ++i) {
- m_queue[i]->reset();
- }
-}
-
-PluginBufferingAdapter::FeatureSet
-PluginBufferingAdapter::Impl::process(const float *const *inputBuffers,
- RealTime timestamp)
-{
- FeatureSet allFeatureSets;
-
- if (m_unrun) {
- m_timestamp = timestamp;
- m_unrun = false;
- }
-
- // queue the new input
-
- for (size_t i = 0; i < m_channels; ++i) {
- int written = m_queue[i]->write(inputBuffers[i], m_inputBlockSize);
- if (written < int(m_inputBlockSize) && i == 0) {
- std::cerr << "WARNING: PluginBufferingAdapter::Impl::process: "
- << "Buffer overflow: wrote " << written
- << " of " << m_inputBlockSize
- << " input samples (for plugin step size "
- << m_stepSize << ", block size " << m_blockSize << ")"
- << std::endl;
- }
- }
-
- // process as much as we can
-
- while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
- processBlock(allFeatureSets, timestamp);
- }
-
- return allFeatureSets;
-}
-
-PluginBufferingAdapter::FeatureSet
-PluginBufferingAdapter::Impl::getRemainingFeatures()
-{
- FeatureSet allFeatureSets;
-
- // process remaining samples in queue
- while (m_queue[0]->getReadSpace() >= int(m_blockSize)) {
- processBlock(allFeatureSets, m_timestamp);
- }
-
- // pad any last samples remaining and process
- if (m_queue[0]->getReadSpace() > 0) {
- for (size_t i = 0; i < m_channels; ++i) {
- m_queue[i]->zero(m_blockSize - m_queue[i]->getReadSpace());
- }
- processBlock(allFeatureSets, m_timestamp);
- }
-
- // get remaining features
-
- FeatureSet featureSet = m_plugin->getRemainingFeatures();
-
- for (map<int, FeatureList>::iterator iter = featureSet.begin();
- iter != featureSet.end(); ++iter) {
- FeatureList featureList = iter->second;
- for (size_t i = 0; i < featureList.size(); ++i) {
- allFeatureSets[iter->first].push_back(featureList[i]);
- }
- }
-
- return allFeatureSets;
-}
-
-void
-PluginBufferingAdapter::Impl::processBlock(FeatureSet& allFeatureSets,
- RealTime timestamp)
-{
- for (size_t i = 0; i < m_channels; ++i) {
- m_queue[i]->peek(m_buffers[i], m_blockSize);
- }
-
- FeatureSet featureSet = m_plugin->process(m_buffers, m_timestamp);
-
- for (map<int, FeatureList>::iterator iter = featureSet.begin();
- iter != featureSet.end(); ++iter) {
-
- FeatureList featureList = iter->second;
- int outputNo = iter->first;
-
- for (size_t i = 0; i < featureList.size(); ++i) {
-
- // make sure the timestamp is set
- switch (m_outputs[outputNo].sampleType) {
-
- case OutputDescriptor::OneSamplePerStep:
- // use our internal timestamp - OK????
- featureList[i].timestamp = m_timestamp;
- break;
-
- case OutputDescriptor::FixedSampleRate:
- // use our internal timestamp
- featureList[i].timestamp = m_timestamp;
- break;
-
- case OutputDescriptor::VariableSampleRate:
- break; // plugin must set timestamp
-
- default:
- break;
- }
-
- allFeatureSets[outputNo].push_back(featureList[i]);
- }
- }
-
- // step forward
-
- for (size_t i = 0; i < m_channels; ++i) {
- m_queue[i]->skip(m_stepSize);
- }
-
- // fake up the timestamp each time we step forward
-
- long frame = RealTime::realTime2Frame(m_timestamp,
- int(m_inputSampleRate + 0.5));
- m_timestamp = RealTime::frame2RealTime(frame + m_stepSize,
- int(m_inputSampleRate + 0.5));
-}
-
-}
-
-}
-
-
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
- This file by Mark Levy, Copyright 2007 QMUL.
-
- 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 _VAMP_PLUGIN_BUFFERING_ADAPTER_H_
-#define _VAMP_PLUGIN_BUFFERING_ADAPTER_H_
-
-#include "PluginWrapper.h"
-
-namespace Vamp {
-
-namespace HostExt {
-
-/**
- * \class PluginBufferingAdapter PluginBufferingAdapter.h <vamp-sdk/hostext/PluginBufferingAdapter.h>
- *
- * PluginBufferingAdapter is a Vamp plugin adapter that allows plugins
- * to be used by a host supplying an audio stream in non-overlapping
- * buffers of arbitrary size.
- *
- * A host using PluginBufferingAdapter may ignore the preferred step
- * and block size reported by the plugin, and still expect the plugin
- * to run. The value of blockSize and stepSize passed to initialise
- * should be the size of the buffer which the host will supply; the
- * stepSize should be equal to the blockSize.
- *
- * If the internal step size used for the plugin differs from that
- * supplied by the host, the adapter will modify the sample rate
- * specifications for the plugin outputs (setting them all to
- * VariableSampleRate) and set timestamps on the output features for
- * outputs that formerly used a different sample rate specification.
- * This is necessary in order to obtain correct time stamping.
- *
- * In other respects, the PluginBufferingAdapter behaves identically
- * to the plugin that it wraps. The wrapped plugin will be deleted
- * when the wrapper is deleted.
- */
-
-class PluginBufferingAdapter : public PluginWrapper
-{
-public:
- PluginBufferingAdapter(Plugin *plugin); // I take ownership of plugin
- virtual ~PluginBufferingAdapter();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- size_t getPreferredStepSize() const;
-
- OutputList getOutputDescriptors() const;
-
- void reset();
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
- FeatureSet getRemainingFeatures();
-
-protected:
- class Impl;
- Impl *m_impl;
-};
-
-}
-
-}
-
-#endif
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 "PluginChannelAdapter.h"
-
-namespace Vamp {
-
-namespace HostExt {
-
-class PluginChannelAdapter::Impl
-{
-public:
- Impl(Plugin *plugin);
- ~Impl();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
-protected:
- Plugin *m_plugin;
- size_t m_blockSize;
- size_t m_inputChannels;
- size_t m_pluginChannels;
- float **m_buffer;
- const float **m_forwardPtrs;
-};
-
-PluginChannelAdapter::PluginChannelAdapter(Plugin *plugin) :
- PluginWrapper(plugin)
-{
- m_impl = new Impl(plugin);
-}
-
-PluginChannelAdapter::~PluginChannelAdapter()
-{
- delete m_impl;
-}
-
-bool
-PluginChannelAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- return m_impl->initialise(channels, stepSize, blockSize);
-}
-
-PluginChannelAdapter::FeatureSet
-PluginChannelAdapter::process(const float *const *inputBuffers,
- RealTime timestamp)
-{
- return m_impl->process(inputBuffers, timestamp);
-}
-
-PluginChannelAdapter::Impl::Impl(Plugin *plugin) :
- m_plugin(plugin),
- m_blockSize(0),
- m_inputChannels(0),
- m_pluginChannels(0),
- m_buffer(0),
- m_forwardPtrs(0)
-{
-}
-
-PluginChannelAdapter::Impl::~Impl()
-{
- // the adapter will delete the plugin
-
- if (m_buffer) {
- if (m_inputChannels > m_pluginChannels) {
- delete[] m_buffer[0];
- } else {
- for (size_t i = 0; i < m_pluginChannels - m_inputChannels; ++i) {
- delete[] m_buffer[i];
- }
- }
- delete[] m_buffer;
- m_buffer = 0;
- }
-
- if (m_forwardPtrs) {
- delete[] m_forwardPtrs;
- m_forwardPtrs = 0;
- }
-}
-
-bool
-PluginChannelAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- m_blockSize = blockSize;
-
- size_t minch = m_plugin->getMinChannelCount();
- size_t maxch = m_plugin->getMaxChannelCount();
-
- m_inputChannels = channels;
-
- if (m_inputChannels < minch) {
-
- m_forwardPtrs = new const float *[minch];
-
- if (m_inputChannels > 1) {
- // We need a set of zero-valued buffers to add to the
- // forwarded pointers
- m_buffer = new float*[minch - channels];
- for (size_t i = 0; i < minch; ++i) {
- m_buffer[i] = new float[blockSize];
- for (size_t j = 0; j < blockSize; ++j) {
- m_buffer[i][j] = 0.f;
- }
- }
- }
-
- m_pluginChannels = minch;
-
- // std::cerr << "PluginChannelAdapter::initialise: expanding " << m_inputChannels << " to " << m_pluginChannels << " for plugin" << std::endl;
-
- } else if (m_inputChannels > maxch) {
-
- // We only need m_buffer if we are mixing down to a single
- // channel -- otherwise we can just forward the same float* as
- // passed in to process(), expecting the excess to be ignored
-
- if (maxch == 1) {
- m_buffer = new float *[1];
- m_buffer[0] = new float[blockSize];
-
- // std::cerr << "PluginChannelAdapter::initialise: mixing " << m_inputChannels << " to mono for plugin" << std::endl;
-
- } else {
-
- // std::cerr << "PluginChannelAdapter::initialise: reducing " << m_inputChannels << " to " << m_pluginChannels << " for plugin" << std::endl;
- }
-
- m_pluginChannels = maxch;
-
- } else {
-
- // std::cerr << "PluginChannelAdapter::initialise: accepting given number of channels (" << m_inputChannels << ")" << std::endl;
- m_pluginChannels = m_inputChannels;
- }
-
- return m_plugin->initialise(m_pluginChannels, stepSize, blockSize);
-}
-
-PluginChannelAdapter::FeatureSet
-PluginChannelAdapter::Impl::process(const float *const *inputBuffers,
- RealTime timestamp)
-{
-// std::cerr << "PluginChannelAdapter::process: " << m_inputChannels << " -> " << m_pluginChannels << " channels" << std::endl;
-
- if (m_inputChannels < m_pluginChannels) {
-
- if (m_inputChannels == 1) {
- for (size_t i = 0; i < m_pluginChannels; ++i) {
- m_forwardPtrs[i] = inputBuffers[0];
- }
- } else {
- for (size_t i = 0; i < m_inputChannels; ++i) {
- m_forwardPtrs[i] = inputBuffers[i];
- }
- for (size_t i = m_inputChannels; i < m_pluginChannels; ++i) {
- m_forwardPtrs[i] = m_buffer[i - m_inputChannels];
- }
- }
-
- return m_plugin->process(m_forwardPtrs, timestamp);
-
- } else if (m_inputChannels > m_pluginChannels) {
-
- if (m_pluginChannels == 1) {
- for (size_t j = 0; j < m_blockSize; ++j) {
- m_buffer[0][j] = inputBuffers[0][j];
- }
- for (size_t i = 1; i < m_inputChannels; ++i) {
- for (size_t j = 0; j < m_blockSize; ++j) {
- m_buffer[0][j] += inputBuffers[i][j];
- }
- }
- for (size_t j = 0; j < m_blockSize; ++j) {
- m_buffer[0][j] /= m_inputChannels;
- }
- return m_plugin->process(m_buffer, timestamp);
- } else {
- return m_plugin->process(inputBuffers, timestamp);
- }
-
- } else {
-
- return m_plugin->process(inputBuffers, timestamp);
- }
-}
-
-}
-
-}
-
-
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 _VAMP_PLUGIN_CHANNEL_ADAPTER_H_
-#define _VAMP_PLUGIN_CHANNEL_ADAPTER_H_
-
-#include "PluginWrapper.h"
-
-namespace Vamp {
-
-namespace HostExt {
-
-/**
- * \class PluginChannelAdapter PluginChannelAdapter.h <vamp-sdk/hostext/PluginChannelAdapter.h>
- *
- * PluginChannelAdapter is a Vamp plugin adapter that implements a
- * policy for management of plugins that expect a different number of
- * input channels from the number actually available in the source
- * audio data.
- *
- * A host using PluginChannelAdapter may ignore the getMinChannelCount
- * and getMaxChannelCount reported by the plugin, and still expect the
- * plugin to run.
- *
- * PluginChannelAdapter implements the following policy:
- *
- * - If the plugin supports the provided number of channels directly,
- * PluginChannelAdapter will just run the plugin as normal.
- *
- * - If the plugin only supports exactly one channel but more than
- * one channel is provided, PluginChannelAdapter will use the mean of
- * the channels. This ensures that the resulting values remain
- * within the same magnitude range as expected for mono data.
- *
- * - If the plugin requires more than one channel but exactly one is
- * provided, the provided channel will be duplicated across all the
- * plugin input channels.
- *
- * If none of the above apply:
- *
- * - If the plugin requires more channels than are provided, the
- * minimum acceptable number of channels will be produced by adding
- * empty (zero valued) channels to those provided.
- *
- * - If the plugin requires fewer channels than are provided, the
- * maximum acceptable number of channels will be produced by
- * discarding the excess channels.
- *
- * Hosts requiring a different channel policy from the above will need
- * to implement it themselves, instead of using PluginChannelAdapter.
- *
- * Note that PluginChannelAdapter does not override the minimum and
- * maximum channel counts returned by the wrapped plugin. The host
- * will need to be aware that it is using a PluginChannelAdapter, and
- * be prepared to ignore these counts as necessary. (This contrasts
- * with the approach used in PluginInputDomainAdapter, which aims to
- * make the host completely unaware of which underlying input domain
- * is in fact in use.)
- *
- * (The rationale for this is that a host may wish to use the
- * PluginChannelAdapter but still discriminate in some way on the
- * basis of the number of channels actually supported. For example, a
- * simple stereo audio host may prefer to reject plugins that require
- * more than two channels on the grounds that doesn't actually
- * understand what they are for, rather than allow the channel adapter
- * to make a potentially meaningless channel conversion for them.)
- *
- * In every respect other than its management of channels, the
- * PluginChannelAdapter behaves identically to the plugin that it
- * wraps. The wrapped plugin will be deleted when the wrapper is
- * deleted.
- *
- * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
- */
-
-class PluginChannelAdapter : public PluginWrapper
-{
-public:
- PluginChannelAdapter(Plugin *plugin); // I take ownership of plugin
- virtual ~PluginChannelAdapter();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
-protected:
- class Impl;
- Impl *m_impl;
-};
-
-}
-
-}
-
-#endif
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- This file is based in part on Don Cross's public domain FFT
- implementation.
-
- 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 "PluginInputDomainAdapter.h"
-
-#include <cmath>
-
-/**
- * If you want to compile using FFTW instead of the built-in FFT
- * implementation for the PluginInputDomainAdapter, define HAVE_FFTW3
- * in the Makefile.
- *
- * Be aware that FFTW is licensed under the GPL -- unlike this SDK,
- * which is provided under a more liberal BSD license in order to
- * permit use in closed source applications. The use of FFTW would
- * mean that your code would need to be licensed under the GPL as
- * well. Do not define this symbol unless you understand and accept
- * the implications of this.
- *
- * Parties such as Linux distribution packagers who redistribute this
- * SDK for use in other programs should _not_ define this symbol, as
- * it would change the effective licensing terms under which the SDK
- * was available to third party developers.
- *
- * The default is not to use FFTW, and to use the built-in FFT instead.
- *
- * Note: The FFTW code uses FFTW_MEASURE, and so will perform badly on
- * its first invocation unless the host has saved and restored FFTW
- * wisdom (see the FFTW documentation).
- */
-#ifdef HAVE_FFTW3
-#include <fftw3.h>
-#endif
-
-namespace Vamp {
-
-namespace HostExt {
-
-class PluginInputDomainAdapter::Impl
-{
-public:
- Impl(Plugin *plugin, float inputSampleRate);
- ~Impl();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- size_t getPreferredStepSize() const;
- size_t getPreferredBlockSize() const;
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
-protected:
- Plugin *m_plugin;
- float m_inputSampleRate;
- int m_channels;
- int m_blockSize;
- float **m_freqbuf;
-
- double *m_ri;
- double *m_window;
-
-#ifdef HAVE_FFTW3
- fftw_plan m_plan;
- fftw_complex *m_cbuf;
-#else
- double *m_ro;
- double *m_io;
- void fft(unsigned int n, bool inverse,
- double *ri, double *ii, double *ro, double *io);
-#endif
-
- size_t makeBlockSizeAcceptable(size_t) const;
-};
-
-PluginInputDomainAdapter::PluginInputDomainAdapter(Plugin *plugin) :
- PluginWrapper(plugin)
-{
- m_impl = new Impl(plugin, m_inputSampleRate);
-}
-
-PluginInputDomainAdapter::~PluginInputDomainAdapter()
-{
- delete m_impl;
-}
-
-bool
-PluginInputDomainAdapter::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- return m_impl->initialise(channels, stepSize, blockSize);
-}
-
-Plugin::InputDomain
-PluginInputDomainAdapter::getInputDomain() const
-{
- return TimeDomain;
-}
-
-size_t
-PluginInputDomainAdapter::getPreferredStepSize() const
-{
- return m_impl->getPreferredStepSize();
-}
-
-size_t
-PluginInputDomainAdapter::getPreferredBlockSize() const
-{
- return m_impl->getPreferredBlockSize();
-}
-
-Plugin::FeatureSet
-PluginInputDomainAdapter::process(const float *const *inputBuffers, RealTime timestamp)
-{
- return m_impl->process(inputBuffers, timestamp);
-}
-
-PluginInputDomainAdapter::Impl::Impl(Plugin *plugin, float inputSampleRate) :
- m_plugin(plugin),
- m_inputSampleRate(inputSampleRate),
- m_channels(0),
- m_blockSize(0),
- m_freqbuf(0),
- m_ri(0),
- m_window(0),
-#ifdef HAVE_FFTW3
- m_plan(0),
- m_cbuf(0)
-#else
- m_ro(0),
- m_io(0)
-#endif
-{
-}
-
-PluginInputDomainAdapter::Impl::~Impl()
-{
- // the adapter will delete the plugin
-
- if (m_channels > 0) {
- for (int c = 0; c < m_channels; ++c) {
- delete[] m_freqbuf[c];
- }
- delete[] m_freqbuf;
-#ifdef HAVE_FFTW3
- if (m_plan) {
- fftw_destroy_plan(m_plan);
- fftw_free(m_ri);
- fftw_free(m_cbuf);
- m_plan = 0;
- }
-#else
- delete[] m_ri;
- delete[] m_ro;
- delete[] m_io;
-#endif
- delete[] m_window;
- }
-}
-
-// for some visual studii apparently
-#ifndef M_PI
-#define M_PI 3.14159265358979232846
-#endif
-
-bool
-PluginInputDomainAdapter::Impl::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- if (m_plugin->getInputDomain() == TimeDomain) {
-
- m_blockSize = int(blockSize);
- m_channels = int(channels);
-
- return m_plugin->initialise(channels, stepSize, blockSize);
- }
-
- if (blockSize < 2) {
- std::cerr << "ERROR: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: blocksize < 2 not supported" << std::endl;
- return false;
- }
-
- if (blockSize & (blockSize-1)) {
- std::cerr << "ERROR: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: non-power-of-two\nblocksize " << blockSize << " not supported" << std::endl;
- return false;
- }
-
- if (m_channels > 0) {
- for (int c = 0; c < m_channels; ++c) {
- delete[] m_freqbuf[c];
- }
- delete[] m_freqbuf;
-#ifdef HAVE_FFTW3
- if (m_plan) {
- fftw_destroy_plan(m_plan);
- fftw_free(m_ri);
- fftw_free(m_cbuf);
- m_plan = 0;
- }
-#else
- delete[] m_ri;
- delete[] m_ro;
- delete[] m_io;
-#endif
- delete[] m_window;
- }
-
- m_blockSize = int(blockSize);
- m_channels = int(channels);
-
- m_freqbuf = new float *[m_channels];
- for (int c = 0; c < m_channels; ++c) {
- m_freqbuf[c] = new float[m_blockSize + 2];
- }
- m_window = new double[m_blockSize];
-
- for (int i = 0; i < m_blockSize; ++i) {
- // Hanning window
- m_window[i] = (0.50 - 0.50 * cos((2.0 * M_PI * i) / m_blockSize));
- }
-
-#ifdef HAVE_FFTW3
- m_ri = (double *)fftw_malloc(blockSize * sizeof(double));
- m_cbuf = (fftw_complex *)fftw_malloc((blockSize/2 + 1) * sizeof(fftw_complex));
- m_plan = fftw_plan_dft_r2c_1d(blockSize, m_ri, m_cbuf, FFTW_MEASURE);
-#else
- m_ri = new double[m_blockSize];
- m_ro = new double[m_blockSize];
- m_io = new double[m_blockSize];
-#endif
-
- return m_plugin->initialise(channels, stepSize, blockSize);
-}
-
-size_t
-PluginInputDomainAdapter::Impl::getPreferredStepSize() const
-{
- size_t step = m_plugin->getPreferredStepSize();
-
- if (step == 0 && (m_plugin->getInputDomain() == FrequencyDomain)) {
- step = getPreferredBlockSize() / 2;
- }
-
- return step;
-}
-
-size_t
-PluginInputDomainAdapter::Impl::getPreferredBlockSize() const
-{
- size_t block = m_plugin->getPreferredBlockSize();
-
- if (m_plugin->getInputDomain() == FrequencyDomain) {
- if (block == 0) {
- block = 1024;
- } else {
- block = makeBlockSizeAcceptable(block);
- }
- }
-
- return block;
-}
-
-size_t
-PluginInputDomainAdapter::Impl::makeBlockSizeAcceptable(size_t blockSize) const
-{
- if (blockSize < 2) {
-
- std::cerr << "WARNING: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: blocksize < 2 not" << std::endl
- << "supported, increasing from " << blockSize << " to 2" << std::endl;
- blockSize = 2;
-
- } else if (blockSize & (blockSize-1)) {
-
-#ifdef HAVE_FFTW3
- // not an issue with FFTW
-#else
-
- // not a power of two, can't handle that with our built-in FFT
- // implementation
-
- size_t nearest = blockSize;
- size_t power = 0;
- while (nearest > 1) {
- nearest >>= 1;
- ++power;
- }
- nearest = 1;
- while (power) {
- nearest <<= 1;
- --power;
- }
-
- if (blockSize - nearest > (nearest*2) - blockSize) {
- nearest = nearest*2;
- }
-
- std::cerr << "WARNING: Vamp::HostExt::PluginInputDomainAdapter::Impl::initialise: non-power-of-two\nblocksize " << blockSize << " not supported, using blocksize " << nearest << " instead" << std::endl;
- blockSize = nearest;
-
-#endif
- }
-
- return blockSize;
-}
-
-Plugin::FeatureSet
-PluginInputDomainAdapter::Impl::process(const float *const *inputBuffers,
- RealTime timestamp)
-{
- if (m_plugin->getInputDomain() == TimeDomain) {
- return m_plugin->process(inputBuffers, timestamp);
- }
-
- // The timestamp supplied should be (according to the Vamp::Plugin
- // spec) the time of the start of the time-domain input block.
- // However, we want to pass to the plugin an FFT output calculated
- // from the block of samples _centred_ on that timestamp.
- //
- // We have two options:
- //
- // 1. Buffer the input, calculating the fft of the values at the
- // passed-in block minus blockSize/2 rather than starting at the
- // passed-in block. So each time we call process on the plugin,
- // we are passing in the same timestamp as was passed to our own
- // process plugin, but not (the frequency domain representation
- // of) the same set of samples. Advantages: avoids confusion in
- // the host by ensuring the returned values have timestamps
- // comparable with that passed in to this function (in fact this
- // is pretty much essential for one-value-per-block outputs);
- // consistent with hosts such as SV that deal with the
- // frequency-domain transform themselves. Disadvantages: means
- // making the not necessarily correct assumption that the samples
- // preceding the first official block are all zero (or some other
- // known value).
- //
- // 2. Increase the passed-in timestamps by half the blocksize. So
- // when we call process, we are passing in the frequency domain
- // representation of the same set of samples as passed to us, but
- // with a different timestamp. Advantages: simplicity; avoids
- // iffy assumption mentioned above. Disadvantages: inconsistency
- // with SV in cases where stepSize != blockSize/2; potential
- // confusion arising from returned timestamps being calculated
- // from the adjusted input timestamps rather than the original
- // ones (and inaccuracy where the returned timestamp is implied,
- // as in one-value-per-block).
- //
- // Neither way is ideal, but I don't think either is strictly
- // incorrect either. I think this is just a case where the same
- // plugin can legitimately produce differing results from the same
- // input data, depending on how that data is packaged.
- //
- // We'll go for option 2, adjusting the timestamps. Note in
- // particular that this means some results can differ from those
- // produced by SV.
-
-// std::cerr << "PluginInputDomainAdapter: sampleRate " << m_inputSampleRate << ", blocksize " << m_blockSize << ", adjusting time from " << timestamp;
-
- timestamp = timestamp + RealTime::frame2RealTime
- (m_blockSize/2, int(m_inputSampleRate + 0.5));
-
-// std::cerr << " to " << timestamp << std::endl;
-
- for (int c = 0; c < m_channels; ++c) {
-
- for (int i = 0; i < m_blockSize; ++i) {
- m_ri[i] = double(inputBuffers[c][i]) * m_window[i];
- }
-
- for (int i = 0; i < m_blockSize/2; ++i) {
- // FFT shift
- double value = m_ri[i];
- m_ri[i] = m_ri[i + m_blockSize/2];
- m_ri[i + m_blockSize/2] = value;
- }
-
-#ifdef HAVE_FFTW3
-
- fftw_execute(m_plan);
-
- for (int i = 0; i <= m_blockSize/2; ++i) {
- m_freqbuf[c][i * 2] = float(m_cbuf[i][0]);
- m_freqbuf[c][i * 2 + 1] = float(m_cbuf[i][1]);
- }
-
-#else
-
- fft(m_blockSize, false, m_ri, 0, m_ro, m_io);
-
- for (int i = 0; i <= m_blockSize/2; ++i) {
- m_freqbuf[c][i * 2] = float(m_ro[i]);
- m_freqbuf[c][i * 2 + 1] = float(m_io[i]);
- }
-
-#endif
- }
-
- return m_plugin->process(m_freqbuf, timestamp);
-}
-
-#ifndef HAVE_FFTW3
-
-void
-PluginInputDomainAdapter::Impl::fft(unsigned int n, bool inverse,
- double *ri, double *ii, double *ro, double *io)
-{
- if (!ri || !ro || !io) return;
-
- unsigned int bits;
- unsigned int i, j, k, m;
- unsigned int blockSize, blockEnd;
-
- double tr, ti;
-
- if (n < 2) return;
- if (n & (n-1)) return;
-
- double angle = 2.0 * M_PI;
- if (inverse) angle = -angle;
-
- for (i = 0; ; ++i) {
- if (n & (1 << i)) {
- bits = i;
- break;
- }
- }
-
- static unsigned int tableSize = 0;
- static int *table = 0;
-
- if (tableSize != n) {
-
- delete[] table;
-
- table = new int[n];
-
- for (i = 0; i < n; ++i) {
-
- m = i;
-
- for (j = k = 0; j < bits; ++j) {
- k = (k << 1) | (m & 1);
- m >>= 1;
- }
-
- table[i] = k;
- }
-
- tableSize = n;
- }
-
- if (ii) {
- for (i = 0; i < n; ++i) {
- ro[table[i]] = ri[i];
- io[table[i]] = ii[i];
- }
- } else {
- for (i = 0; i < n; ++i) {
- ro[table[i]] = ri[i];
- io[table[i]] = 0.0;
- }
- }
-
- blockEnd = 1;
-
- for (blockSize = 2; blockSize <= n; blockSize <<= 1) {
-
- double delta = angle / (double)blockSize;
- double sm2 = -sin(-2 * delta);
- double sm1 = -sin(-delta);
- double cm2 = cos(-2 * delta);
- double cm1 = cos(-delta);
- double w = 2 * cm1;
- double ar[3], ai[3];
-
- for (i = 0; i < n; i += blockSize) {
-
- ar[2] = cm2;
- ar[1] = cm1;
-
- ai[2] = sm2;
- ai[1] = sm1;
-
- for (j = i, m = 0; m < blockEnd; j++, m++) {
-
- ar[0] = w * ar[1] - ar[2];
- ar[2] = ar[1];
- ar[1] = ar[0];
-
- ai[0] = w * ai[1] - ai[2];
- ai[2] = ai[1];
- ai[1] = ai[0];
-
- k = j + blockEnd;
- tr = ar[0] * ro[k] - ai[0] * io[k];
- ti = ar[0] * io[k] + ai[0] * ro[k];
-
- ro[k] = ro[j] - tr;
- io[k] = io[j] - ti;
-
- ro[j] += tr;
- io[j] += ti;
- }
- }
-
- blockEnd = blockSize;
- }
-
- if (inverse) {
-
- double denom = (double)n;
-
- for (i = 0; i < n; i++) {
- ro[i] /= denom;
- io[i] /= denom;
- }
- }
-}
-
-#endif
-
-}
-
-}
-
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 _VAMP_PLUGIN_INPUT_DOMAIN_ADAPTER_H_
-#define _VAMP_PLUGIN_INPUT_DOMAIN_ADAPTER_H_
-
-#include "PluginWrapper.h"
-
-namespace Vamp {
-
-namespace HostExt {
-
-/**
- * \class PluginInputDomainAdapter PluginInputDomainAdapter.h <vamp-sdk/hostext/PluginInputDomainAdapter.h>
- *
- * PluginInputDomainAdapter is a Vamp plugin adapter that converts
- * time-domain input into frequency-domain input for plugins that need
- * it. This permits a host to use time- and frequency-domain plugins
- * interchangeably without needing to handle the conversion itself.
- *
- * This adapter uses a basic Hanning windowed FFT that supports
- * power-of-two block sizes only. If a frequency domain plugin
- * requests a non-power-of-two blocksize, the adapter will adjust it
- * to a nearby power of two instead. Thus, getPreferredBlockSize()
- * will always return a power of two if the wrapped plugin is a
- * frequency domain one. If the plugin doesn't accept the adjusted
- * power of two block size, initialise() will fail.
- *
- * The adapter provides no way for the host to discover whether the
- * underlying plugin is actually a time or frequency domain plugin
- * (except that if the preferred block size is not a power of two, it
- * must be a time domain plugin).
- *
- * The FFT implementation is simple and self-contained, but unlikely
- * to be the fastest available: a host can usually do better if it
- * cares enough.
- *
- * In every respect other than its input domain handling, the
- * PluginInputDomainAdapter behaves identically to the plugin that it
- * wraps. The wrapped plugin will be deleted when the wrapper is
- * deleted.
- *
- * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
- */
-
-class PluginInputDomainAdapter : public PluginWrapper
-{
-public:
- PluginInputDomainAdapter(Plugin *plugin); // I take ownership of plugin
- virtual ~PluginInputDomainAdapter();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
-
- InputDomain getInputDomain() const;
-
- size_t getPreferredStepSize() const;
- size_t getPreferredBlockSize() const;
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
-protected:
- class Impl;
- Impl *m_impl;
-};
-
-}
-
-}
-
-#endif
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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-sdk/PluginHostAdapter.h"
-#include "PluginLoader.h"
-#include "PluginInputDomainAdapter.h"
-#include "PluginChannelAdapter.h"
-#include "PluginBufferingAdapter.h"
-
-#include <string>
-#include <cstring>
-#include <fstream>
-#include <cctype> // tolower
-#include <cstring>
-
-#ifdef _WIN32
-
-#include <windows.h>
-#include <tchar.h>
-#define PLUGIN_SUFFIX "dll"
-
-#else /* ! _WIN32 */
-
-#include <dirent.h>
-#include <dlfcn.h>
-
-#ifdef __APPLE__
-#define PLUGIN_SUFFIX "dylib"
-#else /* ! __APPLE__ */
-#define PLUGIN_SUFFIX "so"
-#endif /* ! __APPLE__ */
-
-#endif /* ! _WIN32 */
-
-using namespace std;
-
-namespace Vamp {
-
-namespace HostExt {
-
-class PluginLoader::Impl
-{
-public:
- Impl();
- virtual ~Impl();
-
- PluginKeyList listPlugins();
-
- Plugin *loadPlugin(PluginKey key,
- float inputSampleRate,
- int adapterFlags);
-
- PluginKey composePluginKey(string libraryName, string identifier);
-
- PluginCategoryHierarchy getPluginCategory(PluginKey key);
-
- string getLibraryPathForPlugin(PluginKey key);
-
- static void setInstanceToClean(PluginLoader *instance);
-
-protected:
- class PluginDeletionNotifyAdapter : public PluginWrapper {
- public:
- PluginDeletionNotifyAdapter(Plugin *plugin, Impl *loader);
- virtual ~PluginDeletionNotifyAdapter();
- protected:
- Impl *m_loader;
- };
-
- class InstanceCleaner {
- public:
- InstanceCleaner() : m_instance(0) { }
- ~InstanceCleaner() { delete m_instance; }
- void setInstance(PluginLoader *instance) { m_instance = instance; }
- protected:
- PluginLoader *m_instance;
- };
-
- virtual void pluginDeleted(PluginDeletionNotifyAdapter *adapter);
-
- map<PluginKey, string> m_pluginLibraryNameMap;
- bool m_allPluginsEnumerated;
- void enumeratePlugins(PluginKey forPlugin = "");
-
- map<PluginKey, PluginCategoryHierarchy> m_taxonomy;
- void generateTaxonomy();
-
- map<Plugin *, void *> m_pluginLibraryHandleMap;
-
- bool decomposePluginKey(PluginKey key,
- string &libraryName, string &identifier);
-
- void *loadLibrary(string path);
- void unloadLibrary(void *handle);
- void *lookupInLibrary(void *handle, const char *symbol);
-
- string splicePath(string a, string b);
- vector<string> listFiles(string dir, string ext);
-
- static InstanceCleaner m_cleaner;
-};
-
-PluginLoader *
-PluginLoader::m_instance = 0;
-
-PluginLoader::Impl::InstanceCleaner
-PluginLoader::Impl::m_cleaner;
-
-PluginLoader::PluginLoader()
-{
- m_impl = new Impl();
-}
-
-PluginLoader::~PluginLoader()
-{
- delete m_impl;
-}
-
-PluginLoader *
-PluginLoader::getInstance()
-{
- if (!m_instance) {
- // The cleaner doesn't own the instance, because we leave the
- // instance pointer in the base class for binary backwards
- // compatibility reasons and to avoid waste
- m_instance = new PluginLoader();
- Impl::setInstanceToClean(m_instance);
- }
- return m_instance;
-}
-
-vector<PluginLoader::PluginKey>
-PluginLoader::listPlugins()
-{
- return m_impl->listPlugins();
-}
-
-Plugin *
-PluginLoader::loadPlugin(PluginKey key,
- float inputSampleRate,
- int adapterFlags)
-{
- return m_impl->loadPlugin(key, inputSampleRate, adapterFlags);
-}
-
-PluginLoader::PluginKey
-PluginLoader::composePluginKey(string libraryName, string identifier)
-{
- return m_impl->composePluginKey(libraryName, identifier);
-}
-
-PluginLoader::PluginCategoryHierarchy
-PluginLoader::getPluginCategory(PluginKey key)
-{
- return m_impl->getPluginCategory(key);
-}
-
-string
-PluginLoader::getLibraryPathForPlugin(PluginKey key)
-{
- return m_impl->getLibraryPathForPlugin(key);
-}
-
-PluginLoader::Impl::Impl() :
- m_allPluginsEnumerated(false)
-{
-}
-
-PluginLoader::Impl::~Impl()
-{
-}
-
-void
-PluginLoader::Impl::setInstanceToClean(PluginLoader *instance)
-{
- m_cleaner.setInstance(instance);
-}
-
-vector<PluginLoader::PluginKey>
-PluginLoader::Impl::listPlugins()
-{
- if (!m_allPluginsEnumerated) enumeratePlugins();
-
- vector<PluginKey> plugins;
- for (map<PluginKey, string>::iterator mi = m_pluginLibraryNameMap.begin();
- mi != m_pluginLibraryNameMap.end(); ++mi) {
- plugins.push_back(mi->first);
- }
-
- return plugins;
-}
-
-void
-PluginLoader::Impl::enumeratePlugins(PluginKey forPlugin)
-{
- vector<string> path = PluginHostAdapter::getPluginPath();
-
- string libraryName, identifier;
- if (forPlugin != "") {
- if (!decomposePluginKey(forPlugin, libraryName, identifier)) {
- std::cerr << "WARNING: Vamp::HostExt::PluginLoader: Invalid plugin key \""
- << forPlugin << "\" in enumerate" << std::endl;
- return;
- }
- }
-
- for (size_t i = 0; i < path.size(); ++i) {
-
- vector<string> files = listFiles(path[i], PLUGIN_SUFFIX);
-
- for (vector<string>::iterator fi = files.begin();
- fi != files.end(); ++fi) {
-
- if (libraryName != "") {
- // libraryName is lowercased and lacking an extension,
- // as it came from the plugin key
- string temp = *fi;
- for (size_t i = 0; i < temp.length(); ++i) {
- temp[i] = tolower(temp[i]);
- }
- string::size_type pi = temp.find('.');
- if (pi == string::npos) {
- if (libraryName != temp) continue;
- } else {
- if (libraryName != temp.substr(0, pi)) continue;
- }
- }
-
- string fullPath = path[i];
- fullPath = splicePath(fullPath, *fi);
- void *handle = loadLibrary(fullPath);
- if (!handle) continue;
-
- VampGetPluginDescriptorFunction fn =
- (VampGetPluginDescriptorFunction)lookupInLibrary
- (handle, "vampGetPluginDescriptor");
-
- if (!fn) {
- unloadLibrary(handle);
- continue;
- }
-
- int index = 0;
- const VampPluginDescriptor *descriptor = 0;
-
- while ((descriptor = fn(VAMP_API_VERSION, index))) {
- ++index;
- if (identifier != "") {
- if (descriptor->identifier != identifier) continue;
- }
- PluginKey key = composePluginKey(*fi, descriptor->identifier);
-// std::cerr << "enumerate: " << key << " (path: " << fullPath << ")" << std::endl;
- if (m_pluginLibraryNameMap.find(key) ==
- m_pluginLibraryNameMap.end()) {
- m_pluginLibraryNameMap[key] = fullPath;
- }
- }
-
- unloadLibrary(handle);
- }
- }
-
- if (forPlugin == "") m_allPluginsEnumerated = true;
-}
-
-PluginLoader::PluginKey
-PluginLoader::Impl::composePluginKey(string libraryName, string identifier)
-{
- string basename = libraryName;
-
- string::size_type li = basename.rfind('/');
- if (li != string::npos) basename = basename.substr(li + 1);
-
- li = basename.find('.');
- if (li != string::npos) basename = basename.substr(0, li);
-
- for (size_t i = 0; i < basename.length(); ++i) {
- basename[i] = tolower(basename[i]);
- }
-
- return basename + ":" + identifier;
-}
-
-bool
-PluginLoader::Impl::decomposePluginKey(PluginKey key,
- string &libraryName,
- string &identifier)
-{
- string::size_type ki = key.find(':');
- if (ki == string::npos) {
- return false;
- }
-
- libraryName = key.substr(0, ki);
- identifier = key.substr(ki + 1);
- return true;
-}
-
-PluginLoader::PluginCategoryHierarchy
-PluginLoader::Impl::getPluginCategory(PluginKey plugin)
-{
- if (m_taxonomy.empty()) generateTaxonomy();
- if (m_taxonomy.find(plugin) == m_taxonomy.end()) {
- return PluginCategoryHierarchy();
- }
- return m_taxonomy[plugin];
-}
-
-string
-PluginLoader::Impl::getLibraryPathForPlugin(PluginKey plugin)
-{
- if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
- if (m_allPluginsEnumerated) return "";
- enumeratePlugins(plugin);
- }
- if (m_pluginLibraryNameMap.find(plugin) == m_pluginLibraryNameMap.end()) {
- return "";
- }
- return m_pluginLibraryNameMap[plugin];
-}
-
-Plugin *
-PluginLoader::Impl::loadPlugin(PluginKey key,
- float inputSampleRate, int adapterFlags)
-{
- string libname, identifier;
- if (!decomposePluginKey(key, libname, identifier)) {
- std::cerr << "Vamp::HostExt::PluginLoader: Invalid plugin key \""
- << key << "\" in loadPlugin" << std::endl;
- return 0;
- }
-
- string fullPath = getLibraryPathForPlugin(key);
- if (fullPath == "") return 0;
-
- void *handle = loadLibrary(fullPath);
- if (!handle) return 0;
-
- VampGetPluginDescriptorFunction fn =
- (VampGetPluginDescriptorFunction)lookupInLibrary
- (handle, "vampGetPluginDescriptor");
-
- if (!fn) {
- unloadLibrary(handle);
- return 0;
- }
-
- int index = 0;
- const VampPluginDescriptor *descriptor = 0;
-
- while ((descriptor = fn(VAMP_API_VERSION, index))) {
-
- if (string(descriptor->identifier) == identifier) {
-
- Vamp::PluginHostAdapter *plugin =
- new Vamp::PluginHostAdapter(descriptor, inputSampleRate);
-
- Plugin *adapter = new PluginDeletionNotifyAdapter(plugin, this);
-
- m_pluginLibraryHandleMap[adapter] = handle;
-
- if (adapterFlags & ADAPT_INPUT_DOMAIN) {
- if (adapter->getInputDomain() == Plugin::FrequencyDomain) {
- adapter = new PluginInputDomainAdapter(adapter);
- }
- }
-
- if (adapterFlags & ADAPT_BUFFER_SIZE) {
- adapter = new PluginBufferingAdapter(adapter);
- }
-
- if (adapterFlags & ADAPT_CHANNEL_COUNT) {
- adapter = new PluginChannelAdapter(adapter);
- }
-
- return adapter;
- }
-
- ++index;
- }
-
- cerr << "Vamp::HostExt::PluginLoader: Plugin \""
- << identifier << "\" not found in library \""
- << fullPath << "\"" << endl;
-
- return 0;
-}
-
-void
-PluginLoader::Impl::generateTaxonomy()
-{
-// cerr << "PluginLoader::Impl::generateTaxonomy" << endl;
-
- vector<string> path = PluginHostAdapter::getPluginPath();
- string libfragment = "/lib/";
- vector<string> catpath;
-
- string suffix = "cat";
-
- for (vector<string>::iterator i = path.begin();
- i != path.end(); ++i) {
-
- // It doesn't matter that we're using literal forward-slash in
- // this bit, as it's only relevant if the path contains
- // "/lib/", which is only meaningful and only plausible on
- // systems with forward-slash delimiters
-
- string dir = *i;
- string::size_type li = dir.find(libfragment);
-
- if (li != string::npos) {
- catpath.push_back
- (dir.substr(0, li)
- + "/share/"
- + dir.substr(li + libfragment.length()));
- }
-
- catpath.push_back(dir);
- }
-
- char buffer[1024];
-
- for (vector<string>::iterator i = catpath.begin();
- i != catpath.end(); ++i) {
-
- vector<string> files = listFiles(*i, suffix);
-
- for (vector<string>::iterator fi = files.begin();
- fi != files.end(); ++fi) {
-
- string filepath = splicePath(*i, *fi);
- ifstream is(filepath.c_str(), ifstream::in | ifstream::binary);
-
- if (is.fail()) {
-// cerr << "failed to open: " << filepath << endl;
- continue;
- }
-
-// cerr << "opened: " << filepath << endl;
-
- while (!!is.getline(buffer, 1024)) {
-
- string line(buffer);
-
-// cerr << "line = " << line << endl;
-
- string::size_type di = line.find("::");
- if (di == string::npos) continue;
-
- string id = line.substr(0, di);
- string encodedCat = line.substr(di + 2);
-
- if (id.substr(0, 5) != "vamp:") continue;
- id = id.substr(5);
-
- while (encodedCat.length() >= 1 &&
- encodedCat[encodedCat.length()-1] == '\r') {
- encodedCat = encodedCat.substr(0, encodedCat.length()-1);
- }
-
-// cerr << "id = " << id << ", cat = " << encodedCat << endl;
-
- PluginCategoryHierarchy category;
- string::size_type ai;
- while ((ai = encodedCat.find(" > ")) != string::npos) {
- category.push_back(encodedCat.substr(0, ai));
- encodedCat = encodedCat.substr(ai + 3);
- }
- if (encodedCat != "") category.push_back(encodedCat);
-
- m_taxonomy[id] = category;
- }
- }
- }
-}
-
-void *
-PluginLoader::Impl::loadLibrary(string path)
-{
- void *handle = 0;
-#ifdef _WIN32
- handle = LoadLibrary(path.c_str());
- if (!handle) {
- cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
- << path << "\"" << endl;
- }
-#else
- handle = dlopen(path.c_str(), RTLD_LAZY);
- if (!handle) {
- cerr << "Vamp::HostExt::PluginLoader: Unable to load library \""
- << path << "\": " << dlerror() << endl;
- }
-#endif
- return handle;
-}
-
-void
-PluginLoader::Impl::unloadLibrary(void *handle)
-{
-#ifdef _WIN32
- FreeLibrary((HINSTANCE)handle);
-#else
- dlclose(handle);
-#endif
-}
-
-void *
-PluginLoader::Impl::lookupInLibrary(void *handle, const char *symbol)
-{
-#ifdef _WIN32
- return (void *)GetProcAddress((HINSTANCE)handle, symbol);
-#else
- return (void *)dlsym(handle, symbol);
-#endif
-}
-
-string
-PluginLoader::Impl::splicePath(string a, string b)
-{
-#ifdef _WIN32
- return a + "\\" + b;
-#else
- return a + "/" + b;
-#endif
-}
-
-vector<string>
-PluginLoader::Impl::listFiles(string dir, string extension)
-{
- vector<string> files;
-
-#ifdef _WIN32
-
- string expression = dir + "\\*." + extension;
- WIN32_FIND_DATA data;
- HANDLE fh = FindFirstFile(expression.c_str(), &data);
- if (fh == INVALID_HANDLE_VALUE) return files;
-
- bool ok = true;
- while (ok) {
- files.push_back(data.cFileName);
- ok = FindNextFile(fh, &data);
- }
-
- FindClose(fh);
-
-#else
-
- size_t extlen = extension.length();
- DIR *d = opendir(dir.c_str());
- if (!d) return files;
-
- struct dirent *e = 0;
- while ((e = readdir(d))) {
-
- if (!(e->d_type & DT_REG) && (e->d_type != DT_UNKNOWN)) continue;
-
- if (!e->d_name) continue;
-
- size_t len = strlen(e->d_name);
- if (len < extlen + 2 ||
- e->d_name + len - extlen - 1 != "." + extension) {
- continue;
- }
-
- files.push_back(e->d_name);
- }
-
- closedir(d);
-#endif
-
- return files;
-}
-
-void
-PluginLoader::Impl::pluginDeleted(PluginDeletionNotifyAdapter *adapter)
-{
- void *handle = m_pluginLibraryHandleMap[adapter];
- if (handle) unloadLibrary(handle);
- m_pluginLibraryHandleMap.erase(adapter);
-}
-
-PluginLoader::Impl::PluginDeletionNotifyAdapter::PluginDeletionNotifyAdapter(Plugin *plugin,
- Impl *loader) :
- PluginWrapper(plugin),
- m_loader(loader)
-{
-}
-
-PluginLoader::Impl::PluginDeletionNotifyAdapter::~PluginDeletionNotifyAdapter()
-{
- // We need to delete the plugin before calling pluginDeleted, as
- // the delete call may require calling through to the descriptor
- // (for e.g. cleanup) but pluginDeleted may unload the required
- // library for the call. To prevent a double deletion when our
- // parent's destructor runs (after this one), be sure to set
- // m_plugin to 0 after deletion.
- delete m_plugin;
- m_plugin = 0;
-
- if (m_loader) m_loader->pluginDeleted(this);
-}
-
-}
-
-}
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 _VAMP_PLUGIN_LOADER_H_
-#define _VAMP_PLUGIN_LOADER_H_
-
-#include <vector>
-#include <string>
-#include <map>
-
-#include "PluginWrapper.h"
-
-namespace Vamp {
-
-class Plugin;
-
-namespace HostExt {
-
-/**
- * \class PluginLoader PluginLoader.h <vamp-sdk/hostext/PluginLoader.h>
- *
- * Vamp::HostExt::PluginLoader is a convenience class for discovering
- * and loading Vamp plugins using the typical plugin-path, library
- * naming, and categorisation conventions described in the Vamp SDK
- * documentation. This class is intended to greatly simplify the task
- * of becoming a Vamp plugin host for any C++ application.
- *
- * Hosts are not required by the Vamp specification to use the same
- * plugin search path and naming conventions as implemented by this
- * class, and are certainly not required to use this actual class.
- * But we do strongly recommend it.
- *
- * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
- */
-
-class PluginLoader
-{
-public:
- /**
- * Obtain a pointer to the singleton instance of PluginLoader.
- * Use this to obtain your loader object.
- */
- static PluginLoader *getInstance();
-
- /**
- * PluginKey is a string type that is used to identify a plugin
- * uniquely within the scope of "the current system". It consists
- * of the lower-cased base name of the plugin library, a colon
- * separator, and the identifier string for the plugin. It is
- * only meaningful in the context of a given plugin path (the one
- * returned by PluginHostAdapter::getPluginPath()).
- *
- * Use composePluginKey() to construct a plugin key from a known
- * plugin library name and identifier.
- *
- * Note: the fact that the library component of the key is
- * lower-cased implies that library names are matched
- * case-insensitively by the PluginLoader class, regardless of the
- * case sensitivity of the underlying filesystem. (Plugin
- * identifiers _are_ case sensitive, however.) Also, it is not
- * possible to portably extract a working library name from a
- * plugin key, as the result may fail on case-sensitive
- * filesystems. Use getLibraryPathForPlugin() instead.
- */
- typedef std::string PluginKey;
-
- /**
- * PluginKeyList is a sequence of plugin keys, such as returned by
- * listPlugins().
- */
- typedef std::vector<PluginKey> PluginKeyList;
-
- /**
- * PluginCategoryHierarchy is a sequence of general->specific
- * category names, as may be associated with a single plugin.
- * This sequence describes the location of a plugin within a
- * category forest, containing the human-readable names of the
- * plugin's category tree root, followed by each of the nodes down
- * to the leaf containing the plugin.
- *
- * \see getPluginCategory()
- */
- typedef std::vector<std::string> PluginCategoryHierarchy;
-
- /**
- * Search for all available Vamp plugins, and return a list of
- * them in the order in which they were found.
- */
- PluginKeyList listPlugins();
-
- /**
- * AdapterFlags contains a set of values that may be OR'd together
- * to indicate in which circumstances PluginLoader should use a
- * plugin adapter to make a plugin easier to use for a host that
- * does not want to cater for complex features.
- *
- * The available flags are:
- *
- * ADAPT_INPUT_DOMAIN - If the plugin expects frequency domain
- * input, wrap it in a PluginInputDomainAdapter that automatically
- * converts the plugin to one that expects time-domain input.
- * This enables a host to accommodate time- and frequency-domain
- * plugins without needing to do any conversion itself.
- *
- * ADAPT_CHANNEL_COUNT - Wrap the plugin in a PluginChannelAdapter
- * to handle any mismatch between the number of channels of audio
- * the plugin can handle and the number available in the host.
- * This enables a host to use plugins that may require the input
- * to be mixed down to mono, etc., without having to worry about
- * doing that itself.
- *
- * ADAPT_BUFFER_SIZE - Wrap the plugin in a PluginBufferingAdapter
- * permitting the host to provide audio input using any block
- * size, with no overlap, regardless of the plugin's preferred
- * block size (suitable for hosts that read from non-seekable
- * streaming media, for example). This adapter introduces some
- * run-time overhead and also changes the semantics of the plugin
- * slightly (see the PluginBufferingAdapter header documentation
- * for details).
- *
- * ADAPT_ALL_SAFE - Perform all available adaptations that are
- * meaningful for the plugin and "safe". Currently this means to
- * ADAPT_INPUT_DOMAIN if the plugin wants FrequencyDomain input;
- * ADAPT_CHANNEL_COUNT always; and ADAPT_BUFFER_SIZE never.
- *
- * ADAPT_ALL - Perform all available adaptations that are
- * meaningful for the plugin.
- *
- * See PluginInputDomainAdapter, PluginChannelAdapter and
- * PluginBufferingAdapter for more details of the classes that the
- * loader may use if these flags are set.
- */
- enum AdapterFlags {
-
- ADAPT_INPUT_DOMAIN = 0x01,
- ADAPT_CHANNEL_COUNT = 0x02,
- ADAPT_BUFFER_SIZE = 0x04,
-
- ADAPT_ALL_SAFE = 0x03,
-
- ADAPT_ALL = 0xff
- };
-
- /**
- * Load a Vamp plugin, given its identifying key. If the plugin
- * could not be loaded, returns 0.
- *
- * The returned plugin should be deleted (using the standard C++
- * delete keyword) after use.
- *
- * \param adapterFlags a bitwise OR of the values in the AdapterFlags
- * enumeration, indicating under which circumstances an adapter should be
- * used to wrap the original plugin. If adapterFlags is 0, no
- * optional adapters will be used. Otherwise, the returned plugin
- * may be of an adapter class type which will behave identically
- * to the original plugin, apart from any particular features
- * implemented by the adapter itself.
- *
- * \see AdapterFlags, PluginInputDomainAdapter, PluginChannelAdapter
- */
- Plugin *loadPlugin(PluginKey key,
- float inputSampleRate,
- int adapterFlags = 0);
-
- /**
- * Given a Vamp plugin library name and plugin identifier, return
- * the corresponding plugin key in a form suitable for passing in to
- * loadPlugin().
- */
- PluginKey composePluginKey(std::string libraryName,
- std::string identifier);
-
- /**
- * Return the category hierarchy for a Vamp plugin, given its
- * identifying key.
- *
- * If the plugin has no category information, return an empty
- * hierarchy.
- *
- * \see PluginCategoryHierarchy
- */
- PluginCategoryHierarchy getPluginCategory(PluginKey plugin);
-
- /**
- * Return the file path of the dynamic library from which the
- * given plugin will be loaded (if available).
- */
- std::string getLibraryPathForPlugin(PluginKey plugin);
-
-protected:
- PluginLoader();
- virtual ~PluginLoader();
-
- class Impl;
- Impl *m_impl;
-
- static PluginLoader *m_instance;
-};
-
-}
-
-}
-
-#endif
-
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 "PluginWrapper.h"
-
-namespace Vamp {
-
-namespace HostExt {
-
-class PluginRateExtractor : public Plugin
-{
-public:
- PluginRateExtractor() : Plugin(0) { }
- float getRate() const { return m_inputSampleRate; }
-};
-
-PluginWrapper::PluginWrapper(Plugin *plugin) :
- Plugin(((PluginRateExtractor *)plugin)->getRate()),
- m_plugin(plugin)
-{
-}
-
-PluginWrapper::~PluginWrapper()
-{
- delete m_plugin;
-}
-
-bool
-PluginWrapper::initialise(size_t channels, size_t stepSize, size_t blockSize)
-{
- return m_plugin->initialise(channels, stepSize, blockSize);
-}
-
-void
-PluginWrapper::reset()
-{
- m_plugin->reset();
-}
-
-Plugin::InputDomain
-PluginWrapper::getInputDomain() const
-{
- return m_plugin->getInputDomain();
-}
-
-unsigned int
-PluginWrapper::getVampApiVersion() const
-{
- return m_plugin->getVampApiVersion();
-}
-
-std::string
-PluginWrapper::getIdentifier() const
-{
- return m_plugin->getIdentifier();
-}
-
-std::string
-PluginWrapper::getName() const
-{
- return m_plugin->getName();
-}
-
-std::string
-PluginWrapper::getDescription() const
-{
- return m_plugin->getDescription();
-}
-
-std::string
-PluginWrapper::getMaker() const
-{
- return m_plugin->getMaker();
-}
-
-int
-PluginWrapper::getPluginVersion() const
-{
- return m_plugin->getPluginVersion();
-}
-
-std::string
-PluginWrapper::getCopyright() const
-{
- return m_plugin->getCopyright();
-}
-
-PluginBase::ParameterList
-PluginWrapper::getParameterDescriptors() const
-{
- return m_plugin->getParameterDescriptors();
-}
-
-float
-PluginWrapper::getParameter(std::string parameter) const
-{
- return m_plugin->getParameter(parameter);
-}
-
-void
-PluginWrapper::setParameter(std::string parameter, float value)
-{
- m_plugin->setParameter(parameter, value);
-}
-
-PluginBase::ProgramList
-PluginWrapper::getPrograms() const
-{
- return m_plugin->getPrograms();
-}
-
-std::string
-PluginWrapper::getCurrentProgram() const
-{
- return m_plugin->getCurrentProgram();
-}
-
-void
-PluginWrapper::selectProgram(std::string program)
-{
- m_plugin->selectProgram(program);
-}
-
-size_t
-PluginWrapper::getPreferredStepSize() const
-{
- return m_plugin->getPreferredStepSize();
-}
-
-size_t
-PluginWrapper::getPreferredBlockSize() const
-{
- return m_plugin->getPreferredBlockSize();
-}
-
-size_t
-PluginWrapper::getMinChannelCount() const
-{
- return m_plugin->getMinChannelCount();
-}
-
-size_t PluginWrapper::getMaxChannelCount() const
-{
- return m_plugin->getMaxChannelCount();
-}
-
-Plugin::OutputList
-PluginWrapper::getOutputDescriptors() const
-{
- return m_plugin->getOutputDescriptors();
-}
-
-Plugin::FeatureSet
-PluginWrapper::process(const float *const *inputBuffers, RealTime timestamp)
-{
- return m_plugin->process(inputBuffers, timestamp);
-}
-
-Plugin::FeatureSet
-PluginWrapper::getRemainingFeatures()
-{
- return m_plugin->getRemainingFeatures();
-}
-
-}
-
-}
-
+++ /dev/null
-/* -*- 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-2007 Chris Cannam and QMUL.
-
- 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 _VAMP_PLUGIN_WRAPPER_H_
-#define _VAMP_PLUGIN_WRAPPER_H_
-
-#include <vamp-sdk/Plugin.h>
-
-namespace Vamp {
-
-namespace HostExt {
-
-/**
- * \class PluginWrapper PluginWrapper.h <vamp-sdk/hostext/PluginWrapper.h>
- *
- * PluginWrapper is a simple base class for adapter plugins. It takes
- * a pointer to a "to be wrapped" Vamp plugin on construction, and
- * provides implementations of all the Vamp plugin methods that simply
- * delegate through to the wrapped plugin. A subclass can therefore
- * override only the methods that are meaningful for the particular
- * adapter.
- *
- * \note This class was introduced in version 1.1 of the Vamp plugin SDK.
- */
-
-class PluginWrapper : public Plugin
-{
-public:
- virtual ~PluginWrapper();
-
- bool initialise(size_t channels, size_t stepSize, size_t blockSize);
- void reset();
-
- InputDomain getInputDomain() const;
-
- unsigned int getVampApiVersion() const;
- std::string getIdentifier() const;
- std::string getName() const;
- std::string getDescription() const;
- std::string getMaker() const;
- int getPluginVersion() const;
- std::string getCopyright() const;
-
- ParameterList getParameterDescriptors() const;
- float getParameter(std::string) const;
- void setParameter(std::string, float);
-
- ProgramList getPrograms() const;
- std::string getCurrentProgram() const;
- void selectProgram(std::string);
-
- size_t getPreferredStepSize() const;
- size_t getPreferredBlockSize() const;
-
- size_t getMinChannelCount() const;
- size_t getMaxChannelCount() const;
-
- OutputList getOutputDescriptors() const;
-
- FeatureSet process(const float *const *inputBuffers, RealTime timestamp);
-
- FeatureSet getRemainingFeatures();
-
-protected:
- PluginWrapper(Plugin *plugin); // I take ownership of plugin
- Plugin *m_plugin;
-};
-
-}
-
-}
-
-#endif
--- /dev/null
+/* -*- 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 _VAMP_SDK_PLUGGUARD_H_
+#define _VAMP_SDK_PLUGGUARD_H_
+
+/**
+ * Normal usage should be:
+ *
+ * - Plugins include vamp-sdk/Plugin.h or vamp-sdk/PluginBase.h.
+ * These files include this header, which specifies an appropriate
+ * namespace for the plugin classes to avoid any risk of conflict
+ * with non-plugin class implementations in the host on load.
+ *
+ * - Hosts include vamp-hostsdk/Plugin.h, vamp-hostsdk/PluginBase.h,
+ * vamp-hostsdk/PluginHostAdapter, vamp-hostsdk/PluginLoader.h etc.
+ * These files include vamp-hostsdk/hostguard.h, which makes a note
+ * that we are in a host. A file such as vamp-hostsdk/Plugin.h
+ * then simply includes vamp-sdk/Plugin.h, and this guard header
+ * takes notice of the fact that it has been included from a host
+ * and leaves the plugin namespace unset.
+ *
+ * Problems will occur when a host includes files directly from the
+ * vamp-sdk directory. There are two reasons this might happen:
+ * mistake, perhaps owing to ignorance of the fact that this isn't
+ * allowed (particularly since it was the normal mechanism in v1 of
+ * the SDK); and a wish to incorporate plugin code directly into the
+ * host rather than having to load it.
+ *
+ * What if the host does include a vamp-sdk header by mistake? We can
+ * catch it if it's included before something from vamp-hostsdk. If
+ * it's included after something from vamp-hostsdk, it will work OK
+ * anyway. The remaining problem case is where nothing from
+ * vamp-hostsdk is included in the same file. We can't catch that.
+ */
+
+#ifndef _VAMP_IN_HOSTSDK
+
+#define _VAMP_IN_PLUGINSDK 1
+
+#ifdef _VAMP_NO_PLUGIN_NAMESPACE
+#define _VAMP_SDK_PLUGSPACE_BEGIN(h)
+#define _VAMP_SDK_PLUGSPACE_END(h)
+#else
+#ifdef _VAMP_PLUGIN_IN_HOST_NAMESPACE
+#define _VAMP_SDK_PLUGSPACE_BEGIN(h) \
+ namespace _VampHost {
+
+#define _VAMP_SDK_PLUGSPACE_END(h) \
+ } \
+ using namespace _VampHost;
+#else
+#define _VAMP_SDK_PLUGSPACE_BEGIN(h) \
+ namespace _VampPlugin {
+
+#define _VAMP_SDK_PLUGSPACE_END(h) \
+ } \
+ using namespace _VampPlugin;
+#endif
+#endif
+
+#endif
+
+#endif
+
--- /dev/null
+/* -*- 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 _VAMP_SDK_SINGLE_INCLUDE_H_
+#define _VAMP_SDK_SINGLE_INCLUDE_H_
+
+#include "PluginBase.h"
+#include "Plugin.h"
+#include "RealTime.h"
+
+#endif
+
+
* See also the vampApiVersion field in the plugin descriptor, and the
* hostApiVersion argument to the vampGetPluginDescriptor function.
*/
-#define VAMP_API_VERSION 1
+#define VAMP_API_VERSION 2
/**
* C language API for Vamp plugins.
"Resolution" of result, if sampleType is vampVariableSampleRate. */
float sampleRate;
+ /** 1 if the returned results for this output are known to have a
+ duration field.
+
+ This field is new in Vamp API version 2; it must not be tested
+ for plugins that report an older API version in their plugin
+ descriptor.
+ */
+ int hasDuration;
+
} VampOutputDescriptor;
typedef struct _VampFeature
} VampFeature;
+typedef struct _VampFeatureV2
+{
+ /** 1 if the feature has a duration. */
+ int hasDuration;
+
+ /** Seconds component of duratiion. */
+ int durationSec;
+
+ /** Nanoseconds component of duration. */
+ int durationNsec;
+
+} VampFeatureV2;
+
+typedef union _VampFeatureUnion
+{
+ // sizeof(featureV1) >= sizeof(featureV2) for backward compatibility
+ VampFeature v1;
+ VampFeatureV2 v2;
+
+} VampFeatureUnion;
+
typedef struct _VampFeatureList
{
/** Number of features in this feature list. */
unsigned int featureCount;
- /** Features in this feature list. May be NULL if featureCount is zero. */
- VampFeature *features;
+ /** Features in this feature list. May be NULL if featureCount is
+ zero.
+
+ If present, this array must contain featureCount feature
+ structures for a Vamp API version 1 plugin, or 2*featureCount
+ feature unions for a Vamp API version 2 plugin.
+
+ The features returned by an API version 2 plugin must consist
+ of the same feature structures as in API version 1 for the
+ first featureCount array elements, followed by featureCount
+ unions that contain VampFeatureV2 structures (or NULL pointers
+ if no V2 feature structures are present).
+ */
+ VampFeatureUnion *features;
} VampFeatureList;
handle, or releaseOutputDescriptor for this descriptor. Host
must call releaseOutputDescriptor after use. */
VampOutputDescriptor *(*getOutputDescriptor)(VampPluginHandle,
- unsigned int);
+ unsigned int);
/** Destroy a descriptor for a feature output. */
void (*releaseOutputDescriptor)(VampOutputDescriptor *);
} VampPluginDescriptor;
+
/** Get the descriptor for a given plugin index in this library.
Return NULL if the index is outside the range of valid indices for
this plugin library.
field for its actual compatibility level, the host should be able
to do the right thing with it: use it if possible, discard it
otherwise.
+
+ This is the only symbol that a Vamp plugin actually needs to
+ export from its shared object; all others can be hidden. See the
+ accompanying documentation for notes on how to achieve this with
+ certain compilers.
*/
const VampPluginDescriptor *vampGetPluginDescriptor
(unsigned int hostApiVersion, unsigned int index);
+
/** Function pointer type for vampGetPluginDescriptor. */
typedef const VampPluginDescriptor *(*VampGetPluginDescriptorFunction)
(unsigned int, unsigned int);
projects / ardour.git / commitdiff