diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json
new file mode 100644
index 0000000..3eb6ef5
--- /dev/null
+++ b/.vscode/c_cpp_properties.json
@@ -0,0 +1,20 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "C:\\Users\\simon\\OneDrive\\Bureau\\TP6son"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "cStandard": "c17",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "msvc-x64"
+        }
+    ],
+    "version": 4
+}
\ No newline at end of file
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 0000000..4656989
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,19 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "(Windows) Lancer",
+            "type": "cppvsdbg",
+            "request": "launch",
+            "program": "entrer le nom du programme, par exemple ${workspaceFolder}/a.exe",
+            "args": [],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false
+        }
+    ]
+}
\ No newline at end of file
diff --git a/COW.WAV b/COW.WAV
new file mode 100644
index 0000000..6cc4f52
Binary files /dev/null and b/COW.WAV differ
diff --git a/COW_d.WAV b/COW_d.WAV
new file mode 100644
index 0000000..bae44ad
Binary files /dev/null and b/COW_d.WAV differ
diff --git a/TP_TIM.pdf b/TP_TIM.pdf
new file mode 100644
index 0000000..bd2a77d
Binary files /dev/null and b/TP_TIM.pdf differ
diff --git a/com.WAV b/com.WAV
new file mode 100644
index 0000000..39d6f6f
Binary files /dev/null and b/com.WAV differ
diff --git a/cowfft.WAV b/cowfft.WAV
new file mode 100644
index 0000000..54a5d23
Binary files /dev/null and b/cowfft.WAV differ
diff --git a/fft.cpp b/fft.cpp
new file mode 100644
index 0000000..92567e1
--- /dev/null
+++ b/fft.cpp
@@ -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;
+	}
+}
diff --git a/fft.h b/fft.h
new file mode 100644
index 0000000..981e637
--- /dev/null
+++ b/fft.h
@@ -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
diff --git a/fftcow.cpp b/fftcow.cpp
new file mode 100644
index 0000000..d9c40c7
--- /dev/null
+++ b/fftcow.cpp
@@ -0,0 +1,57 @@
+#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*4
+
+
+int main(int argc, char **argv)
+{
+	float pi=3.141592;
+	WavData w;
+	
+	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));
+
+		test[i][0]=(double)data[i];
+		test[i][1]=(double)data[i];
+    }
+
+	fft(32768*2,test,test2);
+	
+	ifft(32768*2,test1,test2);
+
+	for(i=0;i<SIZE;i++){
+		data2[i]=test1[i][0];
+	}
+
+	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("cowfft.WAV");
+
+}
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
new file mode 100644
index 0000000..ddf865b
--- /dev/null
+++ b/main.cpp
@@ -0,0 +1,40 @@
+#include <iostream>
+#include "wavdata.h"
+#include "fft.h"
+#include <math.h>
+
+#define DELAY 5000
+#define AMPLITUDE 0.5
+
+int main(int argc, char **argv)
+{
+	WavData w;
+	w.load("COW.WAV");
+
+	char *data = w.data();
+	char *data2 = new char[w.datasize()*2];
+
+	int i;
+	for(i=0;i<w.datasize();i++){
+		data2[i]=data[i];
+		printf("%d ",data[i]);}
+	for(;i<w.datasize()*2;i++)
+		data2[i]=128;
+
+	for(int i=DELAY;i<2*w.datasize();i++)
+	{
+		float value = (float)(unsigned char)data2[i-DELAY]-128.0;
+		value = value * AMPLITUDE;
+		int val = (unsigned int)value + (unsigned char)data2[i];
+		if(val>255)val=255;
+		if(val<0)val=0;
+
+		data2[i]= (unsigned char)(unsigned int)val;
+	}
+
+	w.clearData();
+	w.setDatasize(w.datasize()*2);
+	w.setData(data2);
+
+	w.save("COW_d.WAV");
+}
diff --git a/modifreq.WAV b/modifreq.WAV
new file mode 100644
index 0000000..119a9b4
Binary files /dev/null and b/modifreq.WAV differ
diff --git a/modifreq.cpp b/modifreq.cpp
new file mode 100644
index 0000000..b18cb1f
--- /dev/null
+++ b/modifreq.cpp
@@ -0,0 +1,69 @@
+#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*4
+
+
+int main(int argc, char **argv)
+{
+//Definition variables
+    int i;
+	float pi=3.141592;
+    double test[SIZE][2];
+	double test1[SIZE][2];
+	double test2[SIZE][2];
+    double test3[SIZE*2][2];
+    char *data = new char[SIZE];
+	char *data2 = new char[SIZE];
+	WavData w;
+    
+//Creation de la donnée
+	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));
+
+		test[i][0]=(double)data[i];
+		test[i][1]=(double)data[i];
+    }
+
+//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]);
+		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
+
+	for(i=0;i<SIZE;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(SIZE);
+	w.setData(data2);
+	w.save("modifreq.WAV");
+
+}
\ No newline at end of file
diff --git a/pur.WAV b/pur.WAV
new file mode 100644
index 0000000..07f8a63
Binary files /dev/null and b/pur.WAV differ
diff --git a/pur.cpp b/pur.cpp
new file mode 100644
index 0000000..43d3230
--- /dev/null
+++ b/pur.cpp
@@ -0,0 +1,42 @@
+#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*10
+
+
+int main(int argc, char **argv)
+{
+	float pi=3.141592;
+	WavData w;
+	
+	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));
+    }
+
+	
+	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("purla.WAV");
+
+}
\ No newline at end of file
diff --git a/purfreq2.WAV b/purfreq2.WAV
new file mode 100644
index 0000000..39d6f6f
Binary files /dev/null and b/purfreq2.WAV differ
diff --git a/purla.WAV b/purla.WAV
new file mode 100644
index 0000000..fe67473
Binary files /dev/null and b/purla.WAV differ
diff --git a/readme b/readme
index e69de29..5d082e0 100644
--- a/readme
+++ b/readme
@@ -0,0 +1,15 @@
+Dans un premier temps, la description du fichier, puis le format audio, échantillonnage, fréquence et le boc de données
+Le code a pour but d’allonger la durée de l’audio. En ajoutant un effet délay à partir d’un moment de l’audio.
+On a fait un test avec la valeur 128 et pas de son en sortie du fichier
+
+
+Multiplier par 2 le temps
+Diviser
+1 echantillion devient 2
+Dans l’espace frequentielle
+FFT Deux dimensions, double le temps FFTinverse
+
+Son pur
+Dans cette partie, nous nous sommes basés sur la construction du fichier audio donné dans le main.cpp.
+C’est à dire que nous chargions le son cow afin de récupérer ses paramètres, puis en cherchant un peu nous avons trouvé les fonctions, dans le header de la bibliothèque, pour fixer les paramètres de notre format audio en sortie.
+Nous avons commencé à construire notre signal sinusoïdale à l’aide de la fonction sinus dans math.h et de notre fréquence
diff --git a/test b/test
new file mode 100644
index 0000000..fe9eae3
Binary files /dev/null and b/test differ
diff --git a/test.WAV b/test.WAV
new file mode 100644
index 0000000..a61f5de
Binary files /dev/null and b/test.WAV differ
diff --git a/test.cpp b/test.cpp
new file mode 100644
index 0000000..49f84db
--- /dev/null
+++ b/test.cpp
@@ -0,0 +1,107 @@
+#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
diff --git a/test2.WAV b/test2.WAV
new file mode 100644
index 0000000..652264d
Binary files /dev/null and b/test2.WAV differ
diff --git a/testWAV.pro b/testWAV.pro
new file mode 100644
index 0000000..d2d7879
--- /dev/null
+++ b/testWAV.pro
@@ -0,0 +1,12 @@
+######################################################################
+# 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
diff --git a/wavdata.cpp b/wavdata.cpp
new file mode 100644
index 0000000..71642a7
--- /dev/null
+++ b/wavdata.cpp
@@ -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;
+}
diff --git a/wavdata.h b/wavdata.h
new file mode 100644
index 0000000..24c9a2b
--- /dev/null
+++ b/wavdata.h
@@ -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
--
libgit2 0.21.2