libs/vamp-plugins/ZeroCrossing.cpp

   1 /* -*- c-basic-offset: 4 indent-tabs-mode: nil -*-  vi:set ts=8 sts=4 sw=4: */
   2
   3 /*
   4     Vamp
   5
   6     An API for audio analysis and feature extraction plugins.
   7
   8     Centre for Digital Music, Queen Mary, University of London.
   9     Copyright 2006 Chris Cannam.
  10
  11     Permission is hereby granted, free of charge, to any person
  12     obtaining a copy of this software and associated documentation
  13     files (the "Software"), to deal in the Software without
  14     restriction, including without limitation the rights to use, copy,
  15     modify, merge, publish, distribute, sublicense, and/or sell copies
  16     of the Software, and to permit persons to whom the Software is
  17     furnished to do so, subject to the following conditions:
  18
  19     The above copyright notice and this permission notice shall be
  20     included in all copies or substantial portions of the Software.
  21
  22     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24     MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
  26     ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
  27     CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29
  30     Except as contained in this notice, the names of the Centre for
  31     Digital Music; Queen Mary, University of London; and Chris Cannam
  32     shall not be used in advertising or otherwise to promote the sale,
  33     use or other dealings in this Software without prior written
  34     authorization.
  35 */
  36
  37 #include "ZeroCrossing.h"
  38
  39 using std::string;
  40 using std::vector;
  41 using std::cerr;
  42 using std::endl;
  43
  44
  45 ZeroCrossing::ZeroCrossing(float inputSampleRate) :
  46     Plugin(inputSampleRate),
  47     m_stepSize(0),
  48     m_previousSample(0.0f)
  49 {
  50 }
  51
  52 ZeroCrossing::~ZeroCrossing()
  53 {
  54 }
  55
  56 string
  57 ZeroCrossing::getIdentifier() const
  58 {
  59     return "zerocrossing";
  60 }
  61
  62 string
  63 ZeroCrossing::getName() const
  64 {
  65     return "Zero Crossings";
  66 }
  67
  68 string
  69 ZeroCrossing::getDescription() const
  70 {
  71     return "Detect and count zero crossing points";
  72 }
  73
  74 string
  75 ZeroCrossing::getMaker() const
  76 {
  77     return "Vamp SDK Example Plugins";
  78 }
  79
  80 int
  81 ZeroCrossing::getPluginVersion() const
  82 {
  83     return 2;
  84 }
  85
  86 string
  87 ZeroCrossing::getCopyright() const
  88 {
  89     return "Freely redistributable (BSD license)";
  90 }
  91
  92 bool
  93 ZeroCrossing::initialise(size_t channels, size_t stepSize, size_t blockSize)
  94 {
  95     if (channels < getMinChannelCount() ||
  96         channels > getMaxChannelCount()) return false;
  97
  98     m_stepSize = std::min(stepSize, blockSize);
  99
 100     return true;
 101 }
 102
 103 void
 104 ZeroCrossing::reset()
 105 {
 106     m_previousSample = 0.0f;
 107 }
 108
 109 ZeroCrossing::OutputList
 110 ZeroCrossing::getOutputDescriptors() const
 111 {
 112     OutputList list;
 113
 114     OutputDescriptor zc;
 115     zc.identifier = "counts";
 116     zc.name = "Zero Crossing Counts";
 117     zc.description = "The number of zero crossing points per processing block";
 118     zc.unit = "crossings";
 119     zc.hasFixedBinCount = true;
 120     zc.binCount = 1;
 121     zc.hasKnownExtents = false;
 122     zc.isQuantized = true;
 123     zc.quantizeStep = 1.0;
 124     zc.sampleType = OutputDescriptor::OneSamplePerStep;
 125     list.push_back(zc);
 126
 127     zc.identifier = "zerocrossings";
 128     zc.name = "Zero Crossings";
 129     zc.description = "The locations of zero crossing points";
 130     zc.unit = "";
 131     zc.hasFixedBinCount = true;
 132     zc.binCount = 0;
 133     zc.sampleType = OutputDescriptor::VariableSampleRate;
 134     zc.sampleRate = m_inputSampleRate;
 135     list.push_back(zc);
 136
 137     return list;
 138 }
 139
 140 ZeroCrossing::FeatureSet
 141 ZeroCrossing::process(const float *const *inputBuffers,
 142                       Vamp::RealTime timestamp)
 143 {
 144     if (m_stepSize == 0) {
 145         cerr << "ERROR: ZeroCrossing::process: "
 146              << "ZeroCrossing has not been initialised"
 147              << endl;
 148         return FeatureSet();
 149     }
 150
 151     float prev = m_previousSample;
 152     size_t count = 0;
 153
 154     FeatureSet returnFeatures;
 155
 156     for (size_t i = 0; i < m_stepSize; ++i) {
 157
 158         float sample = inputBuffers[0][i];
 159         bool crossing = false;
 160
 161         if (sample <= 0.0) {
 162             if (prev > 0.0) crossing = true;
 163         } else if (sample > 0.0) {
 164             if (prev <= 0.0) crossing = true;
 165         }
 166
 167         if (crossing) {
 168             ++count;
 169             Feature feature;
 170             feature.hasTimestamp = true;
 171             feature.timestamp = timestamp +
 172                 Vamp::RealTime::frame2RealTime(i, (size_t)m_inputSampleRate);
 173             returnFeatures[1].push_back(feature);
 174         }
 175
 176         prev = sample;
 177     }
 178
 179     m_previousSample = prev;
 180
 181     Feature feature;
 182     feature.hasTimestamp = false;
 183     feature.values.push_back(count);
 184
 185     returnFeatures[0].push_back(feature);
 186     return returnFeatures;
 187 }
 188
 189 ZeroCrossing::FeatureSet
 190 ZeroCrossing::getRemainingFeatures()
 191 {
 192     return FeatureSet();
 193 }
 194