631 lines
10 KiB
C++
631 lines
10 KiB
C++
/*
|
|
* Copyright (C) 2006 Chris Cannam
|
|
* Copyright (C) 2006-2012 Fons Adriaensen <fons@linuxaudio.org>
|
|
* COPYRIGHT (C) 2012-2019 Robin Gareus <robin@gareus.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include "TruePeak.h"
|
|
|
|
namespace TruePeakMeter {
|
|
|
|
static double sinc (double x)
|
|
{
|
|
x = fabs (x);
|
|
if (x < 1e-6) return 1.0;
|
|
x *= M_PI;
|
|
return sin (x) / x;
|
|
}
|
|
|
|
static double wind (double x)
|
|
{
|
|
x = fabs (x);
|
|
if (x >= 1.0) return 0.0f;
|
|
x *= M_PI;
|
|
return 0.384 + 0.500 * cos (x) + 0.116 * cos (2 * x);
|
|
}
|
|
|
|
Resampler_table *Resampler_table::_list = 0;
|
|
Resampler_mutex Resampler_table::_mutex;
|
|
|
|
Resampler_table::Resampler_table (double fr, unsigned int hl, unsigned int np)
|
|
: _next (0)
|
|
, _refc (0)
|
|
, _fr (fr)
|
|
, _hl (hl)
|
|
, _np (np)
|
|
{
|
|
unsigned int i, j;
|
|
double t;
|
|
float *p;
|
|
|
|
_ctab = new float [hl * (np + 1)];
|
|
p = _ctab;
|
|
for (j = 0; j <= np; j++)
|
|
{
|
|
t = (double) j / (double) np;
|
|
for (i = 0; i < hl; i++)
|
|
{
|
|
p [hl - i - 1] = (float)(fr * sinc (t * fr) * wind (t / hl));
|
|
t += 1;
|
|
}
|
|
p += hl;
|
|
}
|
|
}
|
|
|
|
Resampler_table::~Resampler_table (void)
|
|
{
|
|
delete[] _ctab;
|
|
}
|
|
|
|
Resampler_table *
|
|
Resampler_table::create (double fr, unsigned int hl, unsigned int np)
|
|
{
|
|
Resampler_table *P;
|
|
|
|
_mutex.lock ();
|
|
P = _list;
|
|
while (P)
|
|
{
|
|
if ((fr >= P->_fr * 0.999) && (fr <= P->_fr * 1.001) && (hl == P->_hl) && (np == P->_np))
|
|
{
|
|
P->_refc++;
|
|
_mutex.unlock ();
|
|
return P;
|
|
}
|
|
P = P->_next;
|
|
}
|
|
P = new Resampler_table (fr, hl, np);
|
|
P->_refc = 1;
|
|
P->_next = _list;
|
|
_list = P;
|
|
_mutex.unlock ();
|
|
return P;
|
|
}
|
|
|
|
void
|
|
Resampler_table::destroy (Resampler_table *T)
|
|
{
|
|
Resampler_table *P, *Q;
|
|
|
|
_mutex.lock ();
|
|
if (T)
|
|
{
|
|
T->_refc--;
|
|
if (T->_refc == 0)
|
|
{
|
|
P = _list;
|
|
Q = 0;
|
|
while (P)
|
|
{
|
|
if (P == T)
|
|
{
|
|
if (Q) Q->_next = T->_next;
|
|
else _list = T->_next;
|
|
break;
|
|
}
|
|
Q = P;
|
|
P = P->_next;
|
|
}
|
|
delete T;
|
|
}
|
|
}
|
|
_mutex.unlock ();
|
|
}
|
|
|
|
static unsigned int
|
|
gcd (unsigned int a, unsigned int b)
|
|
{
|
|
if (a == 0) return b;
|
|
if (b == 0) return a;
|
|
while (1)
|
|
{
|
|
if (a > b)
|
|
{
|
|
a = a % b;
|
|
if (a == 0) return b;
|
|
if (a == 1) return 1;
|
|
}
|
|
else
|
|
{
|
|
b = b % a;
|
|
if (b == 0) return a;
|
|
if (b == 1) return 1;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
Resampler::Resampler (void)
|
|
: _table (0)
|
|
, _nchan (0)
|
|
, _buff (0)
|
|
{
|
|
reset ();
|
|
}
|
|
|
|
Resampler::~Resampler (void)
|
|
{
|
|
clear ();
|
|
}
|
|
|
|
int
|
|
Resampler::setup (unsigned int fs_inp,
|
|
unsigned int fs_out,
|
|
unsigned int nchan,
|
|
unsigned int hlen)
|
|
{
|
|
if ((hlen < 8) || (hlen > 96)) return 1;
|
|
return setup (fs_inp, fs_out, nchan, hlen, 1.0 - 2.6 / hlen);
|
|
}
|
|
|
|
int
|
|
Resampler::setup (unsigned int fs_inp,
|
|
unsigned int fs_out,
|
|
unsigned int nchan,
|
|
unsigned int hlen,
|
|
double frel)
|
|
{
|
|
unsigned int g, h, k, n, s;
|
|
double r;
|
|
float *B = 0;
|
|
Resampler_table *T = 0;
|
|
|
|
k = s = 0;
|
|
if (fs_inp && fs_out && nchan)
|
|
{
|
|
r = (double) fs_out / (double) fs_inp;
|
|
g = gcd (fs_out, fs_inp);
|
|
n = fs_out / g;
|
|
s = fs_inp / g;
|
|
if ((16 * r >= 1) && (n <= 1000))
|
|
{
|
|
h = hlen;
|
|
k = 250;
|
|
if (r < 1)
|
|
{
|
|
frel *= r;
|
|
h = (unsigned int)(ceil (h / r));
|
|
k = (unsigned int)(ceil (k / r));
|
|
}
|
|
T = Resampler_table::create (frel, h, n);
|
|
B = new float [nchan * (2 * h - 1 + k)];
|
|
}
|
|
}
|
|
clear ();
|
|
if (T)
|
|
{
|
|
_table = T;
|
|
_buff = B;
|
|
_nchan = nchan;
|
|
_inmax = k;
|
|
_pstep = s;
|
|
return reset ();
|
|
} else {
|
|
delete[] B;
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
void
|
|
Resampler::clear (void)
|
|
{
|
|
Resampler_table::destroy (_table);
|
|
delete[] _buff;
|
|
_buff = 0;
|
|
_table = 0;
|
|
_nchan = 0;
|
|
_inmax = 0;
|
|
_pstep = 0;
|
|
reset ();
|
|
}
|
|
|
|
double
|
|
Resampler::inpdist (void) const
|
|
{
|
|
if (!_table) return 0;
|
|
return (int)(_table->_hl + 1 - _nread) - (double)_phase / _table->_np;
|
|
}
|
|
|
|
int
|
|
Resampler::inpsize (void) const
|
|
{
|
|
if (!_table) return 0;
|
|
return 2 * _table->_hl;
|
|
}
|
|
|
|
int
|
|
Resampler::reset (void)
|
|
{
|
|
if (!_table) return 1;
|
|
|
|
inp_count = 0;
|
|
out_count = 0;
|
|
inp_data = 0;
|
|
out_data = 0;
|
|
_index = 0;
|
|
_nread = 0;
|
|
_nzero = 0;
|
|
_phase = 0;
|
|
if (_table)
|
|
{
|
|
_nread = 2 * _table->_hl;
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
Resampler::process (void)
|
|
{
|
|
unsigned int hl, ph, np, dp, in, nr, nz, i, n, c;
|
|
float *p1, *p2;
|
|
|
|
if (!_table) return 1;
|
|
|
|
hl = _table->_hl;
|
|
np = _table->_np;
|
|
dp = _pstep;
|
|
in = _index;
|
|
nr = _nread;
|
|
ph = _phase;
|
|
nz = _nzero;
|
|
n = (2 * hl - nr) * _nchan;
|
|
p1 = _buff + in * _nchan;
|
|
p2 = p1 + n;
|
|
|
|
while (out_count)
|
|
{
|
|
if (nr)
|
|
{
|
|
if (inp_count == 0) break;
|
|
if (inp_data)
|
|
{
|
|
for (c = 0; c < _nchan; c++) p2 [c] = inp_data [c];
|
|
inp_data += _nchan;
|
|
nz = 0;
|
|
}
|
|
else
|
|
{
|
|
for (c = 0; c < _nchan; c++) p2 [c] = 0;
|
|
if (nz < 2 * hl) nz++;
|
|
}
|
|
nr--;
|
|
p2 += _nchan;
|
|
inp_count--;
|
|
}
|
|
else
|
|
{
|
|
if (out_data)
|
|
{
|
|
if (nz < 2 * hl)
|
|
{
|
|
float *c1 = _table->_ctab + hl * ph;
|
|
float *c2 = _table->_ctab + hl * (np - ph);
|
|
for (c = 0; c < _nchan; c++)
|
|
{
|
|
float *q1 = p1 + c;
|
|
float *q2 = p2 + c;
|
|
float s = 1e-20f;
|
|
for (i = 0; i < hl; i++)
|
|
{
|
|
q2 -= _nchan;
|
|
s += *q1 * c1 [i] + *q2 * c2 [i];
|
|
q1 += _nchan;
|
|
}
|
|
*out_data++ = s - 1e-20f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (c = 0; c < _nchan; c++) *out_data++ = 0;
|
|
}
|
|
}
|
|
out_count--;
|
|
|
|
ph += dp;
|
|
if (ph >= np)
|
|
{
|
|
nr = ph / np;
|
|
ph -= nr * np;
|
|
in += nr;
|
|
p1 += nr * _nchan;;
|
|
if (in >= _inmax)
|
|
{
|
|
n = (2 * hl - nr) * _nchan;
|
|
memcpy (_buff, p1, n * sizeof (float));
|
|
in = 0;
|
|
p1 = _buff;
|
|
p2 = p1 + n;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_index = in;
|
|
_nread = nr;
|
|
_phase = ph;
|
|
_nzero = nz;
|
|
|
|
return 0;
|
|
}
|
|
|
|
TruePeakdsp::TruePeakdsp (void)
|
|
: _m (0)
|
|
, _p (0)
|
|
, _res (true)
|
|
, _res_peak (true)
|
|
, _buf (NULL)
|
|
{
|
|
}
|
|
|
|
TruePeakdsp::~TruePeakdsp (void)
|
|
{
|
|
free(_buf);
|
|
}
|
|
|
|
void
|
|
TruePeakdsp::process (float const *d, int n)
|
|
{
|
|
_src.inp_count = n;
|
|
_src.inp_data = d;
|
|
_src.out_count = n * 4;
|
|
_src.out_data = _buf;
|
|
_src.process ();
|
|
|
|
float x = 0;
|
|
float v;
|
|
assert (_buf);
|
|
float *b = _buf;
|
|
while (n--) {
|
|
v = fabsf(*b++);
|
|
if (v > x) x = v;
|
|
v = fabsf(*b++);
|
|
if (v > x) x = v;
|
|
v = fabsf(*b++);
|
|
if (v > x) x = v;
|
|
v = fabsf(*b++);
|
|
if (v > x) x = v;
|
|
}
|
|
|
|
if (_res) {
|
|
_m = x;
|
|
_res = false;
|
|
} else if (x > _m) {
|
|
_m = x;
|
|
}
|
|
|
|
if (_res_peak) {
|
|
_p = x;
|
|
_res_peak = false;
|
|
} else if (x > _p) {
|
|
_p = x;
|
|
}
|
|
}
|
|
|
|
float
|
|
TruePeakdsp::read (void)
|
|
{
|
|
_res = true;
|
|
return _m;
|
|
}
|
|
|
|
void
|
|
TruePeakdsp::read (float &m, float &p)
|
|
{
|
|
_res = true;
|
|
_res_peak = true;
|
|
m = _m;
|
|
p = _p;
|
|
}
|
|
|
|
void
|
|
TruePeakdsp::reset ()
|
|
{
|
|
_res = true;
|
|
_m = 0;
|
|
_p = 0;
|
|
}
|
|
|
|
bool
|
|
TruePeakdsp::init (float fsamp)
|
|
{
|
|
_src.setup(fsamp, fsamp * 4.0, 1, 24, 1.0);
|
|
_buf = (float*) malloc(32768 * sizeof(float));
|
|
if (!_buf) {
|
|
return false;
|
|
}
|
|
|
|
/* q/d initialize */
|
|
float zero[8192];
|
|
for (int i = 0; i < 8192; ++i) {
|
|
zero[i]= 0.0;
|
|
}
|
|
_src.inp_count = 8192;
|
|
_src.inp_data = zero;
|
|
_src.out_count = 32768;
|
|
_src.out_data = _buf;
|
|
_src.process ();
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
using std::string;
|
|
using std::vector;
|
|
using std::cerr;
|
|
using std::endl;
|
|
using namespace TruePeakMeter;
|
|
|
|
VampTruePeak::VampTruePeak(float inputSampleRate)
|
|
: Plugin(inputSampleRate)
|
|
, m_blockSize(0)
|
|
, m_rate (inputSampleRate)
|
|
{
|
|
}
|
|
|
|
VampTruePeak::~VampTruePeak()
|
|
{
|
|
}
|
|
|
|
string
|
|
VampTruePeak::getIdentifier() const
|
|
{
|
|
return "dBTP";
|
|
}
|
|
|
|
string
|
|
VampTruePeak::getName() const
|
|
{
|
|
return "dBTP Meter";
|
|
}
|
|
|
|
string
|
|
VampTruePeak::getDescription() const
|
|
{
|
|
return "True Peak Meter (4x Oversampling)";
|
|
}
|
|
|
|
string
|
|
VampTruePeak::getMaker() const
|
|
{
|
|
return "Robin Gareus, Fons Adrianesen";
|
|
}
|
|
|
|
int
|
|
VampTruePeak::getPluginVersion() const
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
string
|
|
VampTruePeak::getCopyright() const
|
|
{
|
|
return "GPL version 3 or later";
|
|
}
|
|
|
|
bool
|
|
VampTruePeak::initialise(size_t channels, size_t stepSize, size_t blockSize)
|
|
{
|
|
if (channels < getMinChannelCount() ||
|
|
channels > getMaxChannelCount()) {
|
|
return false;
|
|
}
|
|
|
|
if (blockSize == 0 || blockSize > 8192) {
|
|
return false;
|
|
}
|
|
|
|
if (!_meter.init (m_inputSampleRate)) {
|
|
return false;
|
|
}
|
|
|
|
m_blockSize = blockSize;
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
VampTruePeak::reset()
|
|
{
|
|
_meter.reset ();
|
|
}
|
|
|
|
VampTruePeak::OutputList
|
|
VampTruePeak::getOutputDescriptors() const
|
|
{
|
|
OutputList list;
|
|
|
|
OutputDescriptor zc;
|
|
zc.identifier = "level";
|
|
zc.name = "TruePeak";
|
|
zc.description = "TruePeak (4x Oversampling)";
|
|
zc.unit = "dbTP";
|
|
zc.hasFixedBinCount = true;
|
|
zc.binCount = 0;
|
|
zc.hasKnownExtents = false;
|
|
zc.isQuantized = false;
|
|
zc.sampleType = OutputDescriptor::OneSamplePerStep;
|
|
list.push_back(zc);
|
|
|
|
zc.identifier = "peaks";
|
|
zc.name = "TruePeakPeaks";
|
|
zc.description = "Location of Peaks above -1dBTP";
|
|
zc.unit = "sec";
|
|
zc.hasFixedBinCount = true;
|
|
zc.binCount = 0;
|
|
zc.hasKnownExtents = false;
|
|
zc.isQuantized = false;
|
|
zc.sampleType = OutputDescriptor::OneSamplePerStep;
|
|
list.push_back(zc);
|
|
|
|
return list;
|
|
}
|
|
|
|
VampTruePeak::FeatureSet
|
|
VampTruePeak::process(const float *const *inputBuffers,
|
|
Vamp::RealTime timestamp)
|
|
{
|
|
if (m_blockSize == 0) {
|
|
cerr << "ERROR: VampTruePeak::process: "
|
|
<< "VampTruePeak has not been initialised"
|
|
<< endl;
|
|
return FeatureSet();
|
|
}
|
|
|
|
size_t remain = m_blockSize;
|
|
size_t processed = 0;
|
|
while (remain > 0) {
|
|
size_t to_proc = std::min ((size_t)48, remain);
|
|
_meter.process (&inputBuffers[0][processed], to_proc);
|
|
processed += to_proc;
|
|
remain -= to_proc;
|
|
|
|
if (_meter.read () >= .89125 /* -1dBTP */) {
|
|
long f = Vamp::RealTime::realTime2Frame (timestamp, m_rate);
|
|
_above_m1.values.push_back ((float) (f + processed));
|
|
}
|
|
}
|
|
|
|
return FeatureSet();
|
|
}
|
|
|
|
VampTruePeak::FeatureSet
|
|
VampTruePeak::getRemainingFeatures()
|
|
{
|
|
FeatureSet returnFeatures;
|
|
|
|
float m, p;
|
|
_meter.read(m, p);
|
|
|
|
Feature dbtp;
|
|
dbtp.hasTimestamp = false;
|
|
dbtp.values.push_back(p);
|
|
returnFeatures[0].push_back(dbtp);
|
|
|
|
_above_m1.hasTimestamp = false;
|
|
returnFeatures[1].push_back(_above_m1);
|
|
|
|
return returnFeatures;
|
|
}
|