modifications

rsimonin
1 parent 6c227d28
Showing 48 changed files with 1606 additions and 148 deletions Show diff stats
com.WAV
cowfft.WAV
COW.WAV -> fft/COW.WAV
fft/cowfft.WAV
fft.cpp -> fft/fft.cpp
fft.h -> fft/fft.h
fftcow.cpp -> fft/fftcow.cpp
fft/fftla.WAV
fft/fftla.cpp
fft/test
wavdata.cpp -> fft/wavdata.cpp
wavdata.h -> fft/wavdata.h
main/COW.WAV
COW_d.WAV -> main/COW_d.WAV
main/fft.cpp
main/fft.h
main.cpp -> main/main.cpp
main/wavdata.cpp
main/wavdata.h
modifreq.WAV
@@ -13,35 +13,38 @@
  
 int main(int argc, char **argv)
 {
+//Definition variables
+    int i;
 	float pi=3.141592;
 	WavData w;
+	w.load("COW.WAV");
+	char *data = w.data();
+	printf("%d\n",w.datasize());
+	char *data2 = new char[w.datasize()];
+
+    double test[w.datasize()*2][2];
+	double test1[w.datasize()*2][2];
+	double test2[w.datasize()*2][2];
  
-	double test[SIZE][2];
-	double test1[SIZE][2];
-	double test2[SIZE][2];
-
-	char *data = new char[SIZE];
-	char *data2 = new char[SIZE];
-
-    int i;
-	for(i=0;i<SIZE;i++){
-		float w=2.0*3.14*FREQLA;
-		float t=(float)i/FREQ;
-
-		data[i]=AMPLITUDE*(1+sin(w*t));
-
+//Creation de la donnée
+	
+	for(i=0;i<w.datasize();i++){
 		test[i][0]=(double)data[i];
-		test[i][1]=(double)data[i];
+		test[i][1]=0;
     }
-
-	fft(32768*2,test,test2);
  
+//FFT
+	fft(32768*2,test,test2);
+
+//FFT inverse
 	ifft(32768*2,test1,test2);
  
-	for(i=0;i<SIZE;i++){
+//Récupération des données
+	for(i=0;i<w.datasize();i++){
 		data2[i]=test1[i][0];
 	}
  
+//Preapation format final
 	w.setAudioFormat(1);
 	w.setNbrChanel(1);
 	w.setFrequency(FREQ);
@@ -50,7 +53,7 @@ int main(int argc, char **argv)
 	w.setBitsPerSample(8);
 	w.clearData();
  
-	w.setDatasize(SIZE);
+	w.setDatasize(w.datasize());
 	w.setData(data2);
 	w.save("cowfft.WAV");
  
@@ -0,0 +1,61 @@
+#include <iostream>
+#include "wavdata.h"
+#include "fft.h"
+#include <math.h>
+
+
+#define FREQ 22400
+#define AMPLITUDE 10
+#define FREQDO 261
+#define FREQLA	440
+#define SIZE FREQ*2
+
+
+int main(int argc, char **argv)
+{
+//Definition variables
+    int i,j;
+	float pi=3.141592;
+    double test[SIZE*2][2];
+	double test2[SIZE*2][2];
+	double test1[SIZE*2][2];
+
+	char *data2 = new char[SIZE];
+	WavData w;
+    
+//Creation de la donnée
+	for(i=0;i<SIZE;i++){
+		float wla=2.0*3.14*FREQLA;
+		float t=(float)i/FREQ;
+
+		test[i][0]=AMPLITUDE*(1+sin(wla*t));
+		test[i][1]=0;
+    }
+
+//FFT
+	fft(32768*2,test,test2);
+	
+//FFT inverse
+	ifft(32768*2,test1,test2);
+	
+//Récupération des données
+
+	for(j=0;j<SIZE;j++){
+		data2[j]=test1[j][0];
+	}
+
+//Preapation format final
+	w.setAudioFormat(1);
+	w.setNbrChanel(1);
+	w.setFrequency(FREQ);
+	w.setBytePerBloc(4);
+	w.setBytePerSec(FREQ);
+	w.setBitsPerSample(8);
+	w.clearData();
+	
+	w.setDatasize(SIZE);
+	w.setData(data2);
+	w.save("fftla.WAV");
+
+
+}
 \ No newline at end of file
@@ -0,0 +1,104 @@
+/*----------------------------------------------------------------------------
+   fft.c - fast Fourier transform and its inverse (both recursively)
+   Copyright (C) 2004, Jerome R. Breitenbach.  All rights reserved.
+
+   The author gives permission to anyone to freely copy, distribute, and use
+   this file, under the following conditions:
+	  - No changes are made.
+	  - No direct commercial advantage is obtained.
+	  - No liability is attributed to the author for any damages incurred.
+  ----------------------------------------------------------------------------*/
+
+/******************************************************************************
+ * This file defines a C function fft that, by calling another function       *
+ * fft_rec (also defined), calculates an FFT recursively.  Usage:             *
+ *   fft(N, x, X);                                                            *
+ * Parameters:                                                                *
+ *   N: number of points in FFT (must equal 2^n for some integer n >= 1)      *
+ *   x: pointer to N time-domain samples given in rectangular form (Re x,     *
+ *      Im x)                                                                 *
+ *   X: pointer to N frequency-domain samples calculated in rectangular form  *
+ *      (Re X, Im X)                                                          *
+ * Similarly, a function ifft with the same parameters is defined that        *
+ * calculates an inverse FFT (IFFT) recursively.  Usage:                      *
+ *   ifft(N, x, X);                                                           *
+ * Here, N and X are given, and x is calculated.                              *
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include "fft.h"
+/* macros */
+#define TWO_PI (6.2831853071795864769252867665590057683943L)
+
+/* FFT */
+void fft(int N, double (*x)[2], double (*X)[2])
+{
+  /* Declare a pointer to scratch space. */
+  double (*XX)[2] = (double (*)[2]) malloc(2 * N * sizeof(double));
+
+  /* Calculate FFT by a recursion. */
+  fft_rec(N, 0, 1, x, X, XX);
+
+  /* Free memory. */
+  free(XX);
+}
+
+/* FFT recursion */
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2])
+{
+  int N2 = N/2;            /* half the number of points in FFT */
+  int k;                   /* generic index */
+  double cs, sn;           /* cosine and sine */
+  int k00, k01, k10, k11;  /* indices for butterflies */
+  double tmp0, tmp1;       /* temporary storage */
+
+  if(N != 2)  /* Perform recursive step. */
+	{
+	  /* Calculate two (N/2)-point DFT's. */
+	  fft_rec(N2, offset, 2*delta, x, XX, X);
+	  fft_rec(N2, offset+delta, 2*delta, x, XX, X);
+
+	  /* Combine the two (N/2)-point DFT's into one N-point DFT. */
+	  for(k=0; k<N2; k++)
+		{
+		  k00 = offset + k*delta;    k01 = k00 + N2*delta;
+		  k10 = offset + 2*k*delta;  k11 = k10 + delta;
+		  cs = cos(TWO_PI*k/(double)N); sn = sin(TWO_PI*k/(double)N);
+		  tmp0 = cs * XX[k11][0] + sn * XX[k11][1];
+		  tmp1 = cs * XX[k11][1] - sn * XX[k11][0];
+		  X[k01][0] = XX[k10][0] - tmp0;
+		  X[k01][1] = XX[k10][1] - tmp1;
+		  X[k00][0] = XX[k10][0] + tmp0;
+		  X[k00][1] = XX[k10][1] + tmp1;
+		}
+	}
+  else  /* Perform 2-point DFT. */
+	{
+	  k00 = offset; k01 = k00 + delta;
+	  X[k01][0] = x[k00][0] - x[k01][0];
+	  X[k01][1] = x[k00][1] - x[k01][1];
+	  X[k00][0] = x[k00][0] + x[k01][0];
+	  X[k00][1] = x[k00][1] + x[k01][1];
+	}
+}
+
+/* IFFT */
+void ifft(int N, double (*x)[2], double (*X)[2])
+{
+  int N2 = N/2;       /* half the number of points in IFFT */
+  int i;              /* generic index */
+  double tmp0, tmp1;  /* temporary storage */
+
+  /* Calculate IFFT via reciprocity property of DFT. */
+  fft(N, X, x);
+  x[0][0] = x[0][0]/N;    x[0][1] = x[0][1]/N;
+  x[N2][0] = x[N2][0]/N;  x[N2][1] = x[N2][1]/N;
+  for(i=1; i<N2; i++)
+	{
+	  tmp0 = x[i][0]/N;       tmp1 = x[i][1]/N;
+	  x[i][0] = x[N-i][0]/N;  x[i][1] = x[N-i][1]/N;
+	  x[N-i][0] = tmp0;       x[N-i][1] = tmp1;
+	}
+}
@@ -0,0 +1,10 @@
+#ifndef FFT_H
+#define FFT_H
+
+/* function prototypes */
+void fft(int N, double (*x)[2], double (*X)[2]);
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2]);
+void ifft(int N, double (*x)[2], double (*X)[2]);
+
+#endif // FFT_H
@@ -0,0 +1,269 @@
+#include "wavdata.h"
+#include <iostream>
+
+
+using namespace std;
+
+WavData::WavData()
+{
+	_data=NULL;
+}
+
+int WavData::error(int i,int line)
+{
+	std::cerr << "Erreur "<<__FILE__<<" L"<<line<< ": ";
+	switch(i)
+	{
+	case -1: std::cerr << "ouverture du fichier";
+		break;
+	case -2: std::cerr << "le fichier n'est pas au format WAVE";
+		break;
+	default: std::cerr << "inconnue";
+		break;
+	}
+
+	std::cerr << "\n";
+	return i;
+}
+
+unsigned int WavData::fromLittleEndian(char * content, int size)
+{
+	unsigned int result = 0;
+	for(int i=size;i>=0;i--)
+	{
+		result *= 256;
+		result += (unsigned char)content[i];
+	}
+	return result;
+}
+
+char * WavData::toLittleEndian(unsigned int content, int size)
+{
+	char * result= new char [size*sizeof(char)];
+
+	for(int i=0;i<size;i++)
+	{
+		result += (char)(content%256);
+		content >>= 8;
+	}
+
+	return result;
+}
+
+void WavData::toLittleEndian(char* result,unsigned int content, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		result[i] = (char)(content%256);
+		content >>= 8;
+	}
+
+	return;
+}
+
+char * WavData::read(ifstream* file,unsigned int size)
+{
+	char * c = new char[size+1];
+	for(int i=0;i<size;i++)
+	{
+		c[i] = file->get();
+	}
+	c[size]='\0';
+	return c;
+}
+
+bool WavData::comp(char* c1, char *c2, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		if(c1[i]!=c2[i])return false;
+	}
+	return true;
+}
+
+int WavData::testString(ifstream* file,char*compstr,int size,char *mess)
+{
+	char * content = read(file,size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<< content << std::endl << "|"<<std::endl;
+	if(!comp(content,compstr,size))return error(-2,__LINE__);
+	
+	delete[] content;
+	return 1;
+}
+
+int WavData::testInt(ifstream* file,int size,char *mess,unsigned int *val)
+{
+	int test;
+	char * content = read(file,size);
+	
+	int value=fromLittleEndian(content, size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<<value << std::endl<<"|" <<std::endl;
+	if(val!=NULL)*val=value;
+	delete[] content;
+	return 1;
+}
+
+int WavData::openFormatBloc(ifstream* file)
+{
+	std::cout << "[Bloc de declaration d'un fichier au format WAVE]"<<std::endl<<"|"<<std::endl;
+
+	//  FileTypeBlocId
+	int r;
+	r = testString(file,"RIFF",4,	"FileTypeBlocID  (4 octets) : Constante 'RIFF'");
+	if(r<=0)return r;
+	
+	//  FileSize
+	r = testInt(file,4,				"FileSize        (4 octets) : Taille du fichier moins 8 octets");
+	if(r<=0)return r;
+	
+	//  FileFormatID
+	r = testString(file,"WAVE",4,	"FileFormatID    (4 octets) : Format = 'WAVE'");
+	if(r<=0)return r;
+	
+	std::cout << std::endl;
+	return 1;
+}
+
+int WavData::openDescriptionBloc(ifstream* file)
+{
+	std::cout << "[Bloc decrivant le format audio]"<<std::endl<<"|"<<std::endl;
+	
+	int r;
+
+	//  FormatBlocID
+	r = testString(file,"fmt ",4, "FormatBlocID    (4 octets) : Identifiant 'fmt'");
+	if(r<=0)return r;
+
+	//  BlocSize
+	r = testInt(file,4,"BlocSize        (4 octets) : Nombre d'octets du bloc - 8 (attendue: 16)");
+	if(r<=0)return r;
+	
+	//  AudioFormat
+	r = testInt(file,2,"AudioFormat     (2 octets) : Format du stockage dans le fichier (1: PCM, ...)",&_audioFormat);
+	if(r<=0)return r;
+	
+	//  NbrCanaux
+	r = testInt(file,2,"NbrCanaux       (2 octets) : Nombre de canaux (de 1 a 6)",&_nbrChanel);
+	if(r<=0)return r;
+	
+	//  Frequency
+	r = testInt(file,4,"Frequence       (4 octets) : Frequence d'echantillonnage (en Hertz)",&_frequency);
+	if(r<=0)return r;
+	
+	//  BytePerSec
+	r = testInt(file,4,"BytePerSec      (4 octets) : Nombre d'octets a lire par seconde",&_bytePerSec);
+	if(r<=0)return r;
+	
+	//   BytePerBloc
+	r = testInt(file,2,"BytePerBloc     (2 octets) : Nombre d'octets par bloc d'echantillonnage",&_bytePerBloc);
+	if(r<=0)return r;
+	
+	//   BitsPerSample
+	r = testInt(file,2,"BitsPerSample   (2 octets) : Nombre de bits pour le codage d'un echantillon",&_bitsPerSample);
+	if(r<=0)return r;
+
+	return 1;
+}
+
+int WavData::openDataBloc(ifstream* file)
+{
+	std::cout << "[Bloc des donnees]\n";
+	
+	int r,test;
+	//  DataBlocID
+	r = testString(file,"data",4,"DataBlocID      (4 octets) : Constante 'data'");
+	if(r<=0)return r;
+	
+	//  DataSize
+	r = testInt(file,3,"DataSize        (4 octets) : Nombre d'octets des donnees",&_datasize);
+	if(r<=0)return r;
+	
+	//  Data[];
+	std::cout << "| Data[] : [Octets du Sample 1 du Canal 1] [Octets du Sample 1 du Canal 2] [Octets du Sample 2 du Canal 1] [Octets du Sample 2 du Canal 2]\n\n";
+	if(_data!=NULL)delete[] _data;
+	_data = read(file,_datasize);
+	
+	return 1;
+}
+
+int WavData::load(char * s)
+{
+	std::cout << "Load file: \"" << s << "\""<<std::endl<<std::endl;
+
+	ifstream file(s, ios::in | ios::binary );
+	if (!file)return error(-1,__LINE__);
+
+	if(openFormatBloc(&file)		!= 1)	{file.close(); return 0;}
+	if(openDescriptionBloc(&file)	!= 1)	{file.close(); return 0;}
+	if(openDataBloc(&file)			!= 1)	{file.close(); return 0;}
+	
+	std::cout << "close file"<< std::endl;
+	file.close();
+	std::cout << "file closed"<<std::endl;
+
+	return 1;
+}
+
+void WavData::write(ofstream *file,char* mess,unsigned int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		file->put(mess[i]);
+	}
+}
+
+int WavData::saveFormatBloc(ofstream* file)
+{
+	char b[13] = "RIFF    WAVE";
+	
+	toLittleEndian(b+4,_datasize+36,4);
+	
+	write(file,b,12);
+	
+	return 1;
+}
+
+int WavData::saveDescriptionBloc(ofstream* file)
+{
+	char b[25] = "fmt                     ";
+	
+	toLittleEndian(b+4,0x10,4);
+	std::cout<<_audioFormat<<std::endl;
+	toLittleEndian(b+8,_audioFormat,2);
+	toLittleEndian(b+10,_nbrChanel,2);
+	toLittleEndian(b+12,_frequency,4);
+	toLittleEndian(b+16,_bytePerSec,4);
+	toLittleEndian(b+20,_bytePerBloc,2);
+	toLittleEndian(b+22,_bitsPerSample,2);
+	
+	write(file,b,24);
+	
+	return 1;
+}
+int WavData::saveDataBloc(ofstream* file)
+{
+	char b[9] = "data    ";
+	toLittleEndian(b+4,_datasize,4);
+	
+	write(file,b,8);
+	
+	write(file,_data,_datasize);
+	
+	return 1;
+}
+
+int WavData::save(char * s)
+{
+	std::cout << "Save file: \"" << s << "\"\n\n";
+
+	ofstream file(s, ios::out | ios::trunc | ios::binary);
+	if (!file)return error(-1,__LINE__);
+
+	saveFormatBloc(&file);
+	saveDescriptionBloc(&file);
+	saveDataBloc(&file);
+
+	file.close();
+
+	return 1;
+}
@@ -0,0 +1,66 @@
+#ifndef WAVDATA_H
+#define WAVDATA_H
+
+#include <iostream>
+#include <fstream>
+
+class WavData
+{
+	unsigned int _audioFormat;
+	unsigned int _nbrChanel;
+	unsigned int _frequency;
+	unsigned int _bytePerBloc;
+	unsigned int _bytePerSec;
+	unsigned int _bitsPerSample;
+
+	char * _data;
+	unsigned int _datasize;
+public:
+	WavData();
+
+	int load(char* s);
+	int save(char* s);
+
+	unsigned int fromLittleEndian(char * content, int size);
+	char * toLittleEndian(unsigned int content, int size);
+	void toLittleEndian(char* result,unsigned int content, int size);
+
+	inline unsigned int audioFormat(){return _audioFormat;}
+	inline unsigned int nbrChanel(){return _nbrChanel;}
+	inline unsigned int frequency(){return _frequency;}
+	inline unsigned int bytePerBloc(){return _bytePerBloc;}
+	inline unsigned int bytePerSec(){return _bytePerSec;}
+	inline unsigned int bitsPerSample(){return _bitsPerSample;}
+	inline unsigned int datasize(){return _datasize;}
+	inline char * data(){return _data;}
+
+	inline void setAudioFormat(unsigned int a){_audioFormat=a;}
+	inline void setNbrChanel(unsigned int a){_nbrChanel=a;}
+	inline void setFrequency(unsigned int a){_frequency=a;}
+	inline void setBytePerBloc(unsigned int a){_bytePerBloc=a;}
+	inline void setBytePerSec(unsigned int a){_bytePerSec=a;}
+	inline void setBitsPerSample(unsigned int a){_bitsPerSample=a;}
+	inline void setData(char * a){_data=a;}
+	inline void clearData(){delete[] _data;_data=NULL;}
+	inline void setDatasize(unsigned int i){_datasize=i;}
+	
+private:
+	int error(int,int);
+	int openFormatBloc(std::ifstream* file);
+	int openDescriptionBloc(std::ifstream *file);
+	int openDataBloc(std::ifstream *file);
+
+	int saveFormatBloc(std::ofstream *file);
+	int saveDescriptionBloc(std::ofstream *file);
+	int saveDataBloc(std::ofstream *file);
+	
+	void write(std::ofstream *file,char* mess,unsigned int size);
+	char * read(std::ifstream* file,unsigned int size);
+	
+	bool comp(char* c1, char *c2, int size);
+	int testString(std::ifstream* file,char*compstr,int size,char *mess);
+	int testInt(std::ifstream* file,int size,char *mess,unsigned int *val=NULL);
+
+};
+
+#endif // WAVDATA_H
@@ -0,0 +1,104 @@
+/*----------------------------------------------------------------------------
+   fft.c - fast Fourier transform and its inverse (both recursively)
+   Copyright (C) 2004, Jerome R. Breitenbach.  All rights reserved.
+
+   The author gives permission to anyone to freely copy, distribute, and use
+   this file, under the following conditions:
+	  - No changes are made.
+	  - No direct commercial advantage is obtained.
+	  - No liability is attributed to the author for any damages incurred.
+  ----------------------------------------------------------------------------*/
+
+/******************************************************************************
+ * This file defines a C function fft that, by calling another function       *
+ * fft_rec (also defined), calculates an FFT recursively.  Usage:             *
+ *   fft(N, x, X);                                                            *
+ * Parameters:                                                                *
+ *   N: number of points in FFT (must equal 2^n for some integer n >= 1)      *
+ *   x: pointer to N time-domain samples given in rectangular form (Re x,     *
+ *      Im x)                                                                 *
+ *   X: pointer to N frequency-domain samples calculated in rectangular form  *
+ *      (Re X, Im X)                                                          *
+ * Similarly, a function ifft with the same parameters is defined that        *
+ * calculates an inverse FFT (IFFT) recursively.  Usage:                      *
+ *   ifft(N, x, X);                                                           *
+ * Here, N and X are given, and x is calculated.                              *
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include "fft.h"
+/* macros */
+#define TWO_PI (6.2831853071795864769252867665590057683943L)
+
+/* FFT */
+void fft(int N, double (*x)[2], double (*X)[2])
+{
+  /* Declare a pointer to scratch space. */
+  double (*XX)[2] = (double (*)[2]) malloc(2 * N * sizeof(double));
+
+  /* Calculate FFT by a recursion. */
+  fft_rec(N, 0, 1, x, X, XX);
+
+  /* Free memory. */
+  free(XX);
+}
+
+/* FFT recursion */
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2])
+{
+  int N2 = N/2;            /* half the number of points in FFT */
+  int k;                   /* generic index */
+  double cs, sn;           /* cosine and sine */
+  int k00, k01, k10, k11;  /* indices for butterflies */
+  double tmp0, tmp1;       /* temporary storage */
+
+  if(N != 2)  /* Perform recursive step. */
+	{
+	  /* Calculate two (N/2)-point DFT's. */
+	  fft_rec(N2, offset, 2*delta, x, XX, X);
+	  fft_rec(N2, offset+delta, 2*delta, x, XX, X);
+
+	  /* Combine the two (N/2)-point DFT's into one N-point DFT. */
+	  for(k=0; k<N2; k++)
+		{
+		  k00 = offset + k*delta;    k01 = k00 + N2*delta;
+		  k10 = offset + 2*k*delta;  k11 = k10 + delta;
+		  cs = cos(TWO_PI*k/(double)N); sn = sin(TWO_PI*k/(double)N);
+		  tmp0 = cs * XX[k11][0] + sn * XX[k11][1];
+		  tmp1 = cs * XX[k11][1] - sn * XX[k11][0];
+		  X[k01][0] = XX[k10][0] - tmp0;
+		  X[k01][1] = XX[k10][1] - tmp1;
+		  X[k00][0] = XX[k10][0] + tmp0;
+		  X[k00][1] = XX[k10][1] + tmp1;
+		}
+	}
+  else  /* Perform 2-point DFT. */
+	{
+	  k00 = offset; k01 = k00 + delta;
+	  X[k01][0] = x[k00][0] - x[k01][0];
+	  X[k01][1] = x[k00][1] - x[k01][1];
+	  X[k00][0] = x[k00][0] + x[k01][0];
+	  X[k00][1] = x[k00][1] + x[k01][1];
+	}
+}
+
+/* IFFT */
+void ifft(int N, double (*x)[2], double (*X)[2])
+{
+  int N2 = N/2;       /* half the number of points in IFFT */
+  int i;              /* generic index */
+  double tmp0, tmp1;  /* temporary storage */
+
+  /* Calculate IFFT via reciprocity property of DFT. */
+  fft(N, X, x);
+  x[0][0] = x[0][0]/N;    x[0][1] = x[0][1]/N;
+  x[N2][0] = x[N2][0]/N;  x[N2][1] = x[N2][1]/N;
+  for(i=1; i<N2; i++)
+	{
+	  tmp0 = x[i][0]/N;       tmp1 = x[i][1]/N;
+	  x[i][0] = x[N-i][0]/N;  x[i][1] = x[N-i][1]/N;
+	  x[N-i][0] = tmp0;       x[N-i][1] = tmp1;
+	}
+}
@@ -0,0 +1,10 @@
+#ifndef FFT_H
+#define FFT_H
+
+/* function prototypes */
+void fft(int N, double (*x)[2], double (*X)[2]);
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2]);
+void ifft(int N, double (*x)[2], double (*X)[2]);
+
+#endif // FFT_H
@@ -3,7 +3,7 @@
 #include "fft.h"
 #include <math.h>
  
