Classe csound

Télécharger le projet
Commenter

Description

Une classe pour l'acquisition et le traitement du son

Traitements :
Acquisition, Fichiers Wave, Lecture, Mixage, Collage, Découpage, FFT...
Effets :
Echo, Réverbération, Chorus, Pitch, Voix codée...
Filtres :
Passe-bas, passe-bande, équalizer...

Source / Exemple : 


class CSound
{
	friend CSoundProcessing;

	static const int NB_BUFFER = 32;
	static const int TAILLE_BUFFER = 4096;

	//en-tête du fichier wave
	typedef struct WAVEHEADER
	{
		//identification du format (RIFF)
		char strFileType[4];
		//taille du fichier (taille du fichier - 8)
   		DWORD dwFileSize;
   		//type de fichier (Wave)
   		char strFileId[4];

   		//identification du chunk format (fmt )
   		char strChunkFmtId[4];
   		//taille du chunck format (16)
   		DWORD dwChunkFmtSize;
   		//format (1)
   		WORD wFormat;
   		//nombre de canaux (mono:1 ou stéréo:2)
   		WORD wNbChannels;
   		//fréquence d'échantillonnage (44,1 kHz)
   		DWORD dwSamplingFreq;
   		//nombre de bits par secondes (wDepth * wNbChannels / 8)
   		DWORD dwBytesPerSec;
   		//nombre de bits par échantillonnage (dwBytesPerSec * wDepth)
   		WORD wBytesPerSample;
   		//nombre de bits par échantillonnage (8 ou 16 bits)
   		WORD wDepth;
	};

    //handle sur la carte son (entrée)
    HWAVEIN m_hWaveIn;

	//flag d'acquisition
	BOOL m_bRecord;

    //structure Wave
    WAVEFORMATEX m_WaveFormat;

    //pour le formatage des données
	void Formate(const CTab<BYTE>& dataIn, CTab<short> dataOut[2]);
	void Unformate(CTab<short> dataIn[2], CTab<BYTE>& dataOut);

    //fontions callback pour l'acquisition
    friend void CALLBACK WaveInProc(HWAVEIN hWaveIn, UINT uMsg, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2);
	void AddData(const CTab<BYTE>& data);

	//buffers d'entrée
	WAVEHDR m_WaveInHeader[NB_BUFFER];
	BYTE m_pWaveInBuffer[NB_BUFFER * TAILLE_BUFFER];

	//données formatées du son
	CTab<short> m_Buffer[2];

	//lock du buffer
	CMutex m_Mutex;
	CSem m_Semaphore;

	//listener
	CSoundListener* m_pListener;

public :
    //constructeur et destructeur
    CSound(void);													//constructeur par défaut
    CSound(DWORD freq, WORD format, WORD nbChannel);				//constructeur avec arguments
    CSound(const CSound& Wave);										//constructeur de copie
    ~CSound(void);													//destructeur

	//listener
	void SetListener(CSoundListener* listener);

	//paramétrage
	void Reset();
	void SetFreq(DWORD freq);
	void SetFormat(WORD format);
	void SetNbChannels(WORD nbChannel);

	//acquisition
    BOOL StartRecord(void);
	BOOL StopRecord(void);
	BOOL InRecord(void) const;

	//lock/unlock
	void LockBuffer();
	void UnlockBuffer();

    //méthode de sauvegarde
    BOOL SaveToFile(const CStr& strNomFichier);
    
    //méthodes de restitution
    BOOL Play(void);
    BOOL PlayFile(const CStr& strNomFichier);
    
    //méthode d'ouverture fichier wave
    BOOL OpenFile(const CStr& strNomFichier);
    
    //méthode pour obtenir la durée d'un son (en secondes)
    float GetTime();
    
    //méthode d'information
    BOOL IsValid() const;
	DWORD GetFreq(void) const;
	WORD GetFormat(void) const;
	WORD GetNbChannels(void) const;
};

class CSoundProcessing
{
public:
	static const int TAILLE_FFT = 2048;

	//type enuméré pour les filtres fenêtrés
	enum TFiltre
	{
		FRect,
		FHanning,
		FHamming,
		FBlackman,
		FBartlett
	};

	//structure pour les bandes de fréquences
	typedef struct TBande
	{
		float fFreqBas;
		float fFreqHaut;
		float fCoef;
	}Bande;

private:
	CSound* m_pSound;

    //FFT et FFT inverse
    static UINT InverseBits(UINT uIndex, UINT uNbBits);
    static UINT GetNbBits(UINT uTaille);
    static BOOL FFT(UINT uTaille, BOOL bInverse, double* pfReIn, double* pfImIn, double* pfReOut, double* pfImOut);

public:
	CSoundProcessing(void);
	virtual ~CSoundProcessing(void);

	void SetSound(CSound* pSound);

    //méthode obtenir pour la FFT
    BOOL GetFFT(CTab<double> fTabFFT[2]);
    
    //méthodes d'effet
    BOOL Gain(float fGain);
    BOOL Echo(float fPeriode, float fAttenuation);
    BOOL Reverb(float fPeriode, float fAttenuation);
    BOOL CodeVoice(void);
    BOOL Pitch(float fPitch);
    BOOL Retard(float fRetard);
    BOOL Chorus(float fAttenuation);
    BOOL Tremolo(float fAmplitude, DWORD dwFreq);
    BOOL Disto(CTab<float>* pTabDisto = NULL);
    BOOL FadeIn(float fLowGain, float fHighGain);
    BOOL FadeOut(float fLowGain, float fHighGain);
	BOOL Inverse(void);

    //méthodes de traitement
    static CSound Mix(const CSound& snd1, const CSound& snd2);
    static CSound Colle(const CSound& snd1, const CSound& snd2);
    static CSound Coupe(const CSound& snd, float fDebut, float fFin);

    //fonction de filtrage (fenêtre)
    static BOOL Filtrage(CTab<double>& TabFFT, int filtre);
    
    //filtres
    BOOL PasseBas(float fGain, DWORD dwFc);
    BOOL PasseHaut(float fGain, DWORD dwFc);
    BOOL PasseBande(TBande tBandeFreq);
    BOOL Noise(void);
    BOOL Equalizer(const CTab<TBande>& TabBande);
};

class CSoundListener
{
public:
	CSoundListener(void);
	virtual ~CSoundListener(void);

	virtual void OnData(CTab<short> data[2]){};
};

Conclusion :


Encore beaucoup plus simple d'utilisation. N'hésitez pas à poser des questions si besoin est.
Un petit exemple d'utilisation suite à des demandes :

CSoundProcessing process;

CSound snd1;

//acquisition de 10 secondes
snd1.StartRecord();
Sleep(10000);
snd1.StopRecord();

//init process sur snd1
process.SetSound(&snd1);

//appliquer un écho toutes les 1s, diminuant de moitié
process.Echo(1.0, 2.0);

CSound snd2;

//ouvrir un fichier Wave
snd2.OpenFile("monfichier.wav");

//init process sur snd2
process.SetSound(&snd2);

//multiplier par deux les fréquences comprises entre 500Hz et 2kHz
CSoundProcessing::TBande bande;
bande.fCoef = 2.0;
bande.fFreqBas = 500;
bande.fFreqHaut = 2000;

process.PasseBande(bande);

//obtenir la FFT du signal
/*
Note :
mono : tabFFT[0] et tabFFT[1] sont identiques
stéréo : tabFFT[0] contient le canal gauche et tabFFT[1] le canal droit
  • /

CTab<double> tabFFT[2];
if(process.GetFFT(tabFFT))
{
int indexFreqMax = 0;
double max = 0.0;

//trouver la fréquence dominante (en amplitude)
for(int i=0;i<tabFFT[0].Size();i++)
{
if(tabFFT[0] > max)
{
max = tabFFT[0];
indexFreqMax = i;
}
}

//calcul de la fréquence correspondante
double freqMax = (double)(indexFreqMax * snd2.GetFreq() / CSoundProcessing::TAILLE_FFT);
}

//mixer avec le fichier wave
CSound snd3 = CSoundProcessing::Mix(snd1, snd2);

//si pas d'erreurs
if(snd3.IsValid())
{
//jouer le son
snd3.Play();

//sauvegarder dans un fichier wave 16 bits stéréo
snd3.SetFormat(16);
snd3.SetNbChannels(2);
snd3.SaveToFile("mix.wav");
}
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (bobbyantho)