allpass::allpass()
{
- bufidx = 0;
+ bufidx = 0;
}
-void allpass::setbuffer(float *buf, int size)
+void allpass::setbuffer(float *buf, int size)
{
- buffer = buf;
- bufsize = size;
+ buffer = buf;
+ bufsize = size;
}
void allpass::mute()
{
- for (int i=0; i<bufsize; i++)
- buffer[i]=0;
+ for (int i=0; i<bufsize; i++)
+ buffer[i]=0;
}
-void allpass::setfeedback(float val)
+void allpass::setfeedback(float val)
{
- feedback = val;
+ feedback = val;
}
-float allpass::getfeedback()
+float allpass::getfeedback()
{
- return feedback;
+ return feedback;
}
-//ends
\ No newline at end of file
+//ends
{
public:
allpass();
- void setbuffer(float *buf, int size);
- inline float process(float inp);
- void mute();
- void setfeedback(float val);
- float getfeedback();
+ void setbuffer(float *buf, int size);
+ inline float process(float inp);
+ void mute();
+ void setfeedback(float val);
+ float getfeedback();
// private:
- float feedback;
- float *buffer;
- int bufsize;
- int bufidx;
+ float feedback;
+ float *buffer;
+ int bufsize;
+ int bufidx;
};
inline float allpass::process(float input)
{
- float output;
- float bufout;
-
- bufout = buffer[bufidx];
- undenormalise(bufout);
-
- output = -input + bufout;
- buffer[bufidx] = input + (bufout*feedback);
-
- if(++bufidx>=bufsize) bufidx = 0;
-
- return output;
+ float output;
+ float bufout;
+
+ bufout = buffer[bufidx];
+ undenormalise(bufout);
+
+ output = -input + bufout;
+ buffer[bufidx] = input + (bufout*feedback);
+
+ if(++bufidx>=bufsize) bufidx = 0;
+
+ return output;
}
#endif//_allpass
comb::comb()
{
- filterstore = 0;
- bufidx = 0;
+ filterstore = 0;
+ bufidx = 0;
}
-void comb::setbuffer(float *buf, int size)
+void comb::setbuffer(float *buf, int size)
{
- buffer = buf;
- bufsize = size;
+ buffer = buf;
+ bufsize = size;
}
void comb::mute()
{
- for (int i=0; i<bufsize; i++)
- buffer[i]=0;
+ for (int i=0; i<bufsize; i++)
+ buffer[i]=0;
}
-void comb::setdamp(float val)
+void comb::setdamp(float val)
{
- damp1 = val;
- damp2 = 1-val;
+ damp1 = val;
+ damp2 = 1-val;
}
-float comb::getdamp()
+float comb::getdamp()
{
- return damp1;
+ return damp1;
}
-void comb::setfeedback(float val)
+void comb::setfeedback(float val)
{
- feedback = val;
+ feedback = val;
}
-float comb::getfeedback()
+float comb::getfeedback()
{
- return feedback;
+ return feedback;
}
// ends
class comb
{
public:
- comb();
- void setbuffer(float *buf, int size);
- inline float process(float inp);
- void mute();
- void setdamp(float val);
- float getdamp();
- void setfeedback(float val);
- float getfeedback();
+ comb();
+ void setbuffer(float *buf, int size);
+ inline float process(float inp);
+ void mute();
+ void setdamp(float val);
+ float getdamp();
+ void setfeedback(float val);
+ float getfeedback();
private:
- float feedback;
- float filterstore;
- float damp1;
- float damp2;
- float *buffer;
- int bufsize;
- int bufidx;
+ float feedback;
+ float filterstore;
+ float damp1;
+ float damp2;
+ float *buffer;
+ int bufsize;
+ int bufidx;
};
inline float comb::process(float input)
{
- float output;
+ float output;
- output = buffer[bufidx];
- undenormalise(output);
+ output = buffer[bufidx];
+ undenormalise(output);
- filterstore = (output*damp2) + (filterstore*damp1);
- undenormalise(filterstore);
+ filterstore = (output*damp2) + (filterstore*damp1);
+ undenormalise(filterstore);
- buffer[bufidx] = input + (filterstore*feedback);
+ buffer[bufidx] = input + (filterstore*feedback);
- if(++bufidx>=bufsize) bufidx = 0;
+ if(++bufidx>=bufsize) bufidx = 0;
- return output;
+ return output;
}
#endif //_comb_
// Reverb model implementation
-//
-//
+//
+//
// Google Summer of Code 2007
-//
-// Authors: Biodun Osunkunle <biodun@videolan.org>
-//
+//
+// Authors: Biodun Osunkunle <biodun@videolan.org>
+//
// Mentor : Jean-Baptiste Kempf <jb@videolan.org>
//
// Original written by Jezar at Dreampoint, June 2000
revmodel::revmodel()
{
- // Tie the components to their buffers
- combL[0].setbuffer(bufcombL1,combtuningL1);
- combR[0].setbuffer(bufcombR1,combtuningR1);
- combL[1].setbuffer(bufcombL2,combtuningL2);
- combR[1].setbuffer(bufcombR2,combtuningR2);
- combL[2].setbuffer(bufcombL3,combtuningL3);
- combR[2].setbuffer(bufcombR3,combtuningR3);
- combL[3].setbuffer(bufcombL4,combtuningL4);
- combR[3].setbuffer(bufcombR4,combtuningR4);
- combL[4].setbuffer(bufcombL5,combtuningL5);
- combR[4].setbuffer(bufcombR5,combtuningR5);
- combL[5].setbuffer(bufcombL6,combtuningL6);
- combR[5].setbuffer(bufcombR6,combtuningR6);
- combL[6].setbuffer(bufcombL7,combtuningL7);
- combR[6].setbuffer(bufcombR7,combtuningR7);
- combL[7].setbuffer(bufcombL8,combtuningL8);
- combR[7].setbuffer(bufcombR8,combtuningR8);
- allpassL[0].setbuffer(bufallpassL1,allpasstuningL1);
- allpassR[0].setbuffer(bufallpassR1,allpasstuningR1);
- allpassL[1].setbuffer(bufallpassL2,allpasstuningL2);
- allpassR[1].setbuffer(bufallpassR2,allpasstuningR2);
- allpassL[2].setbuffer(bufallpassL3,allpasstuningL3);
- allpassR[2].setbuffer(bufallpassR3,allpasstuningR3);
- allpassL[3].setbuffer(bufallpassL4,allpasstuningL4);
- allpassR[3].setbuffer(bufallpassR4,allpasstuningR4);
-
- // Set default values
- allpassL[0].setfeedback(0.5f);
- allpassR[0].setfeedback(0.5f);
- allpassL[1].setfeedback(0.5f);
- allpassR[1].setfeedback(0.5f);
- allpassL[2].setfeedback(0.5f);
- allpassR[2].setfeedback(0.5f);
- allpassL[3].setfeedback(0.5f);
- allpassR[3].setfeedback(0.5f);
- setwet(initialwet);
- setroomsize(initialroom);
- setdry(initialdry);
- setdamp(initialdamp);
- setwidth(initialwidth);
- setmode(initialmode);
-
- // Buffer will be full of rubbish - so we MUST mute them
- mute();
+ // Tie the components to their buffers
+ combL[0].setbuffer(bufcombL1,combtuningL1);
+ combR[0].setbuffer(bufcombR1,combtuningR1);
+ combL[1].setbuffer(bufcombL2,combtuningL2);
+ combR[1].setbuffer(bufcombR2,combtuningR2);
+ combL[2].setbuffer(bufcombL3,combtuningL3);
+ combR[2].setbuffer(bufcombR3,combtuningR3);
+ combL[3].setbuffer(bufcombL4,combtuningL4);
+ combR[3].setbuffer(bufcombR4,combtuningR4);
+ combL[4].setbuffer(bufcombL5,combtuningL5);
+ combR[4].setbuffer(bufcombR5,combtuningR5);
+ combL[5].setbuffer(bufcombL6,combtuningL6);
+ combR[5].setbuffer(bufcombR6,combtuningR6);
+ combL[6].setbuffer(bufcombL7,combtuningL7);
+ combR[6].setbuffer(bufcombR7,combtuningR7);
+ combL[7].setbuffer(bufcombL8,combtuningL8);
+ combR[7].setbuffer(bufcombR8,combtuningR8);
+ allpassL[0].setbuffer(bufallpassL1,allpasstuningL1);
+ allpassR[0].setbuffer(bufallpassR1,allpasstuningR1);
+ allpassL[1].setbuffer(bufallpassL2,allpasstuningL2);
+ allpassR[1].setbuffer(bufallpassR2,allpasstuningR2);
+ allpassL[2].setbuffer(bufallpassL3,allpasstuningL3);
+ allpassR[2].setbuffer(bufallpassR3,allpasstuningR3);
+ allpassL[3].setbuffer(bufallpassL4,allpasstuningL4);
+ allpassR[3].setbuffer(bufallpassR4,allpasstuningR4);
+
+ // Set default values
+ allpassL[0].setfeedback(0.5f);
+ allpassR[0].setfeedback(0.5f);
+ allpassL[1].setfeedback(0.5f);
+ allpassR[1].setfeedback(0.5f);
+ allpassL[2].setfeedback(0.5f);
+ allpassR[2].setfeedback(0.5f);
+ allpassL[3].setfeedback(0.5f);
+ allpassR[3].setfeedback(0.5f);
+ setwet(initialwet);
+ setroomsize(initialroom);
+ setdry(initialdry);
+ setdamp(initialdamp);
+ setwidth(initialwidth);
+ setmode(initialmode);
+
+ // Buffer will be full of rubbish - so we MUST mute them
+ mute();
}
void revmodel::mute()
{
- int i;
- if (getmode() >= freezemode)
- return;
-
- for (i = 0 ; i < numcombs ; i++)
- {
- combL[i].mute();
- combR[i].mute();
- }
- for (i=0;i<numallpasses;i++)
- {
- allpassL[i].mute();
- allpassR[i].mute();
- }
+ int i;
+ if (getmode() >= freezemode)
+ return;
+
+ for (i = 0 ; i < numcombs ; i++)
+ {
+ combL[i].mute();
+ combR[i].mute();
+ }
+ for (i=0;i<numallpasses;i++)
+ {
+ allpassL[i].mute();
+ allpassR[i].mute();
+ }
}
void revmodel::processreplace(float *inputL, float *outputL, long numsamples, int skip)
{
- float outL,outR,input;
- float inputR;
- int i;
+ float outL,outR,input;
+ float inputR;
+ int i;
- outL = outR = 0;
- if (skip > 1)
+ outL = outR = 0;
+ if (skip > 1)
inputR = inputL[1];
- else
- inputR = inputL[0];
- input = (inputL[0] + inputR) * gain;
-
- // Accumulate comb filters in parallel
- for(i=0; i<numcombs; i++)
- {
- outL += combL[i].process(input);
- outR += combR[i].process(input);
- }
-
- // Feed through allpasses in series
- for(i=0; i<numallpasses; i++)
- {
- outL = allpassL[i].process(outL);
- outR = allpassR[i].process(outR);
- }
-
- // Calculate output REPLACING anything already there
- outputL[0] = (outL*wet1 + outR*wet2 + inputR*dry);
+ else
+ inputR = inputL[0];
+ input = (inputL[0] + inputR) * gain;
+
+ // Accumulate comb filters in parallel
+ for(i=0; i<numcombs; i++)
+ {
+ outL += combL[i].process(input);
+ outR += combR[i].process(input);
+ }
+
+ // Feed through allpasses in series
+ for(i=0; i<numallpasses; i++)
+ {
+ outL = allpassL[i].process(outL);
+ outR = allpassR[i].process(outR);
+ }
+
+ // Calculate output REPLACING anything already there
+ outputL[0] = (outL*wet1 + outR*wet2 + inputR*dry);
if (skip > 1)
- outputL[1] = (outR*wet1 + outL*wet2 + inputR*dry);
+ outputL[1] = (outR*wet1 + outL*wet2 + inputR*dry);
}
void revmodel::processmix(float *inputL, float *outputL, long numsamples, int skip)
{
- float outL,outR,input;
- float inputR;
- int i;
+ float outL,outR,input;
+ float inputR;
+ int i;
- outL = outR = 0;
- if (skip > 1)
+ outL = outR = 0;
+ if (skip > 1)
inputR = inputL[1];
- else
- inputR = inputL[0];
- input = (inputL[0] + inputR) * gain;
-
- // Accumulate comb filters in parallel
- for(i=0; i<numcombs; i++)
- {
- outL += combL[i].process(input);
- outR += combR[i].process(input);
- }
-
- // Feed through allpasses in series
- for(i=0; i<numallpasses; i++)
- {
- outL = allpassL[i].process(outL);
- outR = allpassR[i].process(outR);
- }
-
- // Calculate output REPLACING anything already there
- outputL[0] += (outL*wet1 + outR*wet2 + inputR*dry);
+ else
+ inputR = inputL[0];
+ input = (inputL[0] + inputR) * gain;
+
+ // Accumulate comb filters in parallel
+ for(i=0; i<numcombs; i++)
+ {
+ outL += combL[i].process(input);
+ outR += combR[i].process(input);
+ }
+
+ // Feed through allpasses in series
+ for(i=0; i<numallpasses; i++)
+ {
+ outL = allpassL[i].process(outL);
+ outR = allpassR[i].process(outR);
+ }
+
+ // Calculate output REPLACING anything already there
+ outputL[0] += (outL*wet1 + outR*wet2 + inputR*dry);
if (skip > 1)
- outputL[1] += (outR*wet1 + outL*wet2 + inputR*dry);
+ outputL[1] += (outR*wet1 + outL*wet2 + inputR*dry);
}
void revmodel::update()
{
// Recalculate internal values after parameter change
- int i;
-
- wet1 = wet*(width/2 + 0.5f);
- wet2 = wet*((1-width)/2);
-
- if (mode >= freezemode)
- {
- roomsize1 = 1;
- damp1 = 0;
- gain = muted;
- }
- else
- {
- roomsize1 = roomsize;
- damp1 = damp;
- gain = fixedgain;
- }
-
- for(i=0; i<numcombs; i++)
- {
- combL[i].setfeedback(roomsize1);
- combR[i].setfeedback(roomsize1);
- }
-
- for(i=0; i<numcombs; i++)
- {
- combL[i].setdamp(damp1);
- combR[i].setdamp(damp1);
- }
+ int i;
+
+ wet1 = wet*(width/2 + 0.5f);
+ wet2 = wet*((1-width)/2);
+
+ if (mode >= freezemode)
+ {
+ roomsize1 = 1;
+ damp1 = 0;
+ gain = muted;
+ }
+ else
+ {
+ roomsize1 = roomsize;
+ damp1 = damp;
+ gain = fixedgain;
+ }
+
+ for(i=0; i<numcombs; i++)
+ {
+ combL[i].setfeedback(roomsize1);
+ combR[i].setfeedback(roomsize1);
+ }
+
+ for(i=0; i<numcombs; i++)
+ {
+ combL[i].setdamp(damp1);
+ combR[i].setdamp(damp1);
+ }
}
// The following get/set functions are not inlined, because
void revmodel::setroomsize(float value)
{
- roomsize = (value*scaleroom) + offsetroom;
- update();
+ roomsize = (value*scaleroom) + offsetroom;
+ update();
}
float revmodel::getroomsize()
{
- return (roomsize-offsetroom)/scaleroom;
+ return (roomsize-offsetroom)/scaleroom;
}
void revmodel::setdamp(float value)
{
- damp = value*scaledamp;
- update();
+ damp = value*scaledamp;
+ update();
}
float revmodel::getdamp()
{
- return damp/scaledamp;
+ return damp/scaledamp;
}
void revmodel::setwet(float value)
{
- wet = value*scalewet;
- update();
+ wet = value*scalewet;
+ update();
}
float revmodel::getwet()
{
- return wet/scalewet;
+ return wet/scalewet;
}
void revmodel::setdry(float value)
{
- dry = value*scaledry;
+ dry = value*scaledry;
}
float revmodel::getdry()
{
- return dry/scaledry;
+ return dry/scaledry;
}
void revmodel::setwidth(float value)
{
- width = value;
- update();
+ width = value;
+ update();
}
float revmodel::getwidth()
{
- return width;
+ return width;
}
void revmodel::setmode(float value)
{
- mode = value;
- update();
+ mode = value;
+ update();
}
float revmodel::getmode()
{
- if (mode >= freezemode)
- return 1;
- else
- return 0;
+ if (mode >= freezemode)
+ return 1;
+ else
+ return 0;
}
//ends
// Reverb model declaration
//
// Google Summer of Code 2007
-//
-// Authors: Biodun Osunkunle <biodun@videolan.org>
-//
+//
+// Authors: Biodun Osunkunle <biodun@videolan.org>
+//
// Mentor : Jean-Baptiste Kempf <jb@videolan.org>
//
// Original written by Jezar at Dreampoint, June 2000
class revmodel
{
public:
- revmodel();
- void mute();
- void processreplace(float *inputL, float *outputL, long numsamples, int skip);
- void processmix(float *inputL, float *outputL, long numsamples, int skip);
- void setroomsize(float value);
- float getroomsize();
- void setdamp(float value);
- float getdamp();
- void setwet(float value);
- float getwet();
- void setdry(float value);
- float getdry();
- void setwidth(float value);
- float getwidth();
- void setmode(float value);
- float getmode();
+ revmodel();
+ void mute();
+ void processreplace(float *inputL, float *outputL, long numsamples, int skip);
+ void processmix(float *inputL, float *outputL, long numsamples, int skip);
+ void setroomsize(float value);
+ float getroomsize();
+ void setdamp(float value);
+ float getdamp();
+ void setwet(float value);
+ float getwet();
+ void setdry(float value);
+ float getdry();
+ void setwidth(float value);
+ float getwidth();
+ void setmode(float value);
+ float getmode();
private:
- void update();
+ void update();
private:
- float gain;
- float roomsize,roomsize1;
- float damp,damp1;
- float wet,wet1,wet2;
- float dry;
- float width;
- float mode;
+ float gain;
+ float roomsize,roomsize1;
+ float damp,damp1;
+ float wet,wet1,wet2;
+ float dry;
+ float width;
+ float mode;
-// The following are all declared inline
+// The following are all declared inline
// to remove the need for dynamic allocation
// with its subsequent error-checking messiness
// Comb filters
- comb combL[numcombs];
- comb combR[numcombs];
+ comb combL[numcombs];
+ comb combR[numcombs];
- // Allpass filters
- allpass allpassL[numallpasses];
- allpass allpassR[numallpasses];
+ // Allpass filters
+ allpass allpassL[numallpasses];
+ allpass allpassR[numallpasses];
- // Buffers for the combs
- float bufcombL1[combtuningL1];
- float bufcombR1[combtuningR1];
- float bufcombL2[combtuningL2];
- float bufcombR2[combtuningR2];
- float bufcombL3[combtuningL3];
- float bufcombR3[combtuningR3];
- float bufcombL4[combtuningL4];
- float bufcombR4[combtuningR4];
- float bufcombL5[combtuningL5];
- float bufcombR5[combtuningR5];
- float bufcombL6[combtuningL6];
- float bufcombR6[combtuningR6];
- float bufcombL7[combtuningL7];
- float bufcombR7[combtuningR7];
- float bufcombL8[combtuningL8];
- float bufcombR8[combtuningR8];
+ // Buffers for the combs
+ float bufcombL1[combtuningL1];
+ float bufcombR1[combtuningR1];
+ float bufcombL2[combtuningL2];
+ float bufcombR2[combtuningR2];
+ float bufcombL3[combtuningL3];
+ float bufcombR3[combtuningR3];
+ float bufcombL4[combtuningL4];
+ float bufcombR4[combtuningR4];
+ float bufcombL5[combtuningL5];
+ float bufcombR5[combtuningR5];
+ float bufcombL6[combtuningL6];
+ float bufcombR6[combtuningR6];
+ float bufcombL7[combtuningL7];
+ float bufcombR7[combtuningR7];
+ float bufcombL8[combtuningL8];
+ float bufcombR8[combtuningR8];
- // Buffers for the allpasses
- float bufallpassL1[allpasstuningL1];
- float bufallpassR1[allpasstuningR1];
- float bufallpassL2[allpasstuningL2];
- float bufallpassR2[allpasstuningR2];
- float bufallpassL3[allpasstuningL3];
- float bufallpassR3[allpasstuningR3];
- float bufallpassL4[allpasstuningL4];
- float bufallpassR4[allpasstuningR4];
+ // Buffers for the allpasses
+ float bufallpassL1[allpasstuningL1];
+ float bufallpassR1[allpasstuningR1];
+ float bufallpassL2[allpasstuningL2];
+ float bufallpassR2[allpasstuningR2];
+ float bufallpassL3[allpasstuningL3];
+ float bufallpassR3[allpasstuningR3];
+ float bufallpassL4[allpasstuningL4];
+ float bufallpassR4[allpasstuningR4];
};
#endif//_revmodel_
* spatializer.cpp:
*****************************************************************************
* Copyright (C) 2004, 2006, 2007 the VideoLAN team
- *
+ *
* Google Summer of Code 2007
- *
- * Authors: Biodun Osunkunle <biodun@videolan.org>
- *
+ *
+ * Authors: Biodun Osunkunle <biodun@videolan.org>
+ *
* Mentor : Jean-Baptiste Kempf <jb@videolan.org>
*
* This program is free software; you can redistribute it and/or modify
{
/* reverb static config */
vlc_bool_t b_first;
-
+
} aout_filter_sys_t;
static revmodel reverbm;
-
+
static const char *psz_control_names[] =
{
"Roomsize", "Width" , "Wet", "Dry", "Damp"
static int DampCallback ( vlc_object_t *, char const *,
vlc_value_t, vlc_value_t, void * );
static int WidthCallback ( vlc_object_t *, char const *,
- vlc_value_t, vlc_value_t, void * );
+ vlc_value_t, vlc_value_t, void * );
+
/*****************************************************************************
* Open:
*****************************************************************************/
p_filter->pf_do_work = DoWork;
p_filter->b_in_place = VLC_TRUE;
-
- /* Allocate structure */
+
+ /* Allocate structure */
p_sys = p_filter->p_sys = (aout_filter_sys_t*)malloc( sizeof( aout_filter_sys_t ) );
reverbm.setroomsize(1.05);
reverbm.setwet(10.0f);
reverbm.setdamp(0.3);
reverbm.setwidth(0.9);
SpatInit( p_filter);
-
+
return VLC_SUCCESS;
}
/*****************************************************************************
* Close: close the plugin
*****************************************************************************/
-static void Close( vlc_object_t *p_this )
+static void Close( vlc_object_t *p_this )
{
aout_filter_t *p_filter = (aout_filter_t *)p_this;
aout_filter_sys_t *p_sys = p_filter->p_sys;
int i, ch;
vlc_value_t val1, val2, val3, val4, val5;
aout_instance_t *p_aout = (aout_instance_t *)p_filter->p_parent;
-
+
for( int i = 0; i < 5 ; i ++ )
{
var_CreateGetFloatCommand( p_aout, psz_control_names[i] );
var_AddCallback( p_aout, psz_control_names[2], WetCallback, p_sys );
var_AddCallback( p_aout, psz_control_names[3], DryCallback, p_sys );
var_AddCallback( p_aout, psz_control_names[4], DampCallback, p_sys );
-
+
return VLC_SUCCESS;
}
{
in[ch] = in[ch] * SPAT_AMP;
}
- reverbm.processreplace( in, out , 1, i_channels);
+ reverbm.processreplace( in, out , 1, i_channels);
in += i_channels;
out += i_channels;
}
static int RoomCallback( vlc_object_t *p_this, char const *psz_cmd,
vlc_value_t oldval, vlc_value_t newval, void *p_data )
{
- msg_Dbg (p_this,"room callback %3.1f %s %s %d\n", newval.f_float, __FILE__,__func__,__LINE__);
+ msg_Dbg (p_this,"room callback %3.1f %s %s %d\n", newval.f_float, __FILE__,__func__,__LINE__);
reverbm.setroomsize(newval.f_float);
return VLC_SUCCESS;
}
#ifndef _tuning_
#define _tuning_
-const int numcombs = 8;
-const int numallpasses = 4;
-const float muted = 0;
-const float fixedgain = 0.005f;
-const float scalewet = 3;
-const float scaledry = 2;
-const float scaledamp = 0.4f;
-const float scaleroom = 0.28f;
-const float offsetroom = 0.7f;
-const float initialroom = 0.5f;
-const float initialdamp = 0.5f;
-const float initialwet = 1/scalewet;
-const float initialdry = 0;
-const float initialwidth = 1;
-const float initialmode = 0;
-const float freezemode = 0.5f;
-const int stereospread = 23;
+const int numcombs = 8;
+const int numallpasses = 4;
+const float muted = 0;
+const float fixedgain = 0.005f;
+const float scalewet = 3;
+const float scaledry = 2;
+const float scaledamp = 0.4f;
+const float scaleroom = 0.28f;
+const float offsetroom = 0.7f;
+const float initialroom = 0.5f;
+const float initialdamp = 0.5f;
+const float initialwet = 1/scalewet;
+const float initialdry = 0;
+const float initialwidth = 1;
+const float initialmode = 0;
+const float freezemode = 0.5f;
+const int 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.
-const int combtuningL1 = 1116;
-const int combtuningR1 = 1116+stereospread;
-const int combtuningL2 = 1188;
-const int combtuningR2 = 1188+stereospread;
-const int combtuningL3 = 1277;
-const int combtuningR3 = 1277+stereospread;
-const int combtuningL4 = 1356;
-const int combtuningR4 = 1356+stereospread;
-const int combtuningL5 = 1422;
-const int combtuningR5 = 1422+stereospread;
-const int combtuningL6 = 1491;
-const int combtuningR6 = 1491+stereospread;
-const int combtuningL7 = 1557;
-const int combtuningR7 = 1557+stereospread;
-const int combtuningL8 = 1617;
-const int combtuningR8 = 1617+stereospread;
-const int allpasstuningL1 = 556;
-const int allpasstuningR1 = 556+stereospread;
-const int allpasstuningL2 = 441;
-const int allpasstuningR2 = 441+stereospread;
-const int allpasstuningL3 = 341;
-const int allpasstuningR3 = 341+stereospread;
-const int allpasstuningL4 = 225;
-const int allpasstuningR4 = 225+stereospread;
+const int combtuningL1 = 1116;
+const int combtuningR1 = 1116+stereospread;
+const int combtuningL2 = 1188;
+const int combtuningR2 = 1188+stereospread;
+const int combtuningL3 = 1277;
+const int combtuningR3 = 1277+stereospread;
+const int combtuningL4 = 1356;
+const int combtuningR4 = 1356+stereospread;
+const int combtuningL5 = 1422;
+const int combtuningR5 = 1422+stereospread;
+const int combtuningL6 = 1491;
+const int combtuningR6 = 1491+stereospread;
+const int combtuningL7 = 1557;
+const int combtuningR7 = 1557+stereospread;
+const int combtuningL8 = 1617;
+const int combtuningR8 = 1617+stereospread;
+const int allpasstuningL1 = 556;
+const int allpasstuningR1 = 556+stereospread;
+const int allpasstuningL2 = 441;
+const int allpasstuningR2 = 441+stereospread;
+const int allpasstuningL3 = 341;
+const int allpasstuningR3 = 341+stereospread;
+const int allpasstuningL4 = 225;
+const int allpasstuningR4 = 225+stereospread;
#endif//_tuning_
projects / vlc / commitdiff