From 797149c5a9ee0c7c70947f72cbaece5efd3dd687 Mon Sep 17 00:00:00 2001
From: Ludovic Pouzenc <ludovic@pouzenc.fr>
Date: Sat, 16 Jun 2012 22:29:33 +0000
Subject: Création du source tree princpal. Les routines de maths pour calculer
 le gain déconnent encore je trouve. Reste à intégrer la partie DMX et a
 améliorer tout ce qui a été laissé de côté...
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

git-svn-id: file:///var/svn/2012-violon-leds/trunk@20 6be1fa4d-33ac-4c33-becc-79fcb3794bb6
---
 src/fft.c | 241 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 241 insertions(+)
 create mode 100644 src/fft.c

(limited to 'src/fft.c')

diff --git a/src/fft.c b/src/fft.c
new file mode 100644
index 0000000..dd91d14
--- /dev/null
+++ b/src/fft.c
@@ -0,0 +1,241 @@
+#include "fft.h"
+#include <math.h>
+#include <stdlib.h>
+
+/* Everything here comes from Audacity 1.3.13
+ (orignally in C++ and with more genericity and functionnality)
+ Original Author : Dominic Mazzoni
+ Licenced under GPL 2.0 (see LICENCE)
+*/
+
+#define MaxFastBits 16
+
+int *gFFTBitTable[MaxFastBits]={NULL};
+
+void InitFFT();
+int NumberOfBitsNeeded(int PowerOfTwo);
+inline int FastReverseBits(int i, int NumBits);
+int ReverseBits(int index, int NumBits);
+
+
+void FFT(int NumSamples,
+		int InverseTransform,
+		float *RealIn, float *ImagIn, float *RealOut, float *ImagOut)
+{
+	int NumBits;                 /* Number of bits needed to store indices */
+	int i, j, k, n;
+	int BlockSize, BlockEnd;
+
+	double angle_numerator = 2.0 * M_PI;
+	double tr, ti;                /* temp real, temp imaginary */
+/*
+	if (!IsPowerOfTwo(NumSamples)) {
+		fprintf(stderr, "%d is not a power of two\n", NumSamples);
+		exit(1);
+	}
+*/
+	if (!gFFTBitTable[0])
+		InitFFT();
+
+	if (!InverseTransform)
+		angle_numerator = -angle_numerator;
+
+	NumBits = NumberOfBitsNeeded(NumSamples);
+
+	/*
+	 **   Do simultaneous data copy and bit-reversal ordering into outputs...
+	 */
+	for (i = 0; i < NumSamples; i++) {
+		j = FastReverseBits(i, NumBits);
+		RealOut[j] = RealIn[i];
+		ImagOut[j] = (ImagIn == NULL) ? 0.0 : ImagIn[i];
+	}
+
+	/*
+	 **   Do the FFT itself...
+	 */
+
+	BlockEnd = 1;
+	for (BlockSize = 2; BlockSize <= NumSamples; BlockSize <<= 1) {
+
+		double delta_angle = angle_numerator / (double) BlockSize;
+
+		double sm2 = sin(-2 * delta_angle);
+		double sm1 = sin(-delta_angle);
+		double cm2 = cos(-2 * delta_angle);
+		double cm1 = cos(-delta_angle);
+		double w = 2 * cm1;
+		double ar0, ar1, ar2, ai0, ai1, ai2;
+
+		for (i = 0; i < NumSamples; i += BlockSize) {
+			ar2 = cm2;
+			ar1 = cm1;
+
+			ai2 = sm2;
+			ai1 = sm1;
+
+			for (j = i, n = 0; n < BlockEnd; j++, n++) {
+				ar0 = w * ar1 - ar2;
+				ar2 = ar1;
+				ar1 = ar0;
+
+				ai0 = w * ai1 - ai2;
+				ai2 = ai1;
+				ai1 = ai0;
+
+				k = j + BlockEnd;
+				tr = ar0 * RealOut[k] - ai0 * ImagOut[k];
+				ti = ar0 * ImagOut[k] + ai0 * RealOut[k];
+
+				RealOut[k] = RealOut[j] - tr;
+				ImagOut[k] = ImagOut[j] - ti;
+
+				RealOut[j] += tr;
+				ImagOut[j] += ti;
+			}
+		}
+		BlockEnd = BlockSize;
+	}
+
+	/*
+	 **   Need to normalize if inverse transform...
+	 */
+
+	if (InverseTransform) {
+		float denom = (float) NumSamples;
+
+		for (i = 0; i < NumSamples; i++) {
+			RealOut[i] /= denom;
+			ImagOut[i] /= denom;
+		}
+	}
+}
+
+void InitFFT() {
+	int len=2;
+	int b, i;
+	for (b=0; b<MaxFastBits; b++) {
+		gFFTBitTable[b]=malloc(len*sizeof(int));
+
+		for (i=0; i<len; i++)
+			gFFTBitTable[b][i] = ReverseBits(i, b+1);
+
+		len <<= 1;
+	}
+}
+
+int NumberOfBitsNeeded(int PowerOfTwo)
+{
+	int i;
+
+/*
+	if (PowerOfTwo < 2) {
+		fprintf(stderr, "Error: FFT called with size %d\n", PowerOfTwo);
+		exit(1);
+	}
+*/
+	for (i = 0;; i++)
+		if (PowerOfTwo & (1 << i))
+			return i;
+}
+
+inline int FastReverseBits(int i, int NumBits)
+{
+	if (NumBits <= MaxFastBits)
+		return gFFTBitTable[NumBits - 1][i];
+	else
+		return ReverseBits(i, NumBits);
+}
+
+int ReverseBits(int index, int NumBits)
+{
+   int i, rev;
+
+   for (i = rev = 0; i < NumBits; i++) {
+      rev = (rev << 1) | (index & 1);
+      index >>= 1;
+   }
+
+   return rev;
+}
+
+
+/*
+ * PowerSpectrum
+ *
+ * This function computes the same as RealFFT, above, but
+ * adds the squares of the real and imaginary part of each
+ * coefficient, extracting the power and throwing away the
+ * phase.
+ *
+ * For speed, it does not call RealFFT, but duplicates some
+ * of its code.
+ */
+
+void PowerSpectrum(float In[PSNumS], float Out[PSHalf]) {
+	int i;
+
+	float theta = M_PI / PSHalf;
+
+	float tmpReal[PSHalf];
+	float tmpImag[PSHalf];
+	float RealOut[PSHalf];
+	float ImagOut[PSHalf];
+
+	for (i=0; i<PSHalf; i++) {
+		tmpReal[i] = In[2*i];
+		tmpImag[i] = In[2*i+1];
+	}
+
+	FFT(PSHalf, 0, tmpReal, tmpImag, RealOut, ImagOut);
+
+	float wtemp = sin(0.5 * theta);
+
+	float wpr = -2.0 * wtemp * wtemp;
+	float wpi = -1.0 * sin(theta);
+	float wr = 1.0 + wpr;
+	float wi = wpi;
+
+	int i3;
+
+	float h1r, h1i, h2r, h2i, rt, it;
+	for (i=1; i < PSHalf/2; i++) {
+
+		i3 = PSHalf - i;
+
+		h1r = 0.5 * (RealOut[i] + RealOut[i3]);
+		h1i = 0.5 * (ImagOut[i] - ImagOut[i3]);
+		h2r = 0.5 * (ImagOut[i] + ImagOut[i3]);
+		h2i = -0.5 * (RealOut[i] - RealOut[i3]);
+
+		rt = h1r + wr * h2r - wi * h2i;
+		it = h1i + wr * h2i + wi * h2r;
+
+		Out[i] = rt * rt + it * it;
+
+		rt = h1r - wr * h2r + wi * h2i;
+		it = -h1i + wr * h2i + wi * h2r;
+
+		Out[i3] = rt * rt + it * it;
+
+		wr = (wtemp = wr) * wpr - wi * wpi + wr;
+		wi = wi * wpr + wtemp * wpi + wi;
+	}
+
+	rt = (h1r = RealOut[0]) + ImagOut[0];
+	it = h1r - ImagOut[0];
+	Out[0] = rt * rt + it * it;
+	rt = RealOut[PSHalf / 2];
+	it = ImagOut[PSHalf / 2];
+	Out[PSHalf / 2] = rt * rt + it * it;
+}
+
+void DeinitFFT() {
+	int i;
+	if (gFFTBitTable[0]) {
+		for (i=0;i<MaxFastBits;i++) {
+			free(gFFTBitTable[i]);
+		}
+	}
+}
+
-- 
cgit v1.2.3