← Back to branch summary

~ubuntu-branches/ubuntu/lucid/ardour/lucid-proposed

« back to all changes in this revision

Viewing changes to libs/vamp-plugins/AmplitudeFollower.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2008-02-07 20:51:55 UTC
  • mfrom: (1.1.13 upstream)
  • Revision ID: james.westby@ubuntu.com-20080207205155-xzi5lq5s2o1okvx8
Tags: 1:2.3.1-1
http://bugs.debian.org/463803
* New upstream release
* debian/control:
   - build-depend on libfftw3-dev (Closes: #463803)
   - added Homepage, Vcs-Svn, Vcs-Browser
* debian/patches
   - dropped 50-soundtouch.patch (fixed upstream)
   - updated 80_ardourino.patch
   - dropped unused patches from source package

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/vamp-plugins/AmplitudeFollower.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
    This file copyright 2006 Dan Stowell.
 
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 "AmplitudeFollower.h"
 
38
 
 
39
#include <cmath>
 
40
 
 
41
#include <string>
 
42
#include <vector>
 
43
#include <iostream>
 
44
 
 
45
using std::string;
 
46
using std::vector;
 
47
using std::cerr;
 
48
using std::endl;
 
49
 
 
50
/**
 
51
 * An implementation of SuperCollider's amplitude-follower algorithm
 
52
 * as a simple Vamp plugin.
 
53
 */
 
54
 
 
55
AmplitudeFollower::AmplitudeFollower(float inputSampleRate) :
 
56
    Plugin(inputSampleRate),
 
57
    m_stepSize(0),
 
58
    m_previn(0.0f),
 
59
    m_clampcoef(0.01f),
 
60
    m_relaxcoef(0.01f)
 
61
{
 
62
}
 
63
 
 
64
AmplitudeFollower::~AmplitudeFollower()
 
65
{
 
66
}
 
67
 
 
68
string
 
69
AmplitudeFollower::getIdentifier() const
 
70
{
 
71
    return "amplitudefollower";
 
72
}
 
73
 
 
74
string
 
75
AmplitudeFollower::getName() const
 
76
{
 
77
    return "Amplitude Follower";
 
78
}
 
79
 
 
80
string
 
81
AmplitudeFollower::getDescription() const
 
82
{
 
83
    return "Track the amplitude of the audio signal";
 
84
}
 
85
 
 
86
string
 
87
AmplitudeFollower::getMaker() const
 
88
{
 
89
    return "Vamp SDK Example Plugins";
 
90
}
 
91
 
 
92
int
 
93
AmplitudeFollower::getPluginVersion() const
 
94
{
 
95
    return 1;
 
96
}
 
97
 
 
98
string
 
99
AmplitudeFollower::getCopyright() const
 
100
{
 
101
    return "Code copyright 2006 Dan Stowell; method from SuperCollider.  Freely redistributable (BSD license)";
 
102
}
 
103
 
 
104
bool
 
105
AmplitudeFollower::initialise(size_t channels, size_t stepSize, size_t blockSize)
 
106
{
 
107
    if (channels < getMinChannelCount() ||
 
108
        channels > getMaxChannelCount()) return false;
 
109
 
 
110
    m_stepSize = std::min(stepSize, blockSize);
 
111
        
 
112
    // Translate the coefficients 
 
113
    // from their "convenient" 60dB convergence-time values
 
114
    // to real coefficients
 
115
    m_clampcoef = m_clampcoef==0.0 ? 0.0 : exp(log(0.1)/(m_clampcoef * m_inputSampleRate));
 
116
    m_relaxcoef = m_relaxcoef==0.0 ? 0.0 : exp(log(0.1)/(m_relaxcoef * m_inputSampleRate));
 
117
 
 
118
    return true;
 
119
}
 
120
 
 
121
void
 
122
AmplitudeFollower::reset()
 
123
{
 
124
    m_previn = 0.0f;
 
125
}
 
126
 
 
127
AmplitudeFollower::OutputList
 
128
AmplitudeFollower::getOutputDescriptors() const
 
129
{
 
130
    OutputList list;
 
131
 
 
132
    OutputDescriptor sca;
 
133
    sca.identifier = "amplitude";
 
134
    sca.name = "Amplitude";
 
135
    sca.description = "";
 
136
    sca.unit = "V";
 
137
    sca.hasFixedBinCount = true;
 
138
    sca.binCount = 1;
 
139
    sca.hasKnownExtents = false;
 
140
    sca.isQuantized = false;
 
141
    sca.sampleType = OutputDescriptor::OneSamplePerStep;
 
142
    list.push_back(sca);
 
143
 
 
144
    return list;
 
145
}
 
146
 
 
147
AmplitudeFollower::ParameterList
 
148
AmplitudeFollower::getParameterDescriptors() const
 
149
{
 
150
    ParameterList list;
 
151
        
 
152
    ParameterDescriptor att;
 
153
    att.identifier = "attack";
 
154
    att.name = "Attack time";
 
155
    att.description = "";
 
156
    att.unit = "s";
 
157
    att.minValue = 0.0f;
 
158
    att.maxValue = 1.f;
 
159
    att.defaultValue = 0.01f;
 
160
    att.isQuantized = false;
 
161
    
 
162
    list.push_back(att);
 
163
    
 
164
    ParameterDescriptor dec;
 
165
    dec.identifier = "release";
 
166
    dec.name = "Release time";
 
167
    dec.description = "";
 
168
    dec.unit = "s";
 
169
    dec.minValue = 0.0f;
 
170
    dec.maxValue = 1.f;
 
171
    dec.defaultValue = 0.01f;
 
172
    dec.isQuantized = false;
 
173
    
 
174
    list.push_back(dec);
 
175
    
 
176
    return list;
 
177
}
 
178
 
 
179
void AmplitudeFollower::setParameter(std::string paramid, float newval)
 
180
{
 
181
    if (paramid == "attack") {
 
182
        m_clampcoef = newval;
 
183
    } else if (paramid == "release") {
 
184
        m_relaxcoef = newval;
 
185
    }
 
186
}
 
187
 
 
188
float AmplitudeFollower::getParameter(std::string paramid) const
 
189
{
 
190
    if (paramid == "attack") {
 
191
        return m_clampcoef;
 
192
    } else if (paramid == "release") {
 
193
        return m_relaxcoef;
 
194
    }
 
195
 
 
196
    return 0.0f;
 
197
}
 
198
 
 
199
AmplitudeFollower::FeatureSet
 
200
AmplitudeFollower::process(const float *const *inputBuffers,
 
201
                           Vamp::RealTime timestamp)
 
202
{
 
203
    if (m_stepSize == 0) {
 
204
        cerr << "ERROR: AmplitudeFollower::process: "
 
205
             << "AmplitudeFollower has not been initialised"
 
206
             << endl;
 
207
        return FeatureSet();
 
208
    }
 
209
 
 
210
    float previn = m_previn;
 
211
 
 
212
    FeatureSet returnFeatures;
 
213
        
 
214
    float val;
 
215
    float peak = 0.0f;
 
216
 
 
217
    for (size_t i = 0; i < m_stepSize; ++i) {
 
218
 
 
219
        val = fabs(inputBuffers[0][i]);
 
220
                
 
221
        if (val < previn) {
 
222
            val = val + (previn - val) * m_relaxcoef;
 
223
        } else {
 
224
            val = val + (previn - val) * m_clampcoef;
 
225
        }
 
226
 
 
227
        if (val > peak) peak = val;
 
228
        previn = val;
 
229
    }
 
230
 
 
231
    m_previn = previn;
 
232
 
 
233
    // Now store the "feature" (peak amp) for this sample
 
234
    Feature feature;
 
235
    feature.hasTimestamp = false;
 
236
    feature.values.push_back(peak);
 
237
    returnFeatures[0].push_back(feature);
 
238
 
 
239
    return returnFeatures;
 
240
}
 
241
 
 
242
AmplitudeFollower::FeatureSet
 
243
AmplitudeFollower::getRemainingFeatures()
 
244
{
 
245
    return FeatureSet();
 
246
}
 
247