premier push

rsimonin
1 parent 77461c77
Showing 25 changed files with 830 additions and 0 deletions Show diff stats
.vscode/c_cpp_properties.json
.vscode/launch.json
COW.WAV
COW_d.WAV
TP_TIM.pdf
com.WAV
cowfft.WAV
fft.cpp
fft.h
fftcow.cpp
main.cpp
modifreq.WAV
modifreq.cpp
pur.WAV
pur.cpp
purfreq2.WAV
purla.WAV
readme
test
test.WAV
@@ -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
@@ -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
@@ -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,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
@@ -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");
+}
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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