Hi ,
Here is the source file freemverb-demo.c of the reverb announced. It contains
the two reverbs (freemverb, and freeverb).
To do the test the file must replace the original fluid_rev.c of any Fluidsynth
version from v1.1.3.
At the top of the file you can set the variable freemverb (char freemverb = 1;
// 1: use freemverb 0:use freeverb)
> Now you have the possibility to build tow version of the FluidSynth library:
> - the one with 'freemverb = 1' using freemverb (stand for 'free modulated
> reverb')
> - the other with 'freemverb = 0'. using freeverb.
When you run the freemverb version you will see the message:Fluidsynth: using
freemverb-demo (in process mixing only !).
1)You can use the FluidSynth console application with a MIDI keyboard on input
(if possible).
To do comparison test between both reverb, i have used the GeneralUser GS 1.471
soundfont from S;Christian Collins
but it isn't mandatory.
2)To make an effective comparison,following settings for both reverbs are
recommened.
- Use headphone only otherwise fluidsynth reverb will be masked by the
natural reverb of the room your are in.
- roomsize : 1(max) damp: 0 (min)
- width: default level: default
- SoundFont Preset: The more percussive the preset is (fast attack and than
decay)(i.e piano ,...) the more the reverb will be stressed.
- Your playing for the comparison:
- use low , medium and high dynamics ranges.
- use low, medium and high key range too.
Note: Fast attack and staccato playing contributes to the reverb stressing (i.e
making "ringing").
Note: please note that reverb settings range are 0:Min 1: Max for both reverb.
But freemverb is not calibrated the same way as freeverb.
Freemverb have higher 'reverb time' than freeverb. Consequently to get the
same roomsize effect for example you will need 0.2 for freemverb against 0.7
for freeverb.
Similarly, you will need different value for 'damp' setting to produce the same
damp effect. For this reason, to do a pertinent comparaison test please follow
the above recommendations (see 2). Later it will be easier to use your own
settings.
Remember: The goal of freemverb is to diminish the "ringing" tendency (resonant
frequencies) produced by any artificial reverb.
Objectives tests would be appreciated.
cheers.
jjc
> Message du 23/10/17 02:44
> De : "Ceresa Jean-Jacques"
> A : "FluidSynthmailinglist"
> Copie à :
> Objet : Re: [fluid-dev] Trying another reverb ?
>
>
> Hi, Marcus and GrahamG
>
> Thanks for your interrest.
>
>I would also be very interested in a better sounding reverb.
I don't pretend that freemverb is a better reverb. This is ears dependant. The
goal was to obtain a less "ringing" sound that with freeverb.To obtain this
result the inner structure off freemverb is completely different and the
necessary comb filters are not fixed delays lines but modulated delay lines.
The effect of modulation is to diminish local resonnance. The "ringing" is
really diminished with only 8 combs filters !. However now we obtain a sound a
bit "chorused" wich is a bit unnatural for reverb. For this reason somes ears
may not accept this sound. By the way the best is to hear the result.
> >So maybe what we need is a system where we can have multiple reverb
> >implementations in core FluidSynth and a setting that can be used to select
> >one >of the implementations.
>
> >Let me explain that idea in a bit more detail. What I have in mind is a
> >better defined interface (basically an internal API) for the reverb and
> >chorus >effects. Something that works a little like LADSPA[1], only less
> >generic and more specific to FluidSynth.
> The fact that it is API specific to FluidSynth make the things OS
> independant. I like this idea.
>
>
> Yes, but to keep things simple at a first time and to give you the
> possibility to ear the result quickly . I propose the following that is
> simple for me:
> 1)I give a file called fluid_mrev2.c. It will contain the two reverb
> (freemverb, and freeverb) and of course the API expected by the FluidSynth
> library(defined in fluid_rev.h) .
> -At the top of the file the variable: char freemverb = 1; // 1: use freemverb
> 0:use freeverb
>
> 2)The file fluid_mrev2.c is intended to replace the original fluid_rev.c
> 3)Now you have the possibility to build tow version of the FluidSynth library,
> - the one with 'char freemverb = 1' using freemverb (stand for 'free
> modulated reverb')
> - the other with 'char freemverb = 0'. using freeverb.
>
> Note:fluid_mrev2.c is actually a working reverb and the code is a draft not
> yet intended to be easly understandable. It works and will be used
> with usual shell reverb commands.
>
> This could be done in a couple of days.
> cheers.
> jjc
>
> Message du 22/10/17 21:14
> De : "Marcus Weseloh"
> A : "FluidSynth mailing list"
> Copie à :
> Objet : Re: [fluid-dev] Trying another reverb ?
>
>
Hi,
>
I would also be very interested in a better sounding reverb.
>
I've written a different reverb as well, implementing a "sympathetic string
reverb" using tuned comb filters. Currently I maintain it in a custom fork, but
I wanted a maintainable solution. So I started working on the LADSPA plugin
system: getting it working properly and in a stable manner, documenting it and
tuning the performance. The largest part of the changes is already merged in
the master branch on GitHub. So adding a different reverb would be as easy as
writing a LADSPA plugin, disabling the internal reverb and configuring the new
one as a plugin. But I guess that won't be much use for people using FluidSynth
on non-Unix platforms...
>
So maybe what we need is a system where we can have multiple reverb
implementations in core FluidSynth and a setting that can be used to select one
of the implementations.
>
Cheers,
>
Marcus
>
2017-10-22 19:14 GMT+02:00 Graham Goode :
>
Hi jjc
>
> Yes, there would be great interest in this, particularly from the
> jOrgan users group as many of use us use fluidsynth with the current
> reverb engine.
>
> Kind regards,
> GrahamG
>
> On 10/22/17, Ceresa Jean-Jacques wrote:
> > Hello,
> >
> > For another application than FluidSynth i have build a reverb (intended to
> > be called freemverb) that sounds less "ringing" that freeverb.
> >
> > Like freeverb , freemverb is a "late" reverb and have a low cpu load
> > (sligtly above freeverb) and low memory cost.
> >
> > Both freeverb and freemverb aren't high quality reverb, but it seems that
> > freemverb gives better results (at least on my ears).
> >
> >
> >
> > It would be easy to build a version of freemverb for fluidsynth with the
> > same Reverb' API (v 1.0.6 or above if versions above have the same Reverb
> > API than v1.0.6 ?).
> >
> > Before doing that, i wish to know:
> >
> > 1) If there are any interests for FluidSynth ?.
> >
> > 2) Also it is necessary that others peoples than me care objectives tests
> > (by ears) ?.
> >
> >
> >
> > Let me know your opinion.
> >
> > Regards
> >
> > jjc
> >
> >
> >
>
>
_______________________________________________
> fluid-dev mailing list
> fluid-dev@nongnu.org
> https://lists.nongnu.org/mailman/listinfo/fluid-dev
>
>
_______________________________________________
fluid-dev mailing list
fluid-dev@nongnu.org
https://lists.nongnu.org/mailman/listinfo/fluid-dev
_______________________________________________
fluid-dev mailing list
fluid-dev@nongnu.org
https://lists.nongnu.org/mailman/listinfo/fluid-dev
/*
Freemverb demo draft
*/
#include "fluid_rev.h"
char freemverb = 1; // 1: use freemverb 0:use freeverb
/***************************************************************
*
* REVERB
*/
/* Denormalising:
*
* According to music-dsp thread 'Denormalise', Pentium processors
* have a hardware 'feature', that is of interest here, related to
* numeric underflow. We have a recursive filter. The output decays
* exponentially, if the input stops. So the numbers get smaller and
* smaller... At some point, they reach 'denormal' level. This will
* lead to drastic spikes in the CPU load. The effect was reproduced
* with the reverb - sometimes the average load over 10 s doubles!!.
*
* The 'undenormalise' macro fixes the problem: As soon as the number
* is close enough to denormal level, the macro forces the number to
* 0.0f. The original macro is:
*
* #define undenormalise(sample) if(((*(unsigned int*)&sample)&0x7f800000)==0)
sample=0.0f
*
* This will zero out a number when it reaches the denormal level.
* Advantage: Maximum dynamic range Disadvantage: We'll have to check
* every sample, expensive. The alternative macro comes from a later
* mail from Jon Watte. It will zap a number before it reaches
* denormal level. Jon suggests to run it once per block instead of
* every sample.
*/
# if defined(WITH_FLOATX)
# define zap_almost_zero(sample) (((*(unsigned int*)&(sample))&0x7f800000) <
0x08000000)?0.0f:(sample)
# else
/* 1e-20 was chosen as an arbitrary (small) threshold. */
#define zap_almost_zero(sample) fabs(sample)<1e-10 ? 0 : sample;
#endif
/* Denormalising part II:
*
* Another method fixes the problem cheaper: Use a small DC-offset in
* the filter calculations. Now the signals converge not against 0,
* but against the offset. The constant offset is invisible from the
* outside world (i.e. it does not appear at the output. There is a
* very small turn-on transient response, which should not cause
* problems.
*/
//#define DC_OFFSET 0.0f
#define DC_OFFSET 1e-8
//#define DC_OFFSET 0.001f
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
/*
*/
int UpdateMemory(void** pMem, long newSize)
{
* pMem = FLUID_REALLOC (* pMem, sizeof(fluid_real_t) * newSize);
if (newSize && * pMem == NULL) // Alloc or realloc
{ /* allocation or reallocation error */
FLUID_LOG(FLUID_INFO, "freemverb: Failed to alloc/realloc
memory");
return FLUID_FAILED;
}
else return FLUID_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
struct lpf
{
fluid_real_t buffer;
fluid_real_t b0, a1;
};
typedef struct lpf fluid_lpf;
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CreateLpf(fluid_lpf * lpf)
{
lpf->b0 = lpf->a1 = 0;
lpf->buffer = 0;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void SetCoeffsLpf(fluid_lpf * lpf , fluid_real_t in_b0, fluid_real_t in_a1)
{
lpf->b0 = in_b0;
lpf->a1 = in_a1;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
inline void ProcessLpf(fluid_lpf * lpf , fluid_real_t *in, fluid_real_t *out){
*out = *in * lpf->b0 - lpf->buffer * lpf->a1;
lpf->buffer = * out;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
struct _fluid_MdelayLine
{
// Buffer parameters
fluid_real_t *pfBuffer, *pfBufferEnd;
fluid_real_t *pfInPos, *pfOutPos;
int lBufferSize;
long lMaxDelay;
/*-------------*/
int inPos;
int outPos;
/*-------------*/
fluid_lpf dampingLPF;
};
typedef struct _fluid_MdelayLine fluid_MdelayLine;
typedef fluid_MdelayLine MDelayLine;
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void ClearMDelayLine(MDelayLine * dl)
{
int i;
if(dl->pfBuffer)
for (i=0; i < dl->lBufferSize;i++)
dl->pfBuffer[i] = DC_OFFSET;
// memset(dl->pfBuffer, DC_OFFSET, dl->lBufferSize * sizeof(fluid_real_t));
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CreateMdelayLine(MDelayLine * dl)
{
dl->pfBuffer = dl->pfBufferEnd = NULL;
dl->lBufferSize = 0;
dl->pfInPos = dl->pfOutPos = NULL;
dl->lMaxDelay = 0;
ClearMDelayLine(dl);
/*-------------------*/
dl->inPos = dl->outPos = 0;
/*-------------------*/
CreateLpf(&dl->dampingLPF);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void DestroyMdelayLine(MDelayLine * dl)
{
if(dl->pfBuffer) UpdateMemory(&dl->pfBuffer,0);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int SetMaxDelayMDelayLine (MDelayLine * dl ,long delay)
{
dl->lMaxDelay = delay;
dl->lBufferSize = dl->lMaxDelay + 10 + 1;
if( UpdateMemory(&dl->pfBuffer,dl->lBufferSize))
return FLUID_FAILED;
dl->pfBufferEnd = dl->pfBuffer + dl->lBufferSize;
dl->pfInPos = dl->pfBuffer;
dl->pfOutPos = dl->pfInPos - dl->lMaxDelay;
if(dl->pfOutPos < dl->pfBuffer)
{
dl->pfOutPos += dl->lBufferSize;
// if (dl->pfOutPos > dl->pfBuffer) printf("pfOutPos - pfBuffer
=%d\n", dl->pfOutPos - dl->pfBuffer);
}
// else printf("SetMaxDelayMDelayLine: pfOutPos >= pfBuffer\n");
dl->outPos = dl->inPos - dl->lMaxDelay;
if(dl->outPos < 0) dl->outPos += dl->lBufferSize;
return FLUID_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
inline void PushMDelayLine (MDelayLine * dl , fluid_real_t * val)
{
* dl->pfInPos = * val;
if(++dl->pfInPos >= dl->pfBufferEnd) dl->pfInPos -= dl->lBufferSize;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
#if 0
inline fluid_real_t GetLastMDelayLine (MDelayLine * dl)
{
fluid_real_t *p = dl->pfOutPos;
fluid_real_t out;
Sleep(2000);
//printf(" 1:pfOutPos=%p\n", dl->pfOutPos);
out = * (dl->pfOutPos);
//printf(" 2:pfOutPos, BufferEnd:%p\n",dl->pfBufferEnd);
if(++dl->pfOutPos >= dl->pfBufferEnd)
{
dl->pfOutPos -= dl->lBufferSize;
// printf(" 2.2:pfOutPos:%p, Buffersize=%d \n",dl->pfOutPos,
dl->lBufferSize );
Sleep(2000);
}
// else printf(" 2.1:pfOutPos:%p, Inc_sample =%d , Buffersize=%d,
pfBufferEnd:%p\n",dl->pfOutPos,
// dl->pfOutPos - p, dl->lBufferSize, dl->pfBufferEnd);
return out;
}
#else
inline fluid_real_t GetLastMDelayLine (MDelayLine * dl)
{
fluid_real_t out = * (dl->pfOutPos);
if(++dl->pfOutPos >= dl->pfBufferEnd) dl->pfOutPos -= dl->lBufferSize;
return out;
}
#endif
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
inline fluid_real_t GetAtMDelayLine (MDelayLine * dl, long index)
{
fluid_real_t * pfRealIndex;
if(index>=dl->lBufferSize) FLUID_LOG(FLUID_WARN,
"GetAtMDelayLine,
Invalid index %d", index);
pfRealIndex = dl->pfInPos - index - 1;
if(pfRealIndex < dl->pfBuffer) pfRealIndex += dl->lBufferSize;
return * pfRealIndex;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
//#define PI 3.1415926535897932384626433832795
#define TWOPI 6.28318530717958647692528676655901
#define PI_DIV_BY_2 1.57079632679489661923132169163975
//#define SCALING_FACTOR 0.0000000004656612874161594f // 2/(2^32-1)
struct _MSinOsc
{
fluid_real_t fFreq;
fluid_real_t a;
fluid_real_t buffer1;
fluid_real_t buffer2;
fluid_real_t resetBuffer2;
};
typedef struct _MSinOsc fluid_MSinOsc;
typedef fluid_MSinOsc MSinOsc;
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CreateMSinOsc(MSinOsc * osc)
{
osc->fFreq = 0;
osc->a = 0;
osc->buffer1 = osc->buffer2 = osc->resetBuffer2 = 0;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void SetFreqOsc(MSinOsc * osc, float freq, float sampleRate, float phase)
{
fluid_real_t w ;
osc->fFreq = freq;
w = TWOPI* osc->fFreq/sampleRate;
osc->a = 2*cos(w);
osc->buffer2 = sin(TWOPI*phase/360 - w);
osc->buffer1 = sin(TWOPI*phase/360);
osc->resetBuffer2 = sin(PI_DIV_BY_2 - w);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
inline fluid_real_t GetCurValueModOsc(MSinOsc * osc)
{
fluid_real_t out;
out = osc->a * osc->buffer1 - osc->buffer2;
if(out >= 1.0) {
out = 1.0;
osc->buffer2 = osc->resetBuffer2;
}
else if(out <= -1.0) {
out = -1.0;
osc->buffer2 = - osc->resetBuffer2;
}
else osc->buffer2 = osc->buffer1;
osc->buffer1 = out;
return out;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
struct ModDelayLine
{
MDelayLine dl; /* delayed line */
fluid_real_t fModOutPos;
long lNomDelay;
long lModDepth;
long index;
long lModRate;
fluid_real_t fOne_m_D;
fluid_real_t buffer;
MSinOsc mod;
};
typedef struct ModDelayLine fluid_ModDelayLine;
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CreateModDelayLine (fluid_ModDelayLine * mdl)
{
CreateMdelayLine(&mdl->dl);
mdl->fModOutPos = 0;
mdl->lNomDelay = 0;
mdl->lModDepth = 0;
mdl->index =0;
mdl->lModRate = 1;
mdl->buffer = 0;
mdl->fOne_m_D = 0;
CreateMSinOsc(&mdl->mod);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void DestroyModDelayLine (fluid_ModDelayLine * mdl)
{
DestroyMdelayLine(&mdl->dl);
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int SetNomDelay(fluid_ModDelayLine * mdl , long delay)
{
mdl->lNomDelay = delay;
if (SetMaxDelayMDelayLine (&mdl->dl, mdl->lNomDelay+ mdl->lModDepth))
return FLUID_FAILED;
// mdl->fModOutPos = (float)( mdl->dl.pfInPos - mdl->dl.pfBuffer -
mdl->lNomDelay);
mdl->fModOutPos = (fluid_real_t) (- mdl->lNomDelay);
if(mdl->fModOutPos < 0)
mdl->fModOutPos += mdl->dl.lBufferSize;
return FLUID_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int SetModDepth (fluid_ModDelayLine * mdl , long depth)
{
if(depth >= mdl->lNomDelay){
FLUID_LOG(FLUID_INFO,
"Mfreeverb: modulation depth has been limited");
depth = mdl->lNomDelay-1;
}
mdl->lModDepth = depth;
if (SetMaxDelayMDelayLine (&mdl->dl, mdl->lNomDelay+ mdl->lModDepth))
return FLUID_FAILED;
// mdl->fModOutPos = (float)( mdl->dl.pfInPos - mdl->dl.pfBuffer -
mdl->lNomDelay);
mdl->fModOutPos = (fluid_real_t) (- mdl->lNomDelay);
if(mdl->fModOutPos < 0)
mdl->fModOutPos += mdl->dl.lBufferSize;
return FLUID_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void SetModRate(fluid_ModDelayLine * mdl , long rate)
{
if (rate > mdl->dl.lBufferSize)
{
FLUID_LOG(FLUID_INFO,
"Mfreeverb: modulation rate is out of range");
return;
}
mdl->lModRate = rate;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
#if 1
inline fluid_real_t GetCurValueModDelayLine (fluid_ModDelayLine * mdl)
{
fluid_real_t fOutIndex;
long lIndex;
fluid_real_t out;
if(((mdl->index++)% mdl->lModRate) == 0){
fOutIndex = ( mdl->fModOutPos +
GetCurValueModOsc(&mdl->mod) *
mdl->lModDepth);
if(fOutIndex >= 0.0f) lIndex = (long)(fOutIndex);
else lIndex = (long)(fOutIndex-1);
mdl->dl.pfOutPos = mdl->dl.pfBuffer + lIndex;
if(mdl->dl.pfOutPos < mdl->dl.pfBuffer)
mdl->dl.pfOutPos += mdl->dl.lBufferSize;
if(mdl->dl.pfOutPos >= mdl->dl.pfBufferEnd)
mdl->dl.pfOutPos -= mdl->dl.lBufferSize;
mdl->fOne_m_D = fOutIndex - lIndex;
mdl->fModOutPos += mdl->lModRate;
if(mdl->fModOutPos >= mdl->dl.lBufferSize)
mdl->fModOutPos -= mdl->dl.lBufferSize;
}
out = *( mdl->dl.pfOutPos++);
if(mdl->dl.pfOutPos >= mdl->dl.pfBufferEnd)
mdl->dl.pfOutPos -= mdl->dl.lBufferSize;
out += mdl->fOne_m_D * (*(mdl->dl.pfOutPos) - mdl->buffer);
mdl->buffer = out;
return out;
}
#else
#endif
/*-----------------------------------------------------------------------------
Early part
-----------------------------------------------------------------------------*/
#define EARLY_REF_FIR_SIZE 0.60f
#define NB_TAPS 4
struct _fluid_early {
MDelayLine earlyRefFIR;
long lPreDelay;
long lTapTimeL[NB_TAPS];
long lTapTimeR[NB_TAPS];
fluid_real_t fTapGainL[NB_TAPS];
fluid_real_t fTapGainR[NB_TAPS];
};
typedef struct _fluid_early fluid_early;
int CreateFluidEarly(fluid_early * early, fluid_real_t sample_rate)
{
int result;
CreateMdelayLine(&early->earlyRefFIR);
result = SetMaxDelayMDelayLine (&early->earlyRefFIR,
(long)(EARLY_REF_FIR_SIZE * sample_rate));
if (result == FLUID_FAILED) {
return FLUID_FAILED;
}
/*-----------------------------------------------------------------------*/
early->lPreDelay = 1102; // Pre delay (in samples)
early->lTapTimeL[0] = early->lPreDelay + (long)(0.0090 * sample_rate);
early->lTapTimeL[1] = early->lPreDelay + (long)(0.0118 * sample_rate);
early->lTapTimeL[2] = early->lPreDelay + (long)(0.0213 * sample_rate);
// early->lTapTimeL[3] = early->lPreDelay + (long)(0.0205 * sample_rate);
early->lTapTimeL[3] = early->lPreDelay + (long)(0.3205 * sample_rate);
early->lTapTimeR[0] = early->lPreDelay + (long)(0.0145 * sample_rate);
early->lTapTimeR[1] = early->lPreDelay + (long)(0.0100 * sample_rate);
early->lTapTimeR[2] = early->lPreDelay + (long)(0.0205 * sample_rate);
// early->lTapTimeR[3] = early->lPreDelay + (long)(0.0230 * sample_rate);
early->lTapTimeR[3] = early->lPreDelay + (long)(0.5230 * sample_rate);
early->fTapGainL[0] = 1.35f;
early->fTapGainL[1] = -1.15f;
early->fTapGainL[2] = -1.14f;
early->fTapGainL[3] = 1.15f;
early->fTapGainR[0] = 1.35f;
early->fTapGainR[1] = -1.16f;
early->fTapGainR[2] = -1.00f;
early->fTapGainR[3] = 1.14f;
// printf("end of CreateFluidEarly\n");
return result;
}
/*-----------------------------------------------------------------------------
fluid_early destructor
-----------------------------------------------------------------------------*/
void DestroyFluidEarly(fluid_early * early)
{
DestroyMdelayLine(&early->earlyRefFIR); /* destruction */
}
/*-----------------------------------------------------------------------------
Late structure
-----------------------------------------------------------------------------*/
#define minRT 1.0f
//#define maxRT 50.50f
#define maxRT 10.0f
#define rangeRT (maxRT - minRT)
//#define minAlpha 0.2f
#define getDCRevTime(roomsize) (minRT + rangeRT * roomsize)
#define getPIRevTime(dcRT,damp) (dcRT*(1 - damp * (1 - minAlpha)))
#define DCRevTime 20.0f;
#define PIRevTime 20.0f;
#define ModDepth 6
#define ModRate 50
#define freqModOsc 1.0f
#define NB_DELAYS 8
#define NB_MOD_DELAYS 8
#define Phase (360.0/(float) NB_MOD_DELAYS)
#define NB_FIXED_DELAYS (NB_DELAYS - NB_MOD_DELAYS)
#define USE_OSC_MODULATION
#define USE_VARIABLE_RATES
struct _fluid_late
{
fluid_real_t samplerate;
fluid_real_t fDCRevTime;
fluid_real_t fPIRevTime;
fluid_real_t toneBuffer;
fluid_real_t b1,b2;
long lTau[NB_DELAYS];
#if (NB_MOD_DELAYS>0)
fluid_ModDelayLine modDelayLine[NB_MOD_DELAYS];
long lModDepth[NB_MOD_DELAYS];
long lModRate[NB_MOD_DELAYS];
#ifdef USE_OSC_MODULATION
MSinOsc mod[NB_MOD_DELAYS];
float fModFreq[NB_MOD_DELAYS];
float fModPhase[NB_MOD_DELAYS];
#endif
#endif
#if (NB_FIXED_DELAYS > 0)
MDelayLine delayLine[NB_DELAYS];
#endif
fluid_lpf dampingLPF[NB_DELAYS];
fluid_real_t fkp[NB_DELAYS];
fluid_real_t fbp[NB_DELAYS];
fluid_real_t fA[NB_DELAYS][NB_DELAYS];
fluid_real_t fFeedConstant;
fluid_real_t fcL[NB_DELAYS];
fluid_real_t fcR[NB_DELAYS];
};
typedef struct _fluid_late fluid_late;
void DestroyFluidLate(fluid_late * late);
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void UpdateRevTimeDamping(fluid_late * late, fluid_real_t damp)
{
int i;
fluid_real_t T = 1/late->samplerate;
fluid_real_t alpha;
fluid_real_t fkp;
fluid_real_t fbp;
fluid_real_t beta;
fkp = (fluid_real_t )pow(10,-3 * late->lTau[NB_DELAYS-1] *T /
late->fDCRevTime);
fbp = damp * 0.9;
alpha = sqrt( 1/ (1- fbp/(20*log10(fkp)*log(10)/80)) );
late->fPIRevTime = alpha * late->fDCRevTime;
for(i=0;i<NB_DELAYS;i++){
fkp = (fluid_real_t )pow(10,-3 * late->lTau[i] *T /
late->fDCRevTime);
fbp = (fluid_real_t)(20*log10(fkp)*log(10)/80 *
(1 - 1/pow(alpha,2)));
SetCoeffsLpf(&late->dampingLPF[i],fkp * (1- fbp),(-1) * fbp);
}
beta = (1 - sqrt ((double) alpha)) / (1 + sqrt((double)alpha));
// beta = (1 - alpha) / (1 + alpha);
late->b1 = 1/(1-beta);
late->b2 = beta * late->b1;
#if 1
#if (NB_MOD_DELAYS>0)
for(i=0;i<NB_MOD_DELAYS;i++){
fkp = (fluid_real_t )pow(10,-3 * late->lTau[i] *T /
late->fDCRevTime);
fbp = (fluid_real_t)(20*log10(fkp)*log(10)/80 *
(1 - 1/pow(alpha,2)));
SetCoeffsLpf(&late->modDelayLine[i].dl.dampingLPF,fkp * (1-
fbp),(-1) * fbp);
// printf("line:%d fkp=%f, fbp=%f, alpha=%f, beta=%f, b1=%f,
b2=%f\n",i,fkp,fbp,
// alpha,beta, late->b1, late->b2);
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(i=NB_MOD_DELAYS;i<NB_DELAYS;i++){
fkp = (fluid_real_t )pow(10,-3 * late->lTau[i] *T /
late->fDCRevTime);
fbp = (fluid_real_t)(20*log10(fkp)*log(10)/80 *
(1 - 1/pow(alpha,2)));
SetCoeffsLpf(&late->delayLine[i].dampingLPF,fkp * (1- fbp),(-1)
* fbp);
}
#endif
#endif
}
void UpdateStereoCoefficient(fluid_late * late, fluid_real_t wet1)
{
int i;
for(i=0;i<NB_DELAYS;i++){
late->fcL[i] = wet1;
if((i%2)!=0)
late->fcL[i] *= -1 ;
if((i==1)||(i==2)||(i==5)||(i==6)||(i==9)||(i==10)||(i==13)||(i==14))
late->fcR[i] = -1 * late->fcL[i];
else
late->fcR[i] = late->fcL[i];
}
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int CreateFluidLate(fluid_late * late, fluid_real_t sample_rate)
{
int result ; /* return value */
long i,j ;
late->samplerate = sample_rate;
// late->fDCRevTime = 3.00f;
// late->fPIRevTime = 1.25f;
late->fDCRevTime = DCRevTime;
late->fPIRevTime = PIRevTime;
late->toneBuffer = 0.0f;
#if (NB_DELAYS == 1)
late->lTau[0] = 1000;
#elif (NB_DELAYS == 4)
late->lTau[0] = 601;
late->lTau[1] = 691;
late->lTau[2] = 773;
late->lTau[3] = 839;
#elif (NB_DELAYS == 8)
late->lTau[0] = 601;
late->lTau[1] = 691;
late->lTau[2] = 773;
late->lTau[3] = 839;
late->lTau[4] = 919;
late->lTau[5] = 997;
late->lTau[6] = 1061;
late->lTau[7] = 1129;
#elif (NB_DELAYS == 12)
late->lTau[0] = 601;
late->lTau[1] = 691;
late->lTau[2] = 773;
late->lTau[3] = 839;
late->lTau[4] = 919;
late->lTau[5] = 997;
late->lTau[6] = 1061;
late->lTau[7] = 1093;
late->lTau[8] = 1129;
late->lTau[9] = 1151;
late->lTau[10] = 1171;
late->lTau[11] = 1187;
#elif (NB_DELAYS == 16)
late->lTau[0] = 919;
late->lTau[1] = 997;
late->lTau[2] = 1061;
late->lTau[3] = 1093;
late->lTau[4] = 1129;
late->lTau[5] = 1151;
late->lTau[6] = 1171;
late->lTau[7] = 1187;
late->lTau[8] = 1213;
late->lTau[9] = 1237;
late->lTau[10] = 1259;
late->lTau[11] = 1283;
late->lTau[12] = 1303;
late->lTau[13] = 1319;
late->lTau[14] = 1327;
late->lTau[15] = 1361;
#endif
//--------------------------------------------------------------------------
#if (NB_MOD_DELAYS>0)
for(i=0;i<NB_MOD_DELAYS;i++){
// late->lModDepth[i] = 6;
late->lModDepth[i] = ModDepth;
}
for(i=0;i<NB_MOD_DELAYS;i++){
// late->lModRate[i] = 50;
late->lModRate[i] = ModRate;
}
for(i=0;i<NB_MOD_DELAYS;i++){
CreateModDelayLine(&late->modDelayLine[i]);
result = SetNomDelay(&late->modDelayLine[i],late->lTau[i]);
if (result == FLUID_FAILED) {
DestroyFluidLate(late);
return FLUID_FAILED;
}
SetModDepth(&late->modDelayLine[i],late->lModDepth[i]);
#ifdef USE_VARIABLE_RATES
SetModRate(&late->modDelayLine[i], late->lModRate[i]);
#endif
}
#ifdef USE_OSC_MODULATION
for(i=0;i<NB_MOD_DELAYS;i++){
// late->fModFreq[i] = (float)(2);
late->fModFreq[i] = freqModOsc;
}
for(i=0;i<NB_MOD_DELAYS;i++){
late->fModPhase[i] = (float)(Phase *i); // 45 degree
}
for(i=0;i<NB_MOD_DELAYS;i++){
#ifdef USE_VARIABLE_RATES
SetFreqOsc(&late->modDelayLine[i].mod,
late->fModFreq[i]* late->lModRate[i],
sample_rate,late->fModPhase[i]);
#else
SetFreqOsc(&late->modDelayLine[i].mod,late->fModFreq[i],
sample_rate,late->fModPhase[i]);
#endif
}
#endif
#endif
#if (NB_FIXED_DELAYS > 0)
for(i=NB_MOD_DELAYS;i<NB_DELAYS;i++){
CreateMdelayLine(&late->delayLine[i]);
result = SetMaxDelayMDelayLine (&late->delayLine[i],
late->lTau[i]);
if (result == FLUID_FAILED) {
DestroyFluidLate(late);
return FLUID_FAILED;
}
}
#endif
{
fluid_real_t T = 1/sample_rate;
fluid_real_t alpha = late->fPIRevTime/late->fDCRevTime;
for(i=0;i<NB_DELAYS;i++){
CreateLpf(&late->dampingLPF[i]);
late->fkp[i] = (fluid_real_t )pow(10,-3 * late->lTau[i]
*T /
late->fDCRevTime);
late->fbp[i] =
(fluid_real_t)(20*log10(late->fkp[i])*log(10)/80 *
(1 - 1/pow(alpha,2)));
SetCoeffsLpf(&late->dampingLPF[i],late->fkp[i] * (1-
late->fbp[i]),
(-1) *
late->fbp[i]);
}
}
{
fluid_real_t fTwoDivByNbDelays = (fluid_real_t)(2.0/NB_DELAYS);
for(i=0;i<NB_DELAYS;i++){
for(j=0;j<NB_DELAYS;j++){
if((j==(i+1))||((i==(NB_DELAYS-1))&&(j==0)))
late->fA[i][j] = 1;
else
late->fA[i][j] = 0;
late->fA[i][j] -= fTwoDivByNbDelays;
}
}
late->fFeedConstant = (fluid_real_t)(-2.0)/NB_DELAYS;
// late->fFeedConstant = (fluid_real_t)(2.0)/NB_DELAYS;
}
UpdateStereoCoefficient(late, 1.0f);
return FLUID_OK;
}
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void DestroyFluidLate(fluid_late * late)
{
long i;
#if (NB_MOD_DELAYS>0)
for(i=0;i<NB_MOD_DELAYS;i++){
DestroyModDelayLine(&late->modDelayLine[i]);
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(i=NB_MOD_DELAYS;i<NB_DELAYS;i++){
DestroyMdelayLine(&late->delayLine[i]);
}
#endif
}
typedef struct _fluid_allpass fluid_allpass;
typedef struct _fluid_comb fluid_comb;
struct _fluid_allpass {
fluid_real_t feedback;
fluid_real_t *buffer;
int bufsize;
int bufidx;
};
void fluid_allpass_init(fluid_allpass* allpass);
void fluid_allpass_setfeedback(fluid_allpass* allpass, fluid_real_t val);
fluid_real_t fluid_allpass_getfeedback(fluid_allpass* allpass);
void
fluid_allpass_setbuffer(fluid_allpass* allpass, int size)
{
allpass->bufidx = 0;
allpass->buffer = FLUID_ARRAY(fluid_real_t,size);
allpass->bufsize = size;
}
void
fluid_allpass_release(fluid_allpass* allpass)
{
FLUID_FREE(allpass->buffer);
}
void
fluid_allpass_init(fluid_allpass* allpass)
{
int i;
int len = allpass->bufsize;
fluid_real_t* buf = allpass->buffer;
for (i = 0; i < len; i++) {
buf[i] = DC_OFFSET; /* this is not 100 % correct. */
}
}
void
fluid_allpass_setfeedback(fluid_allpass* allpass, fluid_real_t val)
{
allpass->feedback = val;
}
fluid_real_t
fluid_allpass_getfeedback(fluid_allpass* allpass)
{
return allpass->feedback;
}
#define fluid_allpass_process(_allpass, _input) \
{ \
fluid_real_t output; \
fluid_real_t bufout; \
bufout = _allpass.buffer[_allpass.bufidx]; \
output = bufout-_input; \
_allpass.buffer[_allpass.bufidx] = _input + (bufout * _allpass.feedback); \
if (++_allpass.bufidx >= _allpass.bufsize) { \
_allpass.bufidx = 0; \
} \
_input = output; \
}
struct _fluid_comb {
fluid_real_t feedback;
fluid_real_t filterstore;
fluid_real_t damp1;
fluid_real_t damp2;
fluid_real_t *buffer;
int bufsize;
int bufidx;
};
void fluid_comb_setbuffer(fluid_comb* comb, int size);
void fluid_comb_release(fluid_comb* comb);
void fluid_comb_init(fluid_comb* comb);
void fluid_comb_setdamp(fluid_comb* comb, fluid_real_t val);
fluid_real_t fluid_comb_getdamp(fluid_comb* comb);
void fluid_comb_setfeedback(fluid_comb* comb, fluid_real_t val);
fluid_real_t fluid_comb_getfeedback(fluid_comb* comb);
void
fluid_comb_setbuffer(fluid_comb* comb, int size)
{
comb->filterstore = 0;
comb->bufidx = 0;
comb->buffer = FLUID_ARRAY(fluid_real_t,size);
comb->bufsize = size;
}
void
fluid_comb_release(fluid_comb* comb)
{
FLUID_FREE(comb->buffer);
}
void
fluid_comb_init(fluid_comb* comb)
{
int i;
fluid_real_t* buf = comb->buffer;
int len = comb->bufsize;
for (i = 0; i < len; i++) {
buf[i] = DC_OFFSET; /* This is not 100 % correct. */
}
}
void
fluid_comb_setdamp(fluid_comb* comb, fluid_real_t val)
{
comb->damp1 = val;
comb->damp2 = 1 - val;
}
fluid_real_t
fluid_comb_getdamp(fluid_comb* comb)
{
return comb->damp1;
}
void
fluid_comb_setfeedback(fluid_comb* comb, fluid_real_t val)
{
comb->feedback = val;
}
fluid_real_t
fluid_comb_getfeedback(fluid_comb* comb)
{
return comb->feedback;
}
#define fluid_comb_process(_comb, _input, _output) \
{ \
fluid_real_t _tmp = _comb.buffer[_comb.bufidx]; \
_comb.filterstore = (_tmp * _comb.damp2) + (_comb.filterstore * _comb.damp1);
\
_comb.buffer[_comb.bufidx] = _input + (_comb.filterstore * _comb.feedback); \
if (++_comb.bufidx >= _comb.bufsize) { \
_comb.bufidx = 0; \
} \
_output += _tmp; \
}
#define numcombs 8
#define numallpasses 4
#define fixedgain 0.015f
#define scalewet 3.0f
#define scaledamp 1.0f
#define scaleroom 0.28f
#define offsetroom 0.7f
#define initialroom 0.5f
#define initialdamp 0.2f
#define initialwet 1
#define initialdry 0
#define initialwidth 1
#define stereospread 23
/*
These values assume 44.1KHz sample rate
they will probably be OK for 48KHz sample rate
but would need scaling for 96KHz (or other) sample rates.
The values were obtained by listening tests.
*/
#define combtuningL1 1116
#define combtuningR1 (1116 + stereospread)
#define combtuningL2 1188
#define combtuningR2 (1188 + stereospread)
#define combtuningL3 1277
#define combtuningR3 (1277 + stereospread)
#define combtuningL4 1356
#define combtuningR4 (1356 + stereospread)
#define combtuningL5 1422
#define combtuningR5 (1422 + stereospread)
#define combtuningL6 1491
#define combtuningR6 (1491 + stereospread)
#define combtuningL7 1557
#define combtuningR7 (1557 + stereospread)
#define combtuningL8 1617
#define combtuningR8 (1617 + stereospread)
#define allpasstuningL1 556
#define allpasstuningR1 (556 + stereospread)
#define allpasstuningL2 441
#define allpasstuningR2 (441 + stereospread)
#define allpasstuningL3 341
#define allpasstuningR3 (341 + stereospread)
#define allpasstuningL4 225
#define allpasstuningR4 (225 + stereospread)
#if 0
struct _fluid_revmodel_t {
fluid_real_t roomsize;
fluid_real_t damp;
fluid_real_t wet, wet1, wet2;
fluid_real_t width;
fluid_real_t gain;
/*
The following are all declared inline
to remove the need for dynamic allocation
with its subsequent error-checking messiness
*/
/* Comb filters */
fluid_comb combL[numcombs];
fluid_comb combR[numcombs];
/* Allpass filters */
fluid_allpass allpassL[numallpasses];
fluid_allpass allpassR[numallpasses];
};
#else
struct _fluid_revmodel_t {
fluid_real_t roomsize;
fluid_real_t damp;
fluid_real_t wet, wet1, wet2;
fluid_real_t width;
fluid_real_t gain;
/*
The following are all declared inline
to remove the need for dynamic allocation
with its subsequent error-checking messiness
*/
/* Comb filters */
fluid_comb combL[numcombs];
fluid_comb combR[numcombs];
/* Allpass filters */
fluid_allpass allpassL[numallpasses];
fluid_allpass allpassR[numallpasses];
//--------------------------------------
// freemverb
fluid_early early;
fluid_late late;
};
#endif
/*-----------------------------------------------------------------------------
freemverb process replace
-----------------------------------------------------------------------------*/
void
fluid_revmodel_m_processreplace(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
int p, k = 0;
// fluid_real_t outL, outR, input;
fluid_real_t xn; // input mono x(n)
fluid_real_t yn1, yn2; // output stereo Left (yn1) and Right (yn2)
fluid_real_t factor;
fluid_real_t fQ[NB_DELAYS]; // Line output/LPF Output
fluid_real_t fS[NB_DELAYS]; // Matrix Output
for (k = 0; k < FLUID_BUFSIZE; k++) {
// outL = outR = 0;
xn = (2.0f * in[k] + DC_OFFSET) * rev->gain;
// yn1 = yn2 = xn;
yn1 = yn2 = 0;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
fQ[p]= GetCurValueModDelayLine(&rev->late.modDelayLine[p]);
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
yn1 += rev->late.fcL[p]*fQ[p]; // stereo left = left + fCL * fQ
yn2 += rev->late.fcR[p]*fQ[p]; // stereo right= right+ fCR * fQ
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
fQ[p] = GetLastMDelayLine(&rev->late.delayLine[p]);
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
yn1 += rev->late.fcL[p]*fQ[p]; // stereo left = left + fCL * fQ
yn2 += rev->late.fcR[p]*fQ[p]; // stereo right= right+ fCR * fQ
}
#endif
factor = 0;
for(p=0;p<NB_DELAYS;p++){
factor += fQ[p];
}
factor *= rev->late.fFeedConstant; //factor = output sum *
(-2.0)/NB_DELAYS;
for(p=1;p<NB_DELAYS;p++){
fS[p-1] = fQ[p] + factor;
}
fS[NB_DELAYS-1] = fQ[0] + factor;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
fS[p] += xn;
PushMDelayLine (&rev->late.modDelayLine[p].dl,&fS[p]);
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
fS[p] += xn;
PushMDelayLine (&rev->late.delayLine[p],&fS[p]);
}
#endif
//-------------------------------------------------------------
yn1 -= DC_OFFSET;
yn2 -= DC_OFFSET;
left_out[k] = yn1 * rev->wet1 + yn2 * rev->wet2;
right_out[k] = yn2 * rev->wet1 + yn1 * rev->wet2;
}
}
#if 0
long c=0;
#endif
/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
#if 0
void
fluid_revmodel_m_processmix(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
int p, k = 0;
// fluid_real_t outL, outR, input;
fluid_real_t xn;
fluid_real_t yn1, yn2;
fluid_real_t factor;
fluid_real_t fQ[NB_DELAYS];
fluid_real_t fS[NB_DELAYS];
for (k = 0; k < FLUID_BUFSIZE; k++) {
// outL = outR = 0;
xn = (2.0f * in[k] + DC_OFFSET) * rev->gain;
//-----------------------------------------------------------
// yn1 = yn2 = xn;
yn1 = yn2 = 0;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
fQ[p]= GetCurValueModDelayLine(&rev->late.modDelayLine[p]);
// printf("m: c=%d\n", c++);
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
yn1 += rev->late.fcL[p]*fQ[p]; // stereo left = left + fCL * fQ
yn2 += rev->late.fcR[p]*fQ[p]; // stereo right= right+ fCR * fQ
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
// printf("f1: c=%d, line:%d\n", c++, p);
fQ[p] = GetLastMDelayLine(&rev->late.delayLine[p]);
// printf("f2: c=%d\n", c++);
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
yn1 += rev->late.fcL[p]*fQ[p]; // stereo left = left + fCL * fQ
yn2 += rev->late.fcR[p]*fQ[p]; // stereo right= right+ fCR * fQ
}
#endif
factor = 0;
for(p=0;p<NB_DELAYS;p++){
factor += fQ[p];
}
factor *= rev->late.fFeedConstant; //factor = output sum *
(-2.0)/NB_DELAYS;
for(p=1;p<NB_DELAYS;p++){
fS[p-1] = fQ[p] + factor;
}
fS[NB_DELAYS-1] = fQ[0] + factor;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
fS[p] += xn;
PushMDelayLine (&rev->late.modDelayLine[p].dl,&fS[p]);
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
fS[p] += xn;
PushMDelayLine (&rev->late.delayLine[p],&fS[p]);
}
#endif
//-------------------------------------------------------------
yn1 -= DC_OFFSET;
yn2 -= DC_OFFSET;
left_out[k] += yn1 * rev->wet1 + yn2 * rev->wet2;
right_out[k] += yn2 * rev->wet1 + yn1 * rev->wet2;
}
}
#else
#define EARLY_PART 0
#define LATE_PART 1
void fluid_revmodel_m_processmix(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
int p , k = 0;
// fluid_real_t outL, outR, input;
MDelayLine * dlEarly;
fluid_real_t xn,xnt;
fluid_real_t yn1, yn2;
fluid_real_t factor,t;
fluid_real_t fQ[NB_DELAYS];
fluid_real_t fS[NB_DELAYS];
for (k = 0; k < FLUID_BUFSIZE; k++) {
// outL = outR = 0;
yn1 = yn2 = 0;
#if EARLY_PART
dlEarly = &rev->early.earlyRefFIR;
// xn = 2.0 * in[k] ;
xn = in[k] ;
//-----------------------------------------------------------
// yn1 = yn2 = xn;
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
#if 0
PushMDelayLine (&rev->early.earlyRefFIR,&xn);
#else
* dlEarly->pfInPos = xn;
if(++dlEarly->pfInPos >= dlEarly->pfBufferEnd)
dlEarly->pfInPos -= dlEarly->lBufferSize;
#endif
for( p=0;p<NB_TAPS;p++){
// left: yn1 = xn + GainLi] * tap[i]
#if 0
yn1 += rev->early.fTapGainL[p] * GetAtMDelayLine
(&rev->early.earlyRefFIR,rev->early.lTapTimeL[p] );
// right: yn2 = xn + GainRi] * tap[i]
yn2 += rev->early.fTapGainR[p] * GetAtMDelayLine
(&rev->early.earlyRefFIR,rev->early.lTapTimeR[p] );
#else
// MDelayLine * dl = &rev->early.earlyRefFIR;
fluid_real_t * pAt;
pAt = dlEarly->pfInPos - rev->early.lTapTimeL[p] - 1;
if(pAt < dlEarly->pfBuffer) pAt += dlEarly->lBufferSize;
yn1 += rev->early.fTapGainL[p] * (* pAt);
pAt = dlEarly->pfInPos - rev->early.lTapTimeR[p] - 1;
if(pAt < dlEarly->pfBuffer) pAt += dlEarly->lBufferSize;
yn2 += rev->early.fTapGainR[p] * (* pAt);
#endif
}
#endif
/*=======================================================================*/
#if LATE_PART
#if EARLY_PART
//#define pre_early 25000 // 566 ms
//#define pre_early 20800 // 470 ms
//#define pre_early 10400 // 280 ms
//#define pre_early 6615 // 150 ms
#define pre_early 4410 // 100 ms
//#define pre_early 3306 // 60 ms
//#define pre_early 0 // 10 ms
#if 0
// xn = GetAtMDelayLine
(&rev->early.earlyRefFIR,rev->early.lPreDelay );
xn = GetAtMDelayLine
(&rev->early.earlyRefFIR,pre_early );
#else
{
// MDelayLine * dl = &rev->early.earlyRefFIR;
fluid_real_t * pAt;
pAt = dlEarly->pfInPos - pre_early - 1;
/* circular motion if necessary */
if(pAt < dlEarly->pfBuffer) pAt += dlEarly->lBufferSize;
xn = * pAt;
}
#endif
#else
xn = in[k];
#endif // EARLY_PART
xn = (2.0f * xn + DC_OFFSET) * rev->gain;
//----------------------------------------------------------
#if 1
// yn1 = xn - rev->late.beta * rev->late.toneBuffer;
xnt = xn * rev->late.b1 - rev->late.b2 * rev->late.toneBuffer;
rev->late.toneBuffer = xn;
xn = xnt;
#endif
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
factor = 0;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
#if 0
// printf("m1_1\n");
fQ[p]=
GetCurValueModDelayLine(&rev->late.modDelayLine[p]);
// printf("m: c=%d\n", c++);
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
factor += fQ[p];
yn1 += rev->late.fcL[p]*fQ[p]; // stereo left = left +
fCL * fQ
yn2 += rev->late.fcR[p]*fQ[p]; // stereo right= right+
fCR * fQ
#else // optimisation 4: 1.34 % --> 1.2 %
#if 0
t =
GetCurValueModDelayLine(&rev->late.modDelayLine[p]);
t = t * rev->late.dampingLPF[p].b0 -
rev->late.dampingLPF[p].buffer *
rev->late.dampingLPF[p].a1;
rev->late.dampingLPF[p].buffer = t;
#else
fluid_ModDelayLine * mdl = &rev->late.modDelayLine[p];
t = GetCurValueModDelayLine(mdl);
t = t * mdl->dl.dampingLPF.b0 -
mdl->dl.dampingLPF.buffer *
mdl->dl.dampingLPF.a1;
mdl->dl.dampingLPF.buffer = t;
#endif
fQ[p] = t;
factor += t;
yn1 += rev->late.fcL[p]* t;
yn2 += rev->late.fcR[p]* t;
#endif
}
#endif // NB_MOD_DELAYS
#if (NB_FIXED_DELAYS > 0)
// We end with the fixed delay line
#if 0
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
// printf("f1: c=%d, line:%d\n", c++, p);
#if 0
// fQ[p] =
GetLastMDelayLine(&rev->late.delayLine[p]);
t =
GetLastMDelayLine(&rev->late.delayLine[p]);
#else
// fQ[p] = *
(rev->late.delayLine[p].pfOutPos);
t = * (rev->late.delayLine[p].pfOutPos);
if(++rev->late.delayLine[p].pfOutPos >=
rev->late.delayLine[p].pfBufferEnd)
rev->late.delayLine[p].pfOutPos -=
rev->late.delayLine[p].lBufferSize;
#endif
// printf("f2: c=%d\n", c++);
//process LPF (input:fQ, output:fQ)
#if 0
ProcessLpf(&rev->late.dampingLPF[p],&fQ[p],&fQ[p]);
factor += fQ[p];
#else
// fQ[p] = fQ[p] * rev->late.dampingLPF[p].b0 -
rev->late.dampingLPF[p].buffer *
// fQ[p] = t * rev->late.dampingLPF[p].b0 -
rev->late.dampingLPF[p].buffer *
// t = t * rev->late.dampingLPF[p].b0 -
rev->late.dampingLPF[p].buffer *
// rev->late.dampingLPF[p].a1;
// rev->late.dampingLPF[p].buffer = t;
t = t * rev->late.delayLine[p].dampingLPF.b0 -
rev->late.delayLine[p].dampingLPF.buffer *
rev->late.delayLine[p].dampingLPF.a1;
rev->late.delayLine[p].dampingLPF.buffer = t;
fQ[p] = t;
factor += t;
#endif
// Process stereo output
yn1 += rev->late.fcL[p] * t; // stereo left = left + fCL * fQ
yn2 += rev->late.fcR[p] * t; // stereo right= right+ fCR * fQ
}
#else
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
MDelayLine * dl = &rev->late.delayLine[p];
t = * (dl->pfOutPos);
if(++dl->pfOutPos >= dl->pfBufferEnd)
dl->pfOutPos -= dl->lBufferSize;
// t = t * rev->late.dampingLPF[p].b0 -
rev->late.dampingLPF[p].buffer *
// rev->late.dampingLPF[p].a1;
// rev->late.dampingLPF[p].buffer = t;
t = t * dl->dampingLPF.b0 - dl->dampingLPF.buffer *
dl->dampingLPF.a1;
dl->dampingLPF.buffer = t;
fQ[p] = t;
factor += t;
yn1 += rev->late.fcL[p] * t;
yn2 += rev->late.fcR[p] * t;
}
#endif
#endif
// factor = 0;
// for(p=0;p<NB_DELAYS;p++){
// factor += fQ[p];
// }
factor *= rev->late.fFeedConstant;
factor += xn;
#if 1
for(p=1;p<NB_DELAYS;p++){
// MDelayLine * dl = &rev->late.delayLine[p-1];
MDelayLine * dl = &rev->late.modDelayLine[p-1].dl;
// fS[p-1] = fQ[p] + factor;
{
#if 0
* rev->late.delayLine[p-1].pfInPos = fQ[p] + factor;
if(++rev->late.delayLine[p-1].pfInPos >=
rev->late.delayLine[p-1].pfBufferEnd)
rev->late.delayLine[p-1].pfInPos -=
rev->late.delayLine[p-1].lBufferSize;
#else
* dl->pfInPos = fQ[p] + factor;
if(++dl->pfInPos >= dl->pfBufferEnd)
dl->pfInPos -= dl->lBufferSize;
// dl->pfBuffer[dl->inPos] = fQ[p] + factor;
// if(++dl->inPos >= dl->lBufferSize)
// dl->inPos -= dl->lBufferSize;
#endif
}
}
// fS[NB_DELAYS-1] = fQ[0] + factor;
{
#if 0
* rev->late.delayLine[NB_DELAYS-1].pfInPos = fQ[0] +
factor;
if(++rev->late.delayLine[NB_DELAYS-1].pfInPos >=
rev->late.delayLine[NB_DELAYS-1].pfBufferEnd)
rev->late.delayLine[NB_DELAYS-1].pfInPos -=
rev->late.delayLine[NB_DELAYS-1].lBufferSize;
#else
// MDelayLine * dl =
&rev->late.modDelayLine[NB_DELAYS-1].dl;
// dl->pfBuffer[dl->inPos] = fQ[0] + factor;
// if(++dl->inPos >= dl->lBufferSize)
// dl->inPos -= dl->lBufferSize;
{
#if 0
* rev->late.modDelayLine[NB_DELAYS-1].dl.pfInPos =
fQ[0] + factor;
if(++rev->late.modDelayLine[NB_DELAYS-1].dl.pfInPos >=
rev->late.modDelayLine[NB_DELAYS-1].dl.pfBufferEnd)
rev->late.modDelayLine[NB_DELAYS-1].dl.pfInPos
-= rev->late.modDelayLine[NB_DELAYS-1].dl.lBufferSize;
#else
MDelayLine * dl =
&rev->late.modDelayLine[NB_DELAYS-1].dl; // entrée ligne modulées
* dl->pfInPos = fQ[0] + factor;
if(++dl->pfInPos >= dl->pfBufferEnd)
dl->pfInPos -= dl->lBufferSize;
#endif
}
//
rev->late.modDelayLine[NB_DELAYS-1].dl.pfBuffer[rev->late.modDelayLine[NB_DELAYS-1].dl.inPos]
=
// fQ[0] + factor;
//
if(++rev->late.modDelayLine[NB_DELAYS-1].dl.inPos >
rev->late.modDelayLine[NB_DELAYS-1].dl.lBufferSize)
//
rev->late.modDelayLine[NB_DELAYS-1].dl.inPos -=
rev->late.modDelayLine[NB_DELAYS-1].dl.lBufferSize;
#endif
}
#else
for(p=1;p<NB_DELAYS;p++){
fS[p-1] = fQ[p] + factor;
}
fS[NB_DELAYS-1] = fQ[0] + factor;
#if (NB_MOD_DELAYS>0)
for(p=0;p<NB_MOD_DELAYS;p++){
// fS[p] += xn;
// PushMDelayLine (&rev->late.modDelayLine[p].dl,&fS[p]);
{
* rev->late.modDelayLine[p].dl.pfInPos = fS[p];
if(++rev->late.modDelayLine[p].dl.pfInPos >=
rev->late.modDelayLine[p].dl.pfBufferEnd)
rev->late.modDelayLine[p].dl.pfInPos -=
rev->late.modDelayLine[p].dl.lBufferSize;
}
}
#endif
#if (NB_FIXED_DELAYS > 0)
for(p=NB_MOD_DELAYS;p<NB_DELAYS;p++){
// fS[p] += xn;
#if 0
PushMDelayLine (&rev->late.delayLine[p],&fS[p]);
#else
{
* rev->late.delayLine[p].pfInPos = fS[p];
if(++rev->late.delayLine[p].pfInPos >=
rev->late.delayLine[p].pfBufferEnd)
rev->late.delayLine[p].pfInPos -=
rev->late.delayLine[p].lBufferSize;
}
#endif
}
#endif
#endif
//-------------------------------------------------------------
yn1 -= DC_OFFSET;
yn2 -= DC_OFFSET;
#endif //LATE_PART
#if 1
left_out[k] += yn1 * rev->wet1 + yn2 * rev->wet2;
right_out[k] += yn2 * rev->wet1 + yn1 * rev->wet2;
#else
left_out[k] += yn1 + yn2 * rev->wet2;
right_out[k] += yn2 + yn1 * rev->wet2;
#endif
}
}
#endif
static void fluid_revmodel_update(fluid_revmodel_t* rev);
static void fluid_revmodel_init(fluid_revmodel_t* rev);
void fluid_set_revmodel_buffers(fluid_revmodel_t* rev, fluid_real_t
sample_rate);
fluid_revmodel_t*
new_fluid_revmodel(void )
{
fluid_revmodel_t* rev;
rev = FLUID_NEW(fluid_revmodel_t);
if (rev == NULL) {
return NULL;
}
//
if (freemverb)
{
if( CreateFluidEarly(&rev->early,44100) == FLUID_OK &&
CreateFluidLate(&rev->late,44100) == FLUID_OK)
{
// rev->gain = fixedgain;
rev->gain = 0.05f;
fluid_revmodel_set(rev,FLUID_REVMODEL_SET_ALL,initialroom,initialdamp,initialwidth,initialwet);
printf("Fluidsynth: using freemverb-demo (in process mixing only
!)\n\n");
}
else return NULL;
}
else
{
fluid_set_revmodel_buffers(rev, 44100);
/* Set default values */
fluid_allpass_setfeedback(&rev->allpassL[0], 0.5f);
fluid_allpass_setfeedback(&rev->allpassR[0], 0.5f);
fluid_allpass_setfeedback(&rev->allpassL[1], 0.5f);
fluid_allpass_setfeedback(&rev->allpassR[1], 0.5f);
fluid_allpass_setfeedback(&rev->allpassL[2], 0.5f);
fluid_allpass_setfeedback(&rev->allpassR[2], 0.5f);
fluid_allpass_setfeedback(&rev->allpassL[3], 0.5f);
fluid_allpass_setfeedback(&rev->allpassR[3], 0.5f);
rev->gain = fixedgain;
fluid_revmodel_set(rev,FLUID_REVMODEL_SET_ALL,initialroom,initialdamp,initialwidth,initialwet);
printf("Fluidsynth: using freeverb\n\n");
}
return rev;
}
void
delete_fluid_revmodel(fluid_revmodel_t* rev)
{
int i;
if (freemverb)
{
DestroyFluidEarly(&rev->early);
DestroyFluidLate(&rev->late);
}
else {
for (i = 0; i < numcombs;i++) {
fluid_comb_release(&rev->combL[i]);
fluid_comb_release(&rev->combR[i]);
}
for (i = 0; i < numallpasses; i++) {
fluid_allpass_release(&rev->allpassL[i]);
fluid_allpass_release(&rev->allpassR[i]);
}
}
FLUID_FREE(rev);
}
void
fluid_set_revmodel_buffers(fluid_revmodel_t* rev, fluid_real_t sample_rate) {
float srfactor = sample_rate/44100.0f;
fluid_comb_setbuffer(&rev->combL[0], combtuningL1*srfactor);
fluid_comb_setbuffer(&rev->combR[0], combtuningR1*srfactor);
fluid_comb_setbuffer(&rev->combL[1], combtuningL2*srfactor);
fluid_comb_setbuffer(&rev->combR[1], combtuningR2*srfactor);
fluid_comb_setbuffer(&rev->combL[2], combtuningL3*srfactor);
fluid_comb_setbuffer(&rev->combR[2], combtuningR3*srfactor);
fluid_comb_setbuffer(&rev->combL[3], combtuningL4*srfactor);
fluid_comb_setbuffer(&rev->combR[3], combtuningR4*srfactor);
fluid_comb_setbuffer(&rev->combL[4], combtuningL5*srfactor);
fluid_comb_setbuffer(&rev->combR[4], combtuningR5*srfactor);
fluid_comb_setbuffer(&rev->combL[5], combtuningL6*srfactor);
fluid_comb_setbuffer(&rev->combR[5], combtuningR6*srfactor);
fluid_comb_setbuffer(&rev->combL[6], combtuningL7*srfactor);
fluid_comb_setbuffer(&rev->combR[6], combtuningR7*srfactor);
fluid_comb_setbuffer(&rev->combL[7], combtuningL8*srfactor);
fluid_comb_setbuffer(&rev->combR[7], combtuningR8*srfactor);
fluid_allpass_setbuffer(&rev->allpassL[0], allpasstuningL1*srfactor);
fluid_allpass_setbuffer(&rev->allpassR[0], allpasstuningR1*srfactor);
fluid_allpass_setbuffer(&rev->allpassL[1], allpasstuningL2*srfactor);
fluid_allpass_setbuffer(&rev->allpassR[1], allpasstuningR2*srfactor);
fluid_allpass_setbuffer(&rev->allpassL[2], allpasstuningL3*srfactor);
fluid_allpass_setbuffer(&rev->allpassR[2], allpasstuningR3*srfactor);
fluid_allpass_setbuffer(&rev->allpassL[3], allpasstuningL4*srfactor);
fluid_allpass_setbuffer(&rev->allpassR[3], allpasstuningR4*srfactor);
fluid_revmodel_init(rev);
}
static void
fluid_revmodel_init(fluid_revmodel_t* rev)
{
int i;
if (freemverb)
{
}
else
{
for (i = 0; i < numcombs;i++) {
fluid_comb_init(&rev->combL[i]);
fluid_comb_init(&rev->combR[i]);
}
for (i = 0; i < numallpasses; i++) {
fluid_allpass_init(&rev->allpassL[i]);
fluid_allpass_init(&rev->allpassR[i]);
}
}
}
void
fluid_revmodel_reset(fluid_revmodel_t* rev)
{
fluid_revmodel_init(rev);
}
void
fluid_revmodel_f_processreplace(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
int i, k = 0;
fluid_real_t outL, outR, input;
for (k = 0; k < FLUID_BUFSIZE; k++) {
outL = outR = 0;
/* The original Freeverb code expects a stereo signal and 'input'
* is set to the sum of the left and right input sample. Since
* this code works on a mono signal, 'input' is set to twice the
* input sample. */
input = (2.0f * in[k] + DC_OFFSET) * rev->gain;
/* Accumulate comb filters in parallel */
for (i = 0; i < numcombs; i++) {
fluid_comb_process(rev->combL[i], input, outL);
fluid_comb_process(rev->combR[i], input, outR);
}
/* Feed through allpasses in series */
for (i = 0; i < numallpasses; i++) {
fluid_allpass_process(rev->allpassL[i], outL);
fluid_allpass_process(rev->allpassR[i], outR);
}
/* Remove the DC offset */
outL -= DC_OFFSET;
outR -= DC_OFFSET;
/* Calculate output REPLACING anything already there */
left_out[k] = outL * rev->wet1 + outR * rev->wet2;
right_out[k] = outR * rev->wet1 + outL * rev->wet2;
}
}
void
fluid_revmodel_processreplace(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
if (freemverb)
{
printf("1:m_r\n");
// fluid_revmodel_m_processreplace(rev, in, left_out, right_out);
// printf("2:m_r\n");
}
else
fluid_revmodel_f_processreplace(rev, in, left_out, right_out);
}
void
fluid_revmodel_f_processmix(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
int i, k = 0;
fluid_real_t outL, outR, input;
for (k = 0; k < FLUID_BUFSIZE; k++) {
outL = outR = 0;
/* The original Freeverb code expects a stereo signal and 'input'
* is set to the sum of the left and right input sample. Since
* this code works on a mono signal, 'input' is set to twice the
* input sample. */
input = (2.0f * in[k] + DC_OFFSET) * rev->gain;
/* Accumulate comb filters in parallel */
for (i = 0; i < numcombs; i++) {
fluid_comb_process(rev->combL[i], input, outL);
fluid_comb_process(rev->combR[i], input, outR);
}
/* Feed through allpasses in series */
for (i = 0; i < numallpasses; i++) {
fluid_allpass_process(rev->allpassL[i], outL);
fluid_allpass_process(rev->allpassR[i], outR);
}
/* Remove the DC offset */
outL -= DC_OFFSET;
outR -= DC_OFFSET;
/* Calculate output MIXING with anything already there */
left_out[k] += outL * rev->wet1 + outR * rev->wet2;
right_out[k] += outR * rev->wet1 + outL * rev->wet2;
}
}
void
fluid_revmodel_processmix(fluid_revmodel_t* rev, fluid_real_t *in,
fluid_real_t *left_out, fluid_real_t *right_out)
{
if (freemverb)
{
#if 1
// printf("1:m_m\n");
fluid_revmodel_m_processmix(rev, in, left_out, right_out);
// printf("2:m_m\n");
#endif
}
else
fluid_revmodel_f_processmix(rev, in, left_out, right_out);
}
static void
fluid_revmodel_update(fluid_revmodel_t* rev)
{
int i;
if (freemverb)
{
rev->late.fDCRevTime = getDCRevTime(rev->roomsize) ;
// rev->late.fPIRevTime = getPIRevTime(rev->late.fDCRevTime,
rev->damp);
UpdateRevTimeDamping(&rev->late, rev->damp);
rev->wet1 = rev->wet * (rev->width / 2.0f + 0.5f);
// UpdateStereoCoefficient(&rev->late,rev->wet1);
rev->wet2 = rev->wet * ((1.0f - rev->width) / 2.0f);
// if(rev->wet1 >0) rev->wet2 /= rev->wet1;
// printf("freemverb: roomsize=%f, damp=%f, dcRT=%f, piRT=%f\n",
// rev->roomsize, rev->damp,
// rev->late.fDCRevTime, rev->late.fPIRevTime);
// printf("freemverb: wet = %f, input gain=%f, width:%f\n", rev->wet,
rev->gain,
// rev->width );
}
else { /* freeverb */
rev->wet1 = rev->wet * (rev->width / 2.0f + 0.5f);
rev->wet2 = rev->wet * ((1.0f - rev->width) / 2.0f);
for (i = 0; i < numcombs; i++) {
fluid_comb_setfeedback(&rev->combL[i], rev->roomsize);
fluid_comb_setfeedback(&rev->combR[i], rev->roomsize);
}
for (i = 0; i < numcombs; i++) {
fluid_comb_setdamp(&rev->combL[i], rev->damp);
fluid_comb_setdamp(&rev->combR[i], rev->damp);
}
}
}
/**
* Set one or more reverb parameters.
* @param rev Reverb instance
* @param set One or more flags from #fluid_revmodel_set_t indicating what
* parameters to set (#FLUID_REVMODEL_SET_ALL to set all parameters)
* @param roomsize Reverb room size
* @param damping Reverb damping
* @param width Reverb width
* @param level Reverb level
*/
void
fluid_revmodel_set(fluid_revmodel_t* rev, int set, float roomsize,
float damping, float width, float level)
{
/*-----------------------------------*/
if (set & FLUID_REVMODEL_SET_ROOMSIZE)
if (freemverb) {
fluid_clip(roomsize, 0.0f, 1.0f);
rev->roomsize = roomsize;
}
/* freeverb */
else rev->roomsize = (roomsize * scaleroom) + offsetroom;
/*-----------------------------------*/
if (set & FLUID_REVMODEL_SET_DAMPING)
if (freemverb) {
fluid_clip(damping, 0.0f, 1.0f);
rev->damp = damping;
}
/* freeverb */
else rev->damp = damping * scaledamp;
/*-----------------------------------*/
if (set & FLUID_REVMODEL_SET_WIDTH)
{
fluid_clip(width, 0.0f, 1.0f);
rev->width = width;
}
/*-----------------------------------*/
if (set & FLUID_REVMODEL_SET_LEVEL)
{
fluid_clip(level, 0.0f, 1.0f);
rev->wet = level * scalewet;
}
/* update internal parameters */
fluid_revmodel_update (rev);
// printf("End of fluid_revmodel_set\n");
}
void
fluid_revmodel_samplerate_change(fluid_revmodel_t* rev, fluid_real_t
sample_rate)
{
int i;
if (freemverb)
{
// printf("End of fluid_revmodel_samplerate_change\n");
}
else { /* freeverb */
for (i = 0; i < numcombs;i++) {
fluid_comb_release(&rev->combL[i]);
fluid_comb_release(&rev->combR[i]);
}
for (i = 0; i < numallpasses; i++) {
fluid_allpass_release(&rev->allpassL[i]);
fluid_allpass_release(&rev->allpassR[i]);
}
fluid_set_revmodel_buffers(rev, sample_rate);
}
}
_______________________________________________
fluid-dev mailing list
fluid-dev@nongnu.org
https://lists.nongnu.org/mailman/listinfo/fluid-dev