-#define FREQ 48000
+#define FREQ 22400
 #define AMPLITUDE 10
 #define FREQDO 261
 #define FREQLA	440
@@ -14,19 +14,21 @@ int main(int argc, char **argv)
 {
 	float pi=3.141592;
 	WavData w;
-	
 	char *data = new char[SIZE];
 	char *data2 = new char[SIZE];
-
     int i;
+
+	//Creation de la données
 	for(i=0;i<SIZE;i++){
-		float w=2.0*3.14*FREQLA;
+		float wla=2.0*3.14*FREQLA;
+		float wdo=2.0*3.14*FREQDO;
 		float t=(float)i/FREQ;
  
-		data[i]=AMPLITUDE*(1+sin(w*t));
+		data[i]=AMPLITUDE*(1+sin(wla*t));
+		data2[i]=AMPLITUDE*(1+sin(wdo*t));
     }
  
-	
+	//setup du format audio de sortie
 	w.setAudioFormat(1);
 	w.setNbrChanel(1);
 	w.setFrequency(FREQ);
@@ -35,8 +37,14 @@ int main(int argc, char **argv)
 	w.setBitsPerSample(8);
 	w.clearData();
  
+	//implémentation des données de sortie
 	w.setDatasize(SIZE);
 	w.setData(data);
 	w.save("purla.WAV");
  
+	w.clearData();
+	w.setDatasize(SIZE);
+	w.setData(data2);
+	w.save("purdo.WAV");
+
 }
 \ No newline at end of file
@@ -0,0 +1,269 @@
+#include "wavdata.h"
+#include <iostream>
+
+
+using namespace std;
+
+WavData::WavData()
+{
+	_data=NULL;
+}
+
+int WavData::error(int i,int line)
+{
+	std::cerr << "Erreur "<<__FILE__<<" L"<<line<< ": ";
+	switch(i)
+	{
+	case -1: std::cerr << "ouverture du fichier";
+		break;
+	case -2: std::cerr << "le fichier n'est pas au format WAVE";
+		break;
+	default: std::cerr << "inconnue";
+		break;
+	}
+
+	std::cerr << "\n";
+	return i;
+}
+
+unsigned int WavData::fromLittleEndian(char * content, int size)
+{
+	unsigned int result = 0;
+	for(int i=size;i>=0;i--)
+	{
+		result *= 256;
+		result += (unsigned char)content[i];
+	}
+	return result;
+}
+
+char * WavData::toLittleEndian(unsigned int content, int size)
+{
+	char * result= new char [size*sizeof(char)];
+
+	for(int i=0;i<size;i++)
+	{
+		result += (char)(content%256);
+		content >>= 8;
+	}
+
+	return result;
+}
+
+void WavData::toLittleEndian(char* result,unsigned int content, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		result[i] = (char)(content%256);
+		content >>= 8;
+	}
+
+	return;
+}
+
+char * WavData::read(ifstream* file,unsigned int size)
+{
+	char * c = new char[size+1];
+	for(int i=0;i<size;i++)
+	{
+		c[i] = file->get();
+	}
+	c[size]='\0';
+	return c;
+}
+
+bool WavData::comp(char* c1, char *c2, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		if(c1[i]!=c2[i])return false;
+	}
+	return true;
+}
+
+int WavData::testString(ifstream* file,char*compstr,int size,char *mess)
+{
+	char * content = read(file,size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<< content << std::endl << "|"<<std::endl;
+	if(!comp(content,compstr,size))return error(-2,__LINE__);
+	
+	delete[] content;
+	return 1;
+}
+
+int WavData::testInt(ifstream* file,int size,char *mess,unsigned int *val)
+{
+	int test;
+	char * content = read(file,size);
+	
+	int value=fromLittleEndian(content, size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<<value << std::endl<<"|" <<std::endl;
+	if(val!=NULL)*val=value;
+	delete[] content;
+	return 1;
+}
+
+int WavData::openFormatBloc(ifstream* file)
+{
+	std::cout << "[Bloc de declaration d'un fichier au format WAVE]"<<std::endl<<"|"<<std::endl;
+
+	//  FileTypeBlocId
+	int r;
+	r = testString(file,"RIFF",4,	"FileTypeBlocID  (4 octets) : Constante 'RIFF'");
+	if(r<=0)return r;
+	
+	//  FileSize
+	r = testInt(file,4,				"FileSize        (4 octets) : Taille du fichier moins 8 octets");
+	if(r<=0)return r;
+	
+	//  FileFormatID
+	r = testString(file,"WAVE",4,	"FileFormatID    (4 octets) : Format = 'WAVE'");
+	if(r<=0)return r;
+	
+	std::cout << std::endl;
+	return 1;
+}
+
+int WavData::openDescriptionBloc(ifstream* file)
+{
+	std::cout << "[Bloc decrivant le format audio]"<<std::endl<<"|"<<std::endl;
+	
+	int r;
+
+	//  FormatBlocID
+	r = testString(file,"fmt ",4, "FormatBlocID    (4 octets) : Identifiant 'fmt'");
+	if(r<=0)return r;
+
+	//  BlocSize
+	r = testInt(file,4,"BlocSize        (4 octets) : Nombre d'octets du bloc - 8 (attendue: 16)");
+	if(r<=0)return r;
+	
+	//  AudioFormat
+	r = testInt(file,2,"AudioFormat     (2 octets) : Format du stockage dans le fichier (1: PCM, ...)",&_audioFormat);
+	if(r<=0)return r;
+	
+	//  NbrCanaux
+	r = testInt(file,2,"NbrCanaux       (2 octets) : Nombre de canaux (de 1 a 6)",&_nbrChanel);
+	if(r<=0)return r;
+	
+	//  Frequency
+	r = testInt(file,4,"Frequence       (4 octets) : Frequence d'echantillonnage (en Hertz)",&_frequency);
+	if(r<=0)return r;
+	
+	//  BytePerSec
+	r = testInt(file,4,"BytePerSec      (4 octets) : Nombre d'octets a lire par seconde",&_bytePerSec);
+	if(r<=0)return r;
+	
+	//   BytePerBloc
+	r = testInt(file,2,"BytePerBloc     (2 octets) : Nombre d'octets par bloc d'echantillonnage",&_bytePerBloc);
+	if(r<=0)return r;
+	
+	//   BitsPerSample
+	r = testInt(file,2,"BitsPerSample   (2 octets) : Nombre de bits pour le codage d'un echantillon",&_bitsPerSample);
+	if(r<=0)return r;
+
+	return 1;
+}
+
+int WavData::openDataBloc(ifstream* file)
+{
+	std::cout << "[Bloc des donnees]\n";
+	
+	int r,test;
+	//  DataBlocID
+	r = testString(file,"data",4,"DataBlocID      (4 octets) : Constante 'data'");
+	if(r<=0)return r;
+	
+	//  DataSize
+	r = testInt(file,3,"DataSize        (4 octets) : Nombre d'octets des donnees",&_datasize);
+	if(r<=0)return r;
+	
+	//  Data[];
+	std::cout << "| Data[] : [Octets du Sample 1 du Canal 1] [Octets du Sample 1 du Canal 2] [Octets du Sample 2 du Canal 1] [Octets du Sample 2 du Canal 2]\n\n";
+	if(_data!=NULL)delete[] _data;
+	_data = read(file,_datasize);
+	
+	return 1;
+}
+
+int WavData::load(char * s)
+{
+	std::cout << "Load file: \"" << s << "\""<<std::endl<<std::endl;
+
+	ifstream file(s, ios::in | ios::binary );
+	if (!file)return error(-1,__LINE__);
+
+	if(openFormatBloc(&file)		!= 1)	{file.close(); return 0;}
+	if(openDescriptionBloc(&file)	!= 1)	{file.close(); return 0;}
+	if(openDataBloc(&file)			!= 1)	{file.close(); return 0;}
+	
+	std::cout << "close file"<< std::endl;
+	file.close();
+	std::cout << "file closed"<<std::endl;
+
+	return 1;
+}
+
+void WavData::write(ofstream *file,char* mess,unsigned int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		file->put(mess[i]);
+	}
+}
+
+int WavData::saveFormatBloc(ofstream* file)
+{
+	char b[13] = "RIFF    WAVE";
+	
+	toLittleEndian(b+4,_datasize+36,4);
+	
+	write(file,b,12);
+	
+	return 1;
+}
+
+int WavData::saveDescriptionBloc(ofstream* file)
+{
+	char b[25] = "fmt                     ";
+	
+	toLittleEndian(b+4,0x10,4);
+	std::cout<<_audioFormat<<std::endl;
+	toLittleEndian(b+8,_audioFormat,2);
+	toLittleEndian(b+10,_nbrChanel,2);
+	toLittleEndian(b+12,_frequency,4);
+	toLittleEndian(b+16,_bytePerSec,4);
+	toLittleEndian(b+20,_bytePerBloc,2);
+	toLittleEndian(b+22,_bitsPerSample,2);
+	
+	write(file,b,24);
+	
+	return 1;
+}
+int WavData::saveDataBloc(ofstream* file)
+{
+	char b[9] = "data    ";
+	toLittleEndian(b+4,_datasize,4);
+	
+	write(file,b,8);
+	
+	write(file,_data,_datasize);
+	
+	return 1;
+}
+
+int WavData::save(char * s)
+{
+	std::cout << "Save file: \"" << s << "\"\n\n";
+
+	ofstream file(s, ios::out | ios::trunc | ios::binary);
+	if (!file)return error(-1,__LINE__);
+
+	saveFormatBloc(&file);
+	saveDescriptionBloc(&file);
+	saveDataBloc(&file);
+
+	file.close();
+
+	return 1;
+}
@@ -0,0 +1,66 @@
+#ifndef WAVDATA_H
+#define WAVDATA_H
+
+#include <iostream>
+#include <fstream>
+
+class WavData
+{
+	unsigned int _audioFormat;
+	unsigned int _nbrChanel;
+	unsigned int _frequency;
+	unsigned int _bytePerBloc;
+	unsigned int _bytePerSec;
+	unsigned int _bitsPerSample;
+
+	char * _data;
+	unsigned int _datasize;
+public:
+	WavData();
+
+	int load(char* s);
+	int save(char* s);
+
+	unsigned int fromLittleEndian(char * content, int size);
+	char * toLittleEndian(unsigned int content, int size);
+	void toLittleEndian(char* result,unsigned int content, int size);
+
+	inline unsigned int audioFormat(){return _audioFormat;}
+	inline unsigned int nbrChanel(){return _nbrChanel;}
+	inline unsigned int frequency(){return _frequency;}
+	inline unsigned int bytePerBloc(){return _bytePerBloc;}
+	inline unsigned int bytePerSec(){return _bytePerSec;}
+	inline unsigned int bitsPerSample(){return _bitsPerSample;}
+	inline unsigned int datasize(){return _datasize;}
+	inline char * data(){return _data;}
+
+	inline void setAudioFormat(unsigned int a){_audioFormat=a;}
+	inline void setNbrChanel(unsigned int a){_nbrChanel=a;}
+	inline void setFrequency(unsigned int a){_frequency=a;}
+	inline void setBytePerBloc(unsigned int a){_bytePerBloc=a;}
+	inline void setBytePerSec(unsigned int a){_bytePerSec=a;}
+	inline void setBitsPerSample(unsigned int a){_bitsPerSample=a;}
+	inline void setData(char * a){_data=a;}
+	inline void clearData(){delete[] _data;_data=NULL;}
+	inline void setDatasize(unsigned int i){_datasize=i;}
+	
+private:
+	int error(int,int);
+	int openFormatBloc(std::ifstream* file);
+	int openDescriptionBloc(std::ifstream *file);
+	int openDataBloc(std::ifstream *file);
+
+	int saveFormatBloc(std::ofstream *file);
+	int saveDescriptionBloc(std::ofstream *file);
+	int saveDataBloc(std::ofstream *file);
+	
+	void write(std::ofstream *file,char* mess,unsigned int size);
+	char * read(std::ifstream* file,unsigned int size);
+	
+	bool comp(char* c1, char *c2, int size);
+	int testString(std::ifstream* file,char*compstr,int size,char *mess);
+	int testInt(std::ifstream* file,int size,char *mess,unsigned int *val=NULL);
+
+};
+
+#endif // WAVDATA_H
@@ -0,0 +1,104 @@
+/*----------------------------------------------------------------------------
+   fft.c - fast Fourier transform and its inverse (both recursively)
+   Copyright (C) 2004, Jerome R. Breitenbach.  All rights reserved.
+
+   The author gives permission to anyone to freely copy, distribute, and use
+   this file, under the following conditions:
+	  - No changes are made.
+	  - No direct commercial advantage is obtained.
+	  - No liability is attributed to the author for any damages incurred.
+  ----------------------------------------------------------------------------*/
+
+/******************************************************************************
+ * This file defines a C function fft that, by calling another function       *
+ * fft_rec (also defined), calculates an FFT recursively.  Usage:             *
+ *   fft(N, x, X);                                                            *
+ * Parameters:                                                                *
+ *   N: number of points in FFT (must equal 2^n for some integer n >= 1)      *
+ *   x: pointer to N time-domain samples given in rectangular form (Re x,     *
+ *      Im x)                                                                 *
+ *   X: pointer to N frequency-domain samples calculated in rectangular form  *
+ *      (Re X, Im X)                                                          *
+ * Similarly, a function ifft with the same parameters is defined that        *
+ * calculates an inverse FFT (IFFT) recursively.  Usage:                      *
+ *   ifft(N, x, X);                                                           *
+ * Here, N and X are given, and x is calculated.                              *
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <math.h>
+#include "fft.h"
+/* macros */
+#define TWO_PI (6.2831853071795864769252867665590057683943L)
+
+/* FFT */
+void fft(int N, double (*x)[2], double (*X)[2])
+{
+  /* Declare a pointer to scratch space. */
+  double (*XX)[2] = (double (*)[2]) malloc(2 * N * sizeof(double));
+
+  /* Calculate FFT by a recursion. */
+  fft_rec(N, 0, 1, x, X, XX);
+
+  /* Free memory. */
+  free(XX);
+}
+
+/* FFT recursion */
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2])
+{
+  int N2 = N/2;            /* half the number of points in FFT */
+  int k;                   /* generic index */
+  double cs, sn;           /* cosine and sine */
+  int k00, k01, k10, k11;  /* indices for butterflies */
+  double tmp0, tmp1;       /* temporary storage */
+
+  if(N != 2)  /* Perform recursive step. */
+	{
+	  /* Calculate two (N/2)-point DFT's. */
+	  fft_rec(N2, offset, 2*delta, x, XX, X);
+	  fft_rec(N2, offset+delta, 2*delta, x, XX, X);
+
+	  /* Combine the two (N/2)-point DFT's into one N-point DFT. */
+	  for(k=0; k<N2; k++)
+		{
+		  k00 = offset + k*delta;    k01 = k00 + N2*delta;
+		  k10 = offset + 2*k*delta;  k11 = k10 + delta;
+		  cs = cos(TWO_PI*k/(double)N); sn = sin(TWO_PI*k/(double)N);
+		  tmp0 = cs * XX[k11][0] + sn * XX[k11][1];
+		  tmp1 = cs * XX[k11][1] - sn * XX[k11][0];
+		  X[k01][0] = XX[k10][0] - tmp0;
+		  X[k01][1] = XX[k10][1] - tmp1;
+		  X[k00][0] = XX[k10][0] + tmp0;
+		  X[k00][1] = XX[k10][1] + tmp1;
+		}
+	}
+  else  /* Perform 2-point DFT. */
+	{
+	  k00 = offset; k01 = k00 + delta;
+	  X[k01][0] = x[k00][0] - x[k01][0];
+	  X[k01][1] = x[k00][1] - x[k01][1];
+	  X[k00][0] = x[k00][0] + x[k01][0];
+	  X[k00][1] = x[k00][1] + x[k01][1];
+	}
+}
+
+/* IFFT */
+void ifft(int N, double (*x)[2], double (*X)[2])
+{
+  int N2 = N/2;       /* half the number of points in IFFT */
+  int i;              /* generic index */
+  double tmp0, tmp1;  /* temporary storage */
+
+  /* Calculate IFFT via reciprocity property of DFT. */
+  fft(N, X, x);
+  x[0][0] = x[0][0]/N;    x[0][1] = x[0][1]/N;
+  x[N2][0] = x[N2][0]/N;  x[N2][1] = x[N2][1]/N;
+  for(i=1; i<N2; i++)
+	{
+	  tmp0 = x[i][0]/N;       tmp1 = x[i][1]/N;
+	  x[i][0] = x[N-i][0]/N;  x[i][1] = x[N-i][1]/N;
+	  x[N-i][0] = tmp0;       x[N-i][1] = tmp1;
+	}
+}
@@ -0,0 +1,10 @@
+#ifndef FFT_H
+#define FFT_H
+
+/* function prototypes */
+void fft(int N, double (*x)[2], double (*X)[2]);
+void fft_rec(int N, int offset, int delta,
+			 double (*x)[2], double (*X)[2], double (*XX)[2]);
+void ifft(int N, double (*x)[2], double (*X)[2]);
+
+#endif // FFT_H
@@ -0,0 +1,76 @@
+#include <iostream>
+#include "wavdata.h"
+#include "fft.h"
+#include <math.h>
+
+
+#define FREQ 22400
+#define AMPLITUDE 10
+#define FREQDO 261
+#define FREQLA	440
+#define SIZE FREQ*2
+
+
+int main(int argc, char **argv)
+{
+//Definition variables
+    int i,j;
+	float pi=3.141592;
+    double test[SIZE*2][2];
+	double test2[SIZE*2][2];
+	double test1[SIZE*2][2];
+	double test3[SIZE*2][2];
+
+	char *data2 = new char[SIZE];
+	WavData w;
+    
+//Creation de la donnée
+	printf("===Creation data\n");
+	for(i=0;i<SIZE;i++){
+		float wla=2.0*3.14*FREQLA;
+		float t=(float)i/FREQ;
+
+		test[i][0]=AMPLITUDE*(1+sin(wla*t));
+		test[i][1]=0;
+    }
+
+//FFT
+	printf("===fft\n");
+	fft(32768*2,test,test2);
+
+//Modification dans le domaine fréquentiel
+	printf("===modif freq\n");
+	for(i=0;i<SIZE;i++){
+		int x=i;
+
+		test3[2*x][0]=test2[x][0];
+		test3[2*x+1][0]=test2[x][0];
+		test3[2*x][1]=0;
+        test3[2*x+1][1]=0;
+	}
+	
+//FFT inverse
+	ifft(32768*2,test1,test3);
+	
+//Récupération des données
+
+	for(j=0;j<SIZE;j++){
+		data2[j]=10*(test1[j][0]+5);
+		printf("%d %lf %lf\n ",j,test1[j][0],test[j][0]);
+	}
+
+//Preapation format final
+	w.setAudioFormat(1);
+	w.setNbrChanel(1);
+	w.setFrequency(FREQ);
+	w.setBytePerBloc(4);
+	w.setBytePerSec(FREQ);
+	w.setBitsPerSample(8);
+	w.clearData();
+	
+	w.setDatasize(SIZE);
+	w.setData(data2);
+	w.save("lastrech.WAV");
+
+
+}
 \ No newline at end of file
@@ -36,22 +36,28 @@ int main(int argc, char **argv)
  
 //FFT
 	fft(32768*4,test,test2);
-
+	
 //Modification dans le domaine fréquentiel
 	for(i=0;i<SIZE;i+=2){
 		test3[i][0]=test2[i][0];
-        printf("%lf ",test2[i][0]);
+        //printf("%lf ",test2[i][0]);
 		test3[i+1][0]=test2[i][0];
 		test3[i][1]=0;
         test3[i+1][1]=0;
 	}
-
+	
 //FFT inverse
 	ifft(32768*4,test1,test3);
+	
 //Récupération des données
+	float moy=0.0;
+	for(i=0;i<SIZE;i+=2){
+		moy=+test3[i][0];
+	}
  
+	printf("%f ",moy);
 	for(i=0;i<SIZE;i++){
-		data2[i]=test1[i][0];
+		data2[i]=test1[i][0]*5+50;
 	}
 //Preapation format final
 	w.setAudioFormat(1);
@@ -0,0 +1,76 @@
+#include <iostream>
+#include "wavdata.h"
+#include "fft.h"
+#include <math.h>
+
+
+#define FREQ 22400
+#define AMPLITUDE 10
+#define FREQDO 261
+#define FREQLA	440
+#define SIZE FREQ*2
+
+
+int main(int argc, char **argv)
+{
+//Definition variables
+    int i;
+	float pi=3.141592;
+	WavData w;
+	w.load("COW.WAV");
+	char *data = w.data();
+    double test[w.datasize()*2][2];
+	double test1[w.datasize()*2][2];
+	double test2[w.datasize()*2][2];
+	double test3[w.datasize()*2][2];
+	
+	
+    printf("===Création data\n");
+//Creation de la donnée
+	char *data2 = new char[w.datasize()*2];
+	printf("===load success\n");
+
+	for(i=0;i<w.datasize();i++){
+		test[i][0]=(double)data[i];
+		test[i][1]=0;
+    }
+	
+//FFT
+	printf("===fft\n");
+	fft(32768*2,test,test2);
+
+//Modification dans le domaine fréquentiel
+	printf("===modif freq\n");
+	for(i=1;i<w.datasize()+1;i++){
+		int x=i-1;
+		int y=(2*i)-2;
+
+		test3[2*x][0]=test2[x][0];
+		test3[2*x+1][0]=test2[x][0];
+		test3[2*x][1]=0;
+        test3[2*x+1][1]=0;
+	}
+	
+//FFT inverse
+	printf("===ifft\n");
+	ifft(32768*2,test1,test3);
+
+//Récupération des données
+	for(i=0;i<w.datasize();i++){
+		data2[i]=test1[i][0];
+	}
+
+//Preapation format final
+	w.setAudioFormat(1);
+	w.setNbrChanel(1);
+	w.setFrequency(FREQ);
+	w.setBytePerBloc(4);
+	w.setBytePerSec(FREQ);
+	w.setBitsPerSample(8);
+	w.clearData();
+	
+	w.setDatasize(w.datasize());
+	w.setData(data2);
+	w.save("strechcow.WAV");
+
+}
 \ No newline at end of file
@@ -0,0 +1,269 @@
+#include "wavdata.h"
+#include <iostream>
+
+
+using namespace std;
+
+WavData::WavData()
+{
+	_data=NULL;
+}
+
+int WavData::error(int i,int line)
+{
+	std::cerr << "Erreur "<<__FILE__<<" L"<<line<< ": ";
+	switch(i)
+	{
+	case -1: std::cerr << "ouverture du fichier";
+		break;
+	case -2: std::cerr << "le fichier n'est pas au format WAVE";
+		break;
+	default: std::cerr << "inconnue";
+		break;
+	}
+
+	std::cerr << "\n";
+	return i;
+}
+
+unsigned int WavData::fromLittleEndian(char * content, int size)
+{
+	unsigned int result = 0;
+	for(int i=size;i>=0;i--)
+	{
+		result *= 256;
+		result += (unsigned char)content[i];
+	}
+	return result;
+}
+
+char * WavData::toLittleEndian(unsigned int content, int size)
+{
+	char * result= new char [size*sizeof(char)];
+
+	for(int i=0;i<size;i++)
+	{
+		result += (char)(content%256);
+		content >>= 8;
+	}
+
+	return result;
+}
+
+void WavData::toLittleEndian(char* result,unsigned int content, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		result[i] = (char)(content%256);
+		content >>= 8;
+	}
+
+	return;
+}
+
+char * WavData::read(ifstream* file,unsigned int size)
+{
+	char * c = new char[size+1];
+	for(int i=0;i<size;i++)
+	{
+		c[i] = file->get();
+	}
+	c[size]='\0';
+	return c;
+}
+
+bool WavData::comp(char* c1, char *c2, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		if(c1[i]!=c2[i])return false;
+	}
+	return true;
+}
+
+int WavData::testString(ifstream* file,char*compstr,int size,char *mess)
+{
+	char * content = read(file,size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<< content << std::endl << "|"<<std::endl;
+	if(!comp(content,compstr,size))return error(-2,__LINE__);
+	
+	delete[] content;
+	return 1;
+}
+
+int WavData::testInt(ifstream* file,int size,char *mess,unsigned int *val)
+{
+	int test;
+	char * content = read(file,size);
+	
+	int value=fromLittleEndian(content, size);
+	std::cout << "| "<< mess << std::endl<<"|    ->"<<value << std::endl<<"|" <<std::endl;
+	if(val!=NULL)*val=value;
+	delete[] content;
+	return 1;
+}
+
+int WavData::openFormatBloc(ifstream* file)
+{
+	std::cout << "[Bloc de declaration d'un fichier au format WAVE]"<<std::endl<<"|"<<std::endl;
+
+	//  FileTypeBlocId
+	int r;
+	r = testString(file,"RIFF",4,	"FileTypeBlocID  (4 octets) : Constante 'RIFF'");
+	if(r<=0)return r;
+	
+	//  FileSize
+	r = testInt(file,4,				"FileSize        (4 octets) : Taille du fichier moins 8 octets");
+	if(r<=0)return r;
+	
+	//  FileFormatID
+	r = testString(file,"WAVE",4,	"FileFormatID    (4 octets) : Format = 'WAVE'");
+	if(r<=0)return r;
+	
+	std::cout << std::endl;
+	return 1;
+}
+
+int WavData::openDescriptionBloc(ifstream* file)
+{
+	std::cout << "[Bloc decrivant le format audio]"<<std::endl<<"|"<<std::endl;
+	
+	int r;
+
+	//  FormatBlocID
+	r = testString(file,"fmt ",4, "FormatBlocID    (4 octets) : Identifiant 'fmt'");
+	if(r<=0)return r;
+
+	//  BlocSize
+	r = testInt(file,4,"BlocSize        (4 octets) : Nombre d'octets du bloc - 8 (attendue: 16)");
+	if(r<=0)return r;
+	
+	//  AudioFormat
+	r = testInt(file,2,"AudioFormat     (2 octets) : Format du stockage dans le fichier (1: PCM, ...)",&_audioFormat);
+	if(r<=0)return r;
+	
+	//  NbrCanaux
+	r = testInt(file,2,"NbrCanaux       (2 octets) : Nombre de canaux (de 1 a 6)",&_nbrChanel);
+	if(r<=0)return r;
+	
+	//  Frequency
+	r = testInt(file,4,"Frequence       (4 octets) : Frequence d'echantillonnage (en Hertz)",&_frequency);
+	if(r<=0)return r;
+	
+	//  BytePerSec
+	r = testInt(file,4,"BytePerSec      (4 octets) : Nombre d'octets a lire par seconde",&_bytePerSec);
+	if(r<=0)return r;
+	
+	//   BytePerBloc
+	r = testInt(file,2,"BytePerBloc     (2 octets) : Nombre d'octets par bloc d'echantillonnage",&_bytePerBloc);
+	if(r<=0)return r;
+	
+	//   BitsPerSample
+	r = testInt(file,2,"BitsPerSample   (2 octets) : Nombre de bits pour le codage d'un echantillon",&_bitsPerSample);
+	if(r<=0)return r;
+
+	return 1;
+}
+
+int WavData::openDataBloc(ifstream* file)
+{
+	std::cout << "[Bloc des donnees]\n";
+	
+	int r,test;
+	//  DataBlocID
+	r = testString(file,"data",4,"DataBlocID      (4 octets) : Constante 'data'");
+	if(r<=0)return r;
+	
+	//  DataSize
+	r = testInt(file,3,"DataSize        (4 octets) : Nombre d'octets des donnees",&_datasize);
+	if(r<=0)return r;
+	
+	//  Data[];
+	std::cout << "| Data[] : [Octets du Sample 1 du Canal 1] [Octets du Sample 1 du Canal 2] [Octets du Sample 2 du Canal 1] [Octets du Sample 2 du Canal 2]\n\n";
+	if(_data!=NULL)delete[] _data;
+	_data = read(file,_datasize);
+	
+	return 1;
+}
+
+int WavData::load(char * s)
+{
+	std::cout << "Load file: \"" << s << "\""<<std::endl<<std::endl;
+
+	ifstream file(s, ios::in | ios::binary );
+	if (!file)return error(-1,__LINE__);
+
+	if(openFormatBloc(&file)		!= 1)	{file.close(); return 0;}
+	if(openDescriptionBloc(&file)	!= 1)	{file.close(); return 0;}
+	if(openDataBloc(&file)			!= 1)	{file.close(); return 0;}
+	
+	std::cout << "close file"<< std::endl;
+	file.close();
+	std::cout << "file closed"<<std::endl;
+
+	return 1;
+}
+
+void WavData::write(ofstream *file,char* mess,unsigned int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		file->put(mess[i]);
+	}
+}
+
+int WavData::saveFormatBloc(ofstream* file)
+{
+	char b[13] = "RIFF    WAVE";
+	
+	toLittleEndian(b+4,_datasize+36,4);
+	
+	write(file,b,12);
+	
+	return 1;
+}
+
+int WavData::saveDescriptionBloc(ofstream* file)
+{
+	char b[25] = "fmt                     ";
+	
+	toLittleEndian(b+4,0x10,4);
+	std::cout<<_audioFormat<<std::endl;
+	toLittleEndian(b+8,_audioFormat,2);
+	toLittleEndian(b+10,_nbrChanel,2);
+	toLittleEndian(b+12,_frequency,4);
+	toLittleEndian(b+16,_bytePerSec,4);
+	toLittleEndian(b+20,_bytePerBloc,2);
+	toLittleEndian(b+22,_bitsPerSample,2);
+	
+	write(file,b,24);
+	
+	return 1;
+}
+int WavData::saveDataBloc(ofstream* file)
+{
+	char b[9] = "data    ";
+	toLittleEndian(b+4,_datasize,4);
+	
+	write(file,b,8);
+	
+	write(file,_data,_datasize);
+	
+	return 1;
+}
+
+int WavData::save(char * s)
+{
+	std::cout << "Save file: \"" << s << "\"\n\n";
+
+	ofstream file(s, ios::out | ios::trunc | ios::binary);
+	if (!file)return error(-1,__LINE__);
+
+	saveFormatBloc(&file);
+	saveDescriptionBloc(&file);
+	saveDataBloc(&file);
+
+	file.close();
+
+	return 1;
+}
@@ -0,0 +1,66 @@
+#ifndef WAVDATA_H
+#define WAVDATA_H
+
+#include <iostream>
+#include <fstream>
+
+class WavData
+{
+	unsigned int _audioFormat;
+	unsigned int _nbrChanel;
+	unsigned int _frequency;
+	unsigned int _bytePerBloc;
+	unsigned int _bytePerSec;
+	unsigned int _bitsPerSample;
+
+	char * _data;
+	unsigned int _datasize;
+public:
+	WavData();
+
+	int load(char* s);
+	int save(char* s);
+
+	unsigned int fromLittleEndian(char * content, int size);
+	char * toLittleEndian(unsigned int content, int size);
+	void toLittleEndian(char* result,unsigned int content, int size);
+
+	inline unsigned int audioFormat(){return _audioFormat;}
+	inline unsigned int nbrChanel(){return _nbrChanel;}
+	inline unsigned int frequency(){return _frequency;}
+	inline unsigned int bytePerBloc(){return _bytePerBloc;}
+	inline unsigned int bytePerSec(){return _bytePerSec;}
+	inline unsigned int bitsPerSample(){return _bitsPerSample;}
+	inline unsigned int datasize(){return _datasize;}
+	inline char * data(){return _data;}
+
+	inline void setAudioFormat(unsigned int a){_audioFormat=a;}
+	inline void setNbrChanel(unsigned int a){_nbrChanel=a;}
+	inline void setFrequency(unsigned int a){_frequency=a;}
+	inline void setBytePerBloc(unsigned int a){_bytePerBloc=a;}
+	inline void setBytePerSec(unsigned int a){_bytePerSec=a;}
+	inline void setBitsPerSample(unsigned int a){_bitsPerSample=a;}
+	inline void setData(char * a){_data=a;}
+	inline void clearData(){delete[] _data;_data=NULL;}
+	inline void setDatasize(unsigned int i){_datasize=i;}
+	
+private:
+	int error(int,int);
+	int openFormatBloc(std::ifstream* file);
+	int openDescriptionBloc(std::ifstream *file);
+	int openDataBloc(std::ifstream *file);
+
+	int saveFormatBloc(std::ofstream *file);
+	int saveDescriptionBloc(std::ofstream *file);
+	int saveDataBloc(std::ofstream *file);
+	
+	void write(std::ofstream *file,char* mess,unsigned int size);
+	char * read(std::ifstream* file,unsigned int size);
+	
+	bool comp(char* c1, char *c2, int size);
+	int testString(std::ifstream* file,char*compstr,int size,char *mess);
+	int testInt(std::ifstream* file,int size,char *mess,unsigned int *val=NULL);
+
+};
+
+#endif // WAVDATA_H
@@ -1,107 +0,0 @@
-#include <iostream>
-#include "wavdata.h"
-#include "fft.h"
-#include <math.h>
-
-#define FREQ 48000
-#define AMPLITUDE 10
-#define FREQDO 261
-#define FREQLA	440
-#define SIZE FREQ*1
-
-
-int main(int argc, char **argv)
-{
-	WavData w;
-    int pi=3.14;
-	char *data = new char[SIZE];
-	
-
-	WavData w1;
-	w1.load("COW.WAV");
-	char *dat = w1.data();
-
-	int i;
-	for(i=0;i<SIZE;i++){
-		data[i]=AMPLITUDE*(sin(FREQLA*pi*2*i)+1);
-    }
-	
-	w.setAudioFormat(1);
-	w.setNbrChanel(1);
-	w.setFrequency(FREQ);
-	w.setBytePerBloc(4);
-	w.setBytePerSec(FREQ);
-	w.setBitsPerSample(8);
-	w.clearData();
-	w.setDatasize(SIZE);
-	w.setData(data);
-	w.save("pur.WAV");
-
-//----------------------------------------------------------------------------------------------//
-
-	double test[SIZE][2];
-	double test1[SIZE][2];
-	double test2[SIZE][2];
-	double test3[SIZE*2][2];
-	double test4[SIZE][2];
-
-	for(i=0;i<SIZE;i++){
-		test[i][0]=AMPLITUDE*(sin(FREQLA*pi*2*i)+1);
-		test[i][1]=0;
-    }
-
-	fft(512,test,test2);
-
-	for(i=0;i<SIZE;i++){
-		test3[i*2][0]=test2[i][0];
-		test3[(i*2)+1][0]=test2[i][0];
-		test3[i][1]=0;
-	}
-
-
-	ifft(512,test1,test3);
-
-	char *data2 = new char[SIZE*2];
-	for(i=0;i<SIZE*2;i++){
-		data2[i]=test1[i][0];
-	}
-
-	w.clearData();
-	w.setDatasize(SIZE*2);
-	w.setData(data2);
-	w.save("test.WAV");
-
-//----------------------------------------------------------------------------------------------//
-
-	double test11[SIZE][2];
-	char *data22 = new char[SIZE];
-
-	for(i=0;i<SIZE;i++){
-		test4[i][0]=test2[i][0];
-		test4[i][1]=0;
-		printf("%d ",test1[i][0]);
-	}
-
-	ifft(512,test11,test4);
-
-	for(i=0;i<SIZE;i++){
-		data22[i]=test11[i][0];
-	}
-
-	w.clearData();
-	w.setDatasize(SIZE);
-	w.setData(data22);
-	w.save("test2.WAV");
-}	
-
-/*
-	for(i=0;i<w.datasize();i++){
-		printf("%d ",data[i]);
-		}
-	printf("\n\n");
-
-	for(i=0;i<100;i++){
-		
-		printf("%f %f i=%d, ",test2[i][1],test2[i][2],i);
-
-    }*/
 \ No newline at end of file
@@ -1,12 +0,0 @@
-######################################################################
-# Automatically generated by qmake (2.01a) lun. mai 9 11:16:11 2011
-######################################################################
-
-TEMPLATE = app
-TARGET = 
-DEPENDPATH += .
-INCLUDEPATH += .
-
-# Input
-HEADERS += fft.h wavdata.h
-SOURCES += fft.cpp main.cpp wavdata.cpp