Initial commit

eishchuk
Showing 16 changed files with 549 additions and 0 deletions Show diff stats
.main.cpp.swp
COW.WAV
COW_d.WAV
DO.WAV
Makefile
fft.cpp
fft.h
fft.o
main.cpp
main.o
task.txt
test
testWAV.pro
wavdata.cpp
wavdata.h
wavdata.o
+++ a/Makefile
@@ -0,0 +1,17 @@
+
+CC = g++
+FLAGS = -c
+OBJECTS = $(SOURDES:.cpp=.o)
+
+TARGET = clavier
+
+$(TARGET) : $(OBJECTS)
+
+all: $(TARGET)
+
+clean:
+	rm -f core *.o $(TARGET)
+
+
+
+
+++ a/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;
+	}
+}
+++ a/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
+++ a/main.cpp
@@ -0,0 +1,70 @@
+#include <iostream>
+#include "wavdata.h"
+#include "fft.h"
+#include <math.h>
+
+#define DELAY 5000
+#define TOUCH 15000
+#define AMPLITUDE 0.5
+
+int main(int argc, char **argv)
+{
+	/*WavData w;
+    char * name = "COW.WAV";
+	w.load(name);
+
+	char *data = w.data();
+	char *data2 = new char[w.datasize()*2];
+
+	int i;
+	for(i=0;i<w.datasize();i++)
+		data2[i]=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);
+
+    char * name_save = "COW_d.WAV";
+	w.save(name_save);*/
+    
+    
+    // recréer une note ) partir du son de la vache
+    
+    WavData note_do;
+    note_do.load("COW.WAV");
+    char * data_do = note_do.data();
+    
+    // TOUCH = durée d'une note
+    int size = note_do.datasize();
+    if (size > TOUCH) size = TOUCH;
+    
+    // changer le son pour avoir une note approprié
+    
+    int i;
+    for (i = 0; i < size ; i++) {
+        data_do[i] = i;
+    }
+    
+    // assign new data & save
+    
+    note_do.clearData();
+    note_do.setDatasize(size);
+    note_do.setData(data_do);
+    
+    note_do.save("DO.WAV");
+    
+    
+}
+++ a/task.txt
@@ -0,0 +1 @@
+Realiser un clavier de piano sur les touches pour avoir le son de vach pour chaque note musicale
+++ a/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
+++ a/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;
+}
+
+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::toLittleEndian(char* result,unsigned int content, int size)
+{
+	for(int i=0;i<size;i++)
+	{
+		result[i] = (char)(content%256);
+		content >>= 8;
+	}
+
+	return;
+}
+
+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;
+}
+++ a/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