1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
/*
Copyright (C) 2008 Fons Adriaensen <fons@kokkinizita.net>
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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <math.h>
#include "kmeterdsp.h"
int Kmeterdsp::_hold;
float Kmeterdsp::_fall;
float Kmeterdsp::_omega;
Kmeterdsp::Kmeterdsp (void) :
_z1 (0),
_z2 (0),
_rms (0),
_dpk (0),
_cnt (0),
_flag (false)
{
}
Kmeterdsp::~Kmeterdsp (void)
{
}
void Kmeterdsp::process (float *p, int n)
{
// Called by JACK's process callback.
//
// p : pointer to sample buffer
// n : number of samples to process
float s, t, z1, z2;
if (_flag) // Display thread has read the rms value.
{
_rms = 0;
_flag = 0;
}
// Get filter state.
z1 = _z1;
z2 = _z2;
// Process n samples. Find digital peak value for this
// period and perform filtering. The second filter is
// evaluated only every 4th sample - this is just an
// optimisation.
t = 0;
n /= 4; // Loop is unrolled by 4.
while (n--)
{
s = fabsf (*p++); // Absolute value of next sample.
if (t < s) t = s; // Update digital peak.
z1 += _omega * (s * s - z1); // Update first filter.
s = fabsf (*p++); // Repeated four times.
if (t < s) t = s;
z1 += _omega * (s * s - z1);
s = fabsf (*p++);
if (t < s) t = s;
z1 += _omega * (s * s - z1);
s = fabsf (*p++);
if (t < s) t = s;
z1 += _omega * (s * s - z1);
z2 += 4 * _omega * (z1 - z2); // Update second filter.
}
// Save filter state. The added constants avoid denormals.
_z1 = z1 + 1e-20f;
_z2 = z2 + 1e-20f;
// Adjust RMS value and update maximum since last read().
s = sqrtf (2 * z2);
if (s > _rms) _rms = s;
// Digital peak hold and fallback.
if (t > _dpk)
{
// If higher than current value, update and set hold counter.
_dpk = t;
_cnt = _hold;
}
else if (_cnt) _cnt--; // else decrement counter if not zero,
else
{
_dpk *= _fall; // else let the peak value fall back,
_dpk += 1e-10f; // and avoid denormals.
}
}
void Kmeterdsp::read (float *rms, float *dpk)
{
// Called by display process approx. 30 times per second.
//
// Returns highest _rms value since last call,
// and current _dpk value.
*rms = _rms;
*dpk = _dpk;
_flag = true; // Resets _rms in next process().
}
void Kmeterdsp::init (int fsamp, int fsize, float hold, float fall)
{
// Called by initialisation code.
//
// fsamp = sample frequency
// fsize = period size
// hold = peak hold time, seconds
// fall = peak fallback rate, dB/s
float t;
_omega = 9.72f / fsamp; // ballistic filter coefficient
t = (float) fsize / fsamp; // period time in seconds
_hold = (int)(hold / t + 0.5f); // number of periods to hold peak
_fall = powf (10.0f, -0.05f * fall * t); // per period fallback multiplier
}
|
