Spatializer: spaces and tab!!!
authorJean-Baptiste Kempf <jb@videolan.org>
Sat, 1 Sep 2007 11:37:15 +0000 (11:37 +0000)
committerJean-Baptiste Kempf <jb@videolan.org>
Sat, 1 Sep 2007 11:37:15 +0000 (11:37 +0000)
modules/audio_filter/spatializer/allpass.cpp
modules/audio_filter/spatializer/allpass.hpp
modules/audio_filter/spatializer/comb.cpp
modules/audio_filter/spatializer/comb.hpp
modules/audio_filter/spatializer/revmodel.cpp
modules/audio_filter/spatializer/revmodel.hpp
modules/audio_filter/spatializer/spatializer.cpp
modules/audio_filter/spatializer/tuning.h

index 5d80eda..072ea72 100644 (file)
@@ -8,29 +8,29 @@
 
 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
index ed2df99..f907667 100644 (file)
@@ -12,16 +12,16 @@ class allpass
 {
 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;
 };
 
 
@@ -29,18 +29,18 @@ public:
 
 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
index c05f506..a06fe47 100644 (file)
@@ -8,41 +8,41 @@
 
 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
index 94f6d40..2da83db 100644 (file)
 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;
 };
 
 
@@ -35,19 +35,19 @@ private:
 
 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_
index 059c374..02bf698 100644 (file)
@@ -1,10 +1,10 @@
 // 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
@@ -188,70 +188,70 @@ void revmodel::update()
 
 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
index cd4efda..b00a2dd 100644 (file)
@@ -1,9 +1,9 @@
 // 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_
index 20f0473..f424394 100644 (file)
@@ -2,11 +2,11 @@
  * 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
@@ -63,11 +63,11 @@ typedef struct aout_filter_sys_t
 {
     /* 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"
@@ -88,7 +88,8 @@ static int DryCallback ( vlc_object_t *, char const *,
 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:
  *****************************************************************************/
@@ -122,8 +123,8 @@ static int Open( vlc_object_t *p_this )
 
     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);
@@ -131,14 +132,14 @@ static int Open( vlc_object_t *p_this )
     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;
@@ -169,7 +170,7 @@ static int SpatInit( aout_filter_t *p_filter )
     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] );
@@ -195,7 +196,7 @@ static int SpatInit( aout_filter_t *p_filter )
     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;
 }
 
@@ -210,7 +211,7 @@ static void SpatFilter( aout_instance_t *p_aout,
         {
             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;
     }
@@ -236,7 +237,7 @@ static void SpatClean( aout_filter_t *p_filter )
 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;
 }
index 9c4e6ca..f18ad3d 100644 (file)
@@ -7,52 +7,52 @@
 #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_