Discussion :

[daheda]

Bonjour à tous et à toute.
bon voilà je suis sur un projet de reconnaissance vocal dont le principe est le suivant:
je capture le son
je le traite (RNA)
puis je l'enregistre.
mais là je sui bloqué sur l'enregistrement...
j'arrive à capturer le signal mais je sais pas comment l'enregistré à noter que j'utilise API pour la capture.
ma question est donc:
Comment enregistrer le signal à partir d'une Fonction API (ou bien enregistrer les Buffer sous forme de stream ou autre) ?
merci de votre réponse
Cordiallement.

[henderson]

Salut !

Enregistrer : en mémoire ou dans un *.WAV ?

A plus !

[henderson]

Salut !

Il existe un site dédié au formatage des fichiers : WOTSIT.

S'il s'agit de mémoriser un *.WAV tout simple, dans ce cas, le fichier se décompose en deux blocs :
- le header qui ne fera que 44 octets
- les échantillons qui sont stockés à la suite du header.

Pour le header, voici une classe qui permet d'intitialiser certaines propriétés (champs du header en FourCC)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class TFileWaveHeader
{
public :
char RiffID[4];		         // "RIFF"
int Riffsize;		         // Size of File - 8
char WaveID[4];		         // "WAVE"
char FmtID [4];		         // "fmt "
unsigned int Formatsize;         // 16
 
// On retrouve ici les paramètres du WAVEFORMATEX
unsigned short FormatTag;	 // WAVE_FORMAT_PCM
unsigned short Channels;
unsigned int SamplesPerSec;
unsigned int AvgBytesPerSec;
unsigned short BlockAlign;
unsigned short BitsPerSample;
 
char DataID[4];		         // "data"
unsigned int DataSize;		 // taille de ce qui suit : les échantillons
 
    void __fastcall Init(int L);
 
};

La méthode pour initialiser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
/*********************************************
la taille (en octets) du bloc des échantillons
est passé à l'aide du paramètre int L
*********************************************/
 
void __fastcall TFileWaveHeader::Init(int L)
{
RiffID[0] = 'R';
RiffID[1] = 'I';
RiffID[2] = 'F';
RiffID[3] = 'F';
 
//Riffsize est la longueur totale du fichier WAV - 8 octets.
//Comme le paramètre L est la taille du bloc des échantillons
//On calcule donc simplement :
Riffsize = L + 36; // 36 = taille du header (44) - 8
 
WaveID[0] = 'W';
WaveID[1] = 'A';
WaveID[2] = 'V';
WaveID[3] = 'E';
 
FmtID[0] = 'f';
FmtID[1] = 'm';
FmtID[2] = 't';
FmtID[3] = ' ';
 
Formatsize = 16; //longueur du bloc des informations du format
 
/*
Le format est sans doute identique à celui de l'enregistrement donc...
Il suffit de récupèrer les valeurs du WAVEFORMATEX ou alors en calculer
d'autres qui seront prises en compte pour la lecture ultérieure
Donc on suppose que les échantillons seront conformes aux paramètres...
*/
 
/*
FormatTag = WAVE_FORMAT_PCM;
Channels = ?
SamplesPerSec = ?
AvgBytesPerSec = ?
BlockAlign = ?
BitsPerSample = ?
*/
 
DataID[0] = 'd';
DataID[1] = 'a';
DataID[2] = 't';
DataID[3] = 'a';
 
//La taille du bloc des échantillons
DataSize = L;
}

Donc on commence par enregistrer le header (44 octets) puis on enregistre à la suite les blocs audio (ça dépend comment on aura procédé pour la saisie)

A plus !

[daheda]

Merci Henderson,
je vais jeter un coup d'oeil sur ce que tu m'as filé et je te met au courant de mon évoultion...
@++
Bon dev

[daheda]

Merci pour le code Henderson mais bon là je sais pa trop comment l'utiliser??
pour te montrer voila le code de la capture du son:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
void Capture_Audio()
   {
   unsigned long i = 0;
   while (i< ((PWAVEHDR) Msg.LParam)->dwBytesRecorded)
      {
      short  m1,m2,m;
      short* signal = (short*)&((PWAVEHDR)Msg.LParam)->lpData[i];
      i += L_Frame_16k * sizeof(short);
      m1 = 0;
      m2 = 0;
      for (short j =0; j <   L_Frame_16k; j++) 
         {
         m =  signal[j];
         if ( m > 0 )
            m1 = max(m1, m);
         else
            m2 = min(m2, m);
         }
      CGauge1->Progress      =      max( m1,-m2)*scale;
      Series1->Delete(0);
      if ( m1+m2 >=0)
         Series1->AddXY((++ilp)*_20_msec,m1*scale);
      else
         Series1->AddXY((++ilp)*_20_msec,m2*scale);
      }
   i = waveInAddBuffer(h_WaveIn, (PWAVEHDR) Msg.LParam, sizeof(WAVEHDR));
 
   if ( i != 0 )
      ShowMessage("Error_Audio_Capture " + IntToStr(i) );
   }

et je le met où ton _init ou quoi?

merci et bon dev @++
Cordialement

[daheda]

bon je me suis creuser la tete sur ton code et voila j'ai un peu compris le truc (j'espère )
et j'ai Ajouté dans void Init(int L)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
FormatTag = WAVE_FORMAT_PCM;
Channels = Form1->waveform.nChannels;
SamplesPerSec = Form1->waveform.nSamplesPerSec;
AvgBytesPerSec = Form1->waveform.nAvgBytesPerSec;
BlockAlign = Form1->waveform.nBlockAlign;
BitsPerSample = Form1->waveform.wBitsPerSample;

mais là en siute que faire?
et j'ai pensé utiliser Fstream que je fais comme ci après :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
ofstream output("SOUND.WAV", ios::out | ios::binary);

et ou est ce que j'écris les restes?
c'est à dire : le header et le bloc ("RIFF" et "WAVE" et le signal proprement dit)

[henderson]

Salut !

Je ne comprend pas ton code.
Normalement, pour chaque buffer on devrait avoir la séquence :

initialisation du WAVEHDR
waveInPrepareHeader
waveInAddBuffer
waveInUnprepareHeader

Par ailleurs, ne faut-il pas travailler au minimum avec deux buffers : pendant que l'un est en service (l'enregistrement audio) l'autre est disponible pour le traitement (enregistrement du fichier etc...).
Pour info, compte tenu de ma machine, j'utilise 4 buffers en évitant tout graphisme surtout si j'enregistre en 44,1 KHz, stéréo et 16 bits !

On peut envisager deux façons de faire.
a) soit l'enregistrement dure un temps connu à l'avance.
Dans ce cas, on peut avoir alloué de la mémoire suffisante pour la totalité du fichier : header + échantillons.
L'enregistrement du fichier peut être effectué à la fin de la saisie, d'un coup d'un seul.

b) soit on ne connait pas la durée finale pour laquelle correspond une certaine quantité d'octets qui sert à initialiser certaines valeurs du header du fichier.
Dans ce cas, on commence par enregistrer le header (qui à ce stade n'est que partiellement initialisé), ou 44 octets vides.
Les blocks sont alloués et enregistrés à la suite au fur et à mesure des besoins (tant que l'on enregistre), en n'oubliant pas de comptabiliser le nombre d'octets.
On peut très bien se servir des mêmes blocs (WAVEHDR + buffer) à condition de respecter la séquence mentionnée au début.
Lorsque l'enregistrement audio est terminé, on connait le nombre exact d'octets utilisés et on effectue l'initialisation du header que l'on enregistre en revenant bien sûr au début du fichier.

J'utilise, pour le fichier : fopen, fwrite, fseek et fclose !

A plus !

[daheda]

salut!

On peut envisager deux façons de faire.
a) soit l'enregistrement dure un temps connu à l'avance.
Dans ce cas, on peut avoir alloué de la mémoire suffisante pour la totalité du fichier : header + échantillons.
L'enregistrement du fichier peut être effectué à la fin de la saisie, d'un coup d'un seul.

b) soit on ne connait pas la durée finale pour laquelle correspond une certaine quantité d'octets qui sert à initialiser certaines valeurs du header du fichier.
Dans ce cas, on commence par enregistrer le header (qui à ce stade n'est que partiellement initialisé), ou 44 octets vides.
Les blocks sont alloués et enregistrés à la suite au fur et à mesure des besoins (tant que l'on enregistre), en n'oubliant pas de comptabiliser le nombre d'octets.
On peut très bien se servir des mêmes blocs (WAVEHDR + buffer) à condition de respecter la séquence mentionnée au début.
Lorsque l'enregistrement audio est terminé, on connait le nombre exact d'octets utilisés et on effectue l'initialisation du header que l'on enregistre en revenant bien sûr au début du fichier.

ce que je veux faire c'est d'enregistrer sans savoir la durée finale (b) et c'est là qui me pose problème. Donc j'ai supposer un enregistrement d'un total de 10 secondes. mais là aussi je n'arrive à enregistrer que sur les 20 milliseconde d'échantillonnage et ça me sort un bruit auquel je m'y attendais pas... je procède ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
void TForm1::Capure_Audio(TMessage &Msg)
{
        unsigned long i = 0;
        double * lhs;
        double tmp;
        short sval;
        long n;
                // open file
        ofstream output("SOUND.WAV", ios::out | ios::binary);
                // RIFF chunk
        output.write("RIFF",4);
        n = (_16Bits/8);
        n *= Mono*10*Form1->waveform.nSamplesPerSec;
        n += 44 - 8;
        output.write((char *)&n,4);
        output.write("WAVE",4);
                // FORMAT chunk
        output.write("fmt ",4);
        n = 16;
        output.write((char *)&n,4);
        n = 1;
        output.write((char *)&n,2);
        n = Mono;
        output.write((char *)&n,2);
        n = Form1->waveform.nSamplesPerSec;
        output.write((char *)&n,4);
        n = (_16Bits/8)*Mono*Form1->waveform.nSamplesPerSec;
        output.write((char *)&n,4);
        n = (_16Bits/8)*Mono;
        output.write((char *)&n,2);
        n = _16Bits;
        output.write((char *)&n,2);
        // DATA chunk
        output.write("data",4);
        n = (_16Bits/8);
        n *= Mono*10*Form1->waveform.nSamplesPerSec;
        output.write((char *)&n,4);
        lhs=new double[10*Form1->waveform.nSamplesPerSec];
	while (i< ((PWAVEHDR) Msg.LParam)->dwBytesRecorded)
	{
		short  m1,m2,m;
		short* signal = (short*)&((PWAVEHDR)Msg.LParam)->lpData[i];
		i += L_Frame_16k * sizeof(short);
		m1 = 0;
		m2 = 0;
		for (short j =0; j <   L_Frame_16k; j++) // 320 data 16k => 20 ms
		{
			m =  signal[j];
//normalement lhs est censé contenir les son que j'ai capturé mais je sais pas quoi mettre
                        lhs[j] = ?
/*juste pour le représentation dans le TChart genre Oscilloscope*/
                        if ( m > 0 )
				m1 = max(m1, m);
			else
				m2 = min(m2, m);
		}
		CGauge1->Progress      =      max( m1,-m2)*scale;
	       	if ((CGauge1->Progress >=10 ))
		{      Series1->Delete(0);
			if ( m1+m2 >=0)
			{
				Series1->AddXY((++ilp)*_20_msec,m1*scale);
/*j'ai mis les valeurs des points du TSeries dans le memo par nombre d'enregistrement=3*/
                                if (nb_Rec==0)
		       	        Memo1->Lines->Add(m1*scale);
                                if (nb_Rec==1)
		       	        Memo2->Lines->Add(m1*scale);
                                if (nb_Rec==2)
		       	        Memo3->Lines->Add(m1*scale);
			}
			else
			{
				Series1->AddXY((++ilp)*_20_msec,m2*scale);
                                if (nb_Rec==0)
		       	        Memo1->Lines->Add(m2*scale);
                                if (nb_Rec==1)
		       	        Memo2->Lines->Add(m2*scale);
                                if (nb_Rec==2)
		       	        Memo3->Lines->Add(m2*scale);
			}
                }
		}
		i = waveInAddBuffer(h_WaveIn, (PWAVEHDR) Msg.LParam, sizeof(WAVEHDR));
		if ( i != 0 )
			ShowMessage("Error_Audio_Capture " + IntToStr(i) );
        //censé entrer les données dans le fichier SOUND.VAW mais ... :(
        for (i = 0; i < 10*Form1->waveform.nSamplesPerSec; i++)
                {
	tmp = lhs[i];
	sval = short ( short(tmp)  *32767/100);
	output.write((char *)&sval,(_16Bits/8));
                }
          output.close();
	}

Mono =1
Form1-> waveform.nSamplesPerSec = 16000 Hz;
Après ça je dois encrore m'attaquer au RNA...
ya pas d'autre moyen de faire une reconnaissance vocal?
je suis sur le point d'abandonner

[henderson]

Salut !

Pour la reconnaissance vocale, je n'ai pas d'idée mais par contre pour la saisie et l'enregistrement simultanés voici quelques rappels :

Le système a besoin d'être approvisionné en buffers sans perte de temps : dès qu'il retourne un buffer rempli, le buffer suivant est déjà en cours de remplissage !
C'est pour cette raison que l'on travaille au minimum avec deux buffers.
A titre perso, par sécurité, j'utilise quatre buffers à cause de ma machine, ce qui reste vrai aussi pour d'autres machines bien plus performantes.

Le système ne supporte aucune erreur de configuration, donc il faut prendre soin de n'utiliser que les fréquences d'échantillonnage supportées par le dispositif.
On y reviendra sans doute plus tard (j'ai du code allant dans ce sens) mais voici comment je m'y prends (peut-être qu'il y a mieux...) :

En global :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
char Textbuffer[256];
bool Record = false;
 
//Par défaut je travaille en 44.1 KHz, stéréo et 16 bits 
WAVEFORMATEX pcmWaveFormat = {WAVE_FORMAT_PCM,
                                2,
                                44100L,
                                176400L,
                                4,
                                16};
 
HWAVEIN HWaveIn;
WAVEINCAPS WaveInCaps;
UINT NbWaveInDevices;
UINT WaveInDevice;
 
int Block;
WAVEHDR Headers[4];
Byte Buffers[4][8192];
 
TFileWaveHeader FWH; // << header du fichier
AnsiString Filename; // nom complet du fichier
FILE *Temp; // donc fopen, fwrite, fseek, fclose
int TotalBytes; // ce qui aura été enregistré

Les méthodes qui vont suivre sont à déclarer dans la classe de la form.
La méthode principale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
void __fastcall TForm1::Recording()
{
int Error;
int le;
TotalBytes=0;
Block = 0;
Temp = fopen(Filename.c_str(), "w+b");
if(Temp == NULL)
    {
    Application->MessageBox("Impossible d'ouvir le fichier",
                            "Erreur fichier",
                            MB_OK + MB_ICONERROR);
    return;
    }
 
Error = OpenWaveIn(&pcmWaveFormat);
if(Error != MMSYSERR_NOERROR)
    {
    ShowWaveInError(Error);
    fclose(Temp);
    return;
    }
 
//Ecriture du header à vide
FWH.Init(0);
fwrite(&FWH, 44, 1, Temp);
 
//On ajoute 4 blocs pour démarrer la saisie
AddBlock();
AddBlock();
AddBlock();
AddBlock();
 
//On commence
waveInStart(HWaveIn);
 
while(Record)
    {
    while((Headers[Block].dwFlags & WHDR_DONE) == 0)
        {
        //Pour pouvoir agir sur le flag Record... 
        Application->ProcessMessages();
        }
    le = Headers[Block].dwBytesRecorded;
    waveInUnprepareHeader(HWaveIn, &Headers[Block], sizeof(WAVEHDR));
    // Enregistrement du bloc
    fwrite(Headers[Block].lpData, le, 1, Temp);
    TotalBytes = TotalBytes + le;
    //Echo dans un panel
    //Donc ... si on a du temps pour le reste...
    TotalBytes1->Caption = IntToStr(TotalBytes);
    Error = AddBlock();
    }
// fin de la saisie et de l'enregistrement
waveInStop(HWaveIn);
// Maintenant on connait la taille
FWH.Init(TotalBytes);
//On revient au début du fichier
fseek(Temp, 0, SEEK_SET);
// On enregistre le header
fwrite(&FWH, 44, 1, Temp);
fclose(Temp);
// On libère les headers
waveInUnprepareHeader(HWaveIn, &Headers[0], sizeof(WAVEHDR));
waveInUnprepareHeader(HWaveIn, &Headers[1], sizeof(WAVEHDR));
waveInUnprepareHeader(HWaveIn, &Headers[2], sizeof(WAVEHDR));
waveInUnprepareHeader(HWaveIn, &Headers[3], sizeof(WAVEHDR));
// Fermeture du dispositif
waveInReset(HWaveIn);
waveInClose(HWaveIn);
}

Voici maintenant les méthodes qui sont sollicitées par la méthode principale :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
bool __fastcall TForm1::OpenWaveIn(WAVEFORMATEX *F)
{
return waveInOpen((LPHWAVEIN)&HWaveIn, WaveInDevice, F, NULL, NULL, NULL);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
int __fastcall TForm1::AddBlock()
{
int Error;
Headers[Block].lpData = (LPSTR)&Buffers[Block][0];
Headers[Block].dwBufferLength = 8192;
Headers[Block].dwBytesRecorded = 0;
Headers[Block].dwUser = 0;
Headers[Block].dwFlags = 0;
Headers[Block].dwLoops = 0;
Error = waveInPrepareHeader(HWaveIn, &Headers[Block], sizeof(WAVEHDR));
if(Error == MMSYSERR_NOERROR)
    {
    Error = waveInAddBuffer(HWaveIn, &Headers[Block], sizeof(WAVEHDR));
    if(Error == MMSYSERR_NOERROR)
        {
        Block = (Block + 1) & 3; // modulo 4 -> tableau circulaire
        }
    }
return(Error);
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
void __fastcall TForm1::ShowWaveInError(int E)
{
waveInGetErrorText(E,(LPSTR)Textbuffer,256);
Application->MessageBox(Textbuffer, "Erreur MIDI", MB_OK);
}

A plus !

[daheda]

salut!
Merci pour le code, je vais tenter de comprendre...
Qu'est ce que je ferais sans DEVELOPPEZ
Merci.
A plus!