Classe csound

Soyez le premier à donner votre avis sur cette source.

Vue 20 042 fois - Téléchargée 11 909 fois

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");
}

Codes Sources

A voir également

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

Tu peux mexpliquer ?
Messages postés
4
Date d'inscription
vendredi 28 août 2009
Statut
Membre
Dernière intervention
11 mars 2010

bonjour,

Avec en partie ce bout de code, j'arrive à acquérir une image lorsqu'il y a un son émis.
Le problème est qu'à chaque nouvelle boucle le PC est de plus en plus lent. Je pense que snd1.Reset(); n'efface pas le tableau. Dois je utiliser ta fonction Formate et si oui peux tu m'aider à l'utiliser

Merci d'avance

while (!bQuit)
{
snd1.StartRecord();
Sleep(100);
snd1.StopRecord();
int maxAudio = snd1.GetMax();
snd1.Reset();
if ( maxAudio > 6000)
{
snd2.Play();
WebCam.SauvegardeBitmap(0);
}
}
Messages postés
4
Date d'inscription
jeudi 24 août 2006
Statut
Membre
Dernière intervention
11 mars 2010

pour - Avoir la taille du fichier en sample ou obtenir la frequence d'echantillonnage
j'ai ajouter des methodes

pour les données par contre je coince
Messages postés
4
Date d'inscription
jeudi 24 août 2006
Statut
Membre
Dernière intervention
11 mars 2010

Re Bonjour,

En fait j'ai plein de question, elles sont liées a mon manque de connaissance du c++
Comment je peux faire pour:
- Avoir la taille du fichier en sample ou obtenir la frequence d'echantillonnage
- Acceder directement au buffer et manipuler les samples comme bon me semble
- Avoir la phase directement, et la phase "unwrap"é :)
- Faire un filtrage (convolution mais en conservant la taille) avec ce que je veux comme filtre.

Merci et dsl si les questions sont betes
Messages postés
4
Date d'inscription
jeudi 24 août 2006
Statut
Membre
Dernière intervention
11 mars 2010

Bonjour

ouha tu es super rapide, effectivement, j'allais ecrire pour dire zut je suis trop bete oublie ma question et boom trop rapide pour moi tu avais deja repondu.

Merci pour tout
Afficher les 112 commentaires

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.