musicdsp.org source code archive - WSInf

samples at a time and then storing in memory the temp values for the next block. In this case you may see diferent results and a much bigger drift
(that's my experience with the same algo).
Anyway my algo is a bit diferent as it permits to change the curent type with a parameter, this makes the formula looks like
value = value * coef + contant;
May be this leads to more calculation errors :).
from : schoenebeck ( at ) software ( minus ) engineering.org
comment : And again... no! :)
Replace the C equation by:
asm volatile (
"movss %1,%%xmm0 # load coeff\n\t"
"movss %2,%%xmm1 # load currentLevel\n\t"
"mulss %%xmm1,%%xmm0 # coeff *= currentLevel\n\t"
"addss %%xmm0,%%xmm1 # currentLevel += coeff * currentLevel\n\t"
"movss %%xmm1,%0 # store currentLevel\n\t"
: "=m" (currentLevel) /* %0 */
: "m" (coeff), /* %1 */
"m" (currentLevel) /* %2 */
);
This is a SSE1 assembly implementation. The SSE registers are only 32 bit
large by guarantee. And this is the result I get:
Calculated sample points: 5764845
Demanded duration: 30.000000 s
Actual duration: 30.025234 s
So this result differs just 1 sample point from the x86 FPU solution! So
believe me, this numerical solution is safe!
(Of course the assembly code above is NOT meant as optimization, it's just
to demonstrate the accuracy even for 32 bit / single precision FP
calculation)
from : m (at) mindplay (dot
comment :
from : m (at) mindplay (dot) dk
comment : in my tests, the following code produced the exact same results, and saves one operation (the addition) per sample - so it should be
faster:
const float sampleRate = 44100;
float coeff;
float currentLevel;
void init(float levelBegin, float levelEnd, float releaseTime) {
currentLevel = levelBegin;
coeff = exp(log(levelEnd)) /
(releaseTime * sampleRate);
}
inline void calculateEnvelope(int samplePoints) {
for (int i = 0; i < samplePoints; i++) {
currentLevel *= coeff;
// do something with 'currentLevel' here
...
}
}
...
Also, assuming that your startLevel is 1.0, to calculate an appropriate endLevel, you can use something like:
endLevel = 10 ^ dB/20;
where dB is your endLevel in decibels (and must be a negative value of course) - for amplitude envelopes, -90 dB should be a suitable level for "near
inaudible"...
from : schoenebeck ( at ) software ( minus ) engineering.org
comment : Sorry, you are right of course; that simplification of the execution
equation works here because we are calculating all points with linear
discretization. But you will agree that your init() function is not good,
because exp(log(x)) == x and it's not generalized at all. Usually you might
have more than one exp segment in your EG and maybe even have an exp attack
segment. So we arrive at the following solution:
const float sampleRate = 44100;
float coeff;
float currentLevel;
void init(float levelBegin, float levelEnd, float releaseTime) {
currentLevel = levelBegin;