Spatializer: spaces and tab!!!

modules/audio_filter/spatializer/allpass.cpp

@@ -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
+//ends
\ No newline at end of file

modules/audio_filter/spatializer/allpass.hpp

@@ -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

modules/audio_filter/spatializer/comb.cpp

@@ -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

modules/audio_filter/spatializer/comb.hpp

@@ -12,22 +12,22 @@
 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_

modules/audio_filter/spatializer/revmodel.cpp

 // 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
@@ -16,169 +16,169 @@
 
 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

modules/audio_filter/spatializer/revmodel.hpp

 // 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
@@ -18,72 +18,72 @@
 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_

modules/audio_filter/spatializer/spatializer.cpp

@@ -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;
 }

modules/audio_filter/spatializer/tuning.h

@@ -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_