Discussion :

[Patrice Terrier]

Voici le prototype de la callback RECORDPROC en mode 32-bit

Code :

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

1
2
3
4
FUNCTION RecordProc(LOCAL hRecord is unsigned int, LOCAL lpVoidBuffer is unsigned int, LOCAL nLength is unsigned int, LOCAL lpVoidUser is unsigned int)
nRet is boolean = True
Code fWrite ici
RESULT nRet

Attention La version fWrite de WinDev ne marche pas comme celle de l'API.
Les éléments ajoutés ne sont pas insérés dans le fichier externe mais écrasent les éléments existants.

Je vous conseille d'utiliser les fonctions I/O de l'API directement, ou alors de recourir à la fonction fSeek, avant d'écrire dans le fichier.

[WDKyle]

Je ne vois pas de quoi vous parlez quand vous me dites d'utiliser les fonctions I/O de l'API... ?

Je vais regarder la fonction fSeek de Windev Merci

J'ai tenté ceci, mais sans grand résultat...

J'ai bien des données qui son crée au niveau du fichier mais cela reste illisible par un lecteur audio quelconque.

Code :

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

1
2
3
4
5
6
7
8
9
10
PROCEDURE Microphone_CallBack(LOCAL hRecord is unsigned int, LOCAL lpVoidBuffer is unsigned int, LOCAL nLength is unsigned int, LOCAL lpVoidUser is unsigned int)
 
nIDFichier est un entier
nIDFichier = fOuvre("C:\Users\Kyle\Documents\test.wav", foCréationSiInexistant+foAjout)
SI nIDFichier <> -1 ALORS
	fEcrit(nIDFichier, &lpVoidBuffer , nLength)
FIN
fFerme(nIDFichier)
 
RENVOYER Vrai

[OnePoint]

Bonjour tout le monde !

J'ai tenter ceci, mais sans grand résultat...

J'ai bien des données qui son crée au niveau du fichier mais cela reste illisible par un lecteur audio quelconque.

@WDKyle, la variable lpVoidBuffer contient déjà l'adresse des données. Utiliser l'opérateur & est donc une erreur.

Côté performances, si la procédure callback est appelée un grand nombre de fois, alors les performances seront plombées par tous les fOuvre et fFerme inutiles.
Disons que cette procédure vaut juste pour tester et qu'il est possible d'améliorer les choses.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
PROCEDURE Microphone_CallBack(LOCAL hRecord is unsigned int, LOCAL lpVoidBuffer is unsigned int, LOCAL nLength is unsigned int, LOCAL lpVoidUser is unsigned int)
 
nIDFichier est un entier
nIDFichier = fOuvre("C:\Users\Kyle\Documents\test.wav", foCréationSiInexistant+foAjout)
SI nIDFichier <> -1 ALORS
	fEcrit(nIDFichier, lpVoidBuffer , nLength)
FIN
fFerme(nIDFichier)
 
RENVOYER Vrai

Bonne continuation !

[Patrice Terrier]

La procédure callback doit SEULEMENT écrire le buffer, rien d'autre.

Il faut utiliser fSeek à chaque fois, avant de faire un fWrite, pour déplacer le pointeur d'écriture d'un offset équivalent à celui de la taille du buffer écrit précédemment.

http://doc.pcsoft.fr/en-US/?1000003036039


Vous pouvez utiliser également la constante fpEnd pour placer la position d'écriture directement à la fin du fichier

...

[OnePoint]

Bonjour Patrice,

Merci pour toutes tes contributions très intéressantes.

La procédure callback doit SEULEMENT écrire le buffer, rien d'autre.

Il faut utiliser fSeek à chaque fois, avant de faire un fWrite, pour déplacer le pointeur d'écriture d'un offset équivalent à celui de la taille du buffer écrit précédemment.

http://doc.pcsoft.fr/en-US/?1000003036039

...

Es-tu vraiment certain de ce que tu dis ?

Après exécution de la fonction fEcrit, la position en cours est modifiée.

http://doc.pcsoft.fr/fr-FR/?3036014

Position dans le fichier

A l'ouverture d'un fichier, la position en cours correspond :

- au premier octet du fichier (par défaut),
- au dernier octet du fichier si le fichier est ouvert en "ajout" (constante foAjout).

Cette position peut être modifiée par la fonction fPositionne.

La fonction fEcrit écrit les éléments spécifiés à partir de la position en cours. Après l'exécution de fEcrit, la position en cours correspond au dernier octet écrit.

[WDKyle]

J'ai corrigé le code avec vos conseils, le fichier final n'est toujours pas écoutable

Code :

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

1
2
3
4
5
6
7
 
PROCEDURE Microphone_CallBack(LOCAL hRecord is unsigned int, LOCAL lpVoidBuffer is unsigned int, LOCAL nLength is unsigned int, LOCAL lpVoidUser is unsigned int)
 
fPositionne(FEN_Cartouchier.nIDFichier, 0, fpFin)
fEcrit(FEN_Cartouchier.nIDFichier, lpVoidBuffer, nLength)
 
RENVOYER Vrai

EDIT : fPositionne(FEN_Cartouchier.nIDFichier, -1, fpFin) donne pas mieux

[Patrice Terrier]

Autant pour moi, je pense qu'il faut utiliser la constante
fpCourant car la position d'origine doit correspondre à la position en cours .

[WDKyle]

Autant pour moi, je pense qu'il faut utiliser la constante
fpCourant car la position d'origine doit correspondre à la position en cours .

J'ai essayé : fPositionne(FEN_Cartouchier.nIDFichier, -1, fpCourant) mais le fichier est toujours illisible.

[Patrice Terrier]

Je n'ai pas l'habitude de la syntaxe des fonctions WinDev E/S, car j'utilise toujours l'API bas niveau pour que mon code soit identique avec tous les langage que j'utilise.

Mais le principe est que le buffer doit être écrit à la suite, il faut donc soit travailler en mode ajout, soit utiliser fSeek pour se positionner correctement.

En ce qui concerne le fichier wav, il faut aussi qu'il comporte un header.

Voici le code que j'utilise dans ma DLL AudioCap (écrite en PowerBASIC) pour créer le fichier Wave :

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
FUNCTION CreateWaveFile(zAudioFile AS ASCIIZ) AS LONG
    LOCAL nRet AS LONG
    hmmioFile = mmioOpen(zAudioFile, BYVAL %NULL, %MMIO_WRITE OR %MMIO_CREATE)
    IF hmmioFile THEN
       ciRiffChunk.fccType = mmioStringToFOURCC("WAVE", 0)
       ciRiffChunk.cksize = 0
       nRet = mmioCreateChunk(hmmioFile, ciRiffChunk, %MMIO_CREATERIFF)
       IF nRet = 0 THEN
          ciSubChunk.ckid = mmioStringToFOURCC ("fmt ", 0)
          ciSubChunk.cksize = SIZEOF(WAVEFORMATEX)
          nRet = mmioCreateChunk(hmmioFile, ciSubChunk, 0)
          IF nRet = 0 THEN
             IF mmioWrite(hmmioFile, BYVAL VARPTR(wfx), SIZEOF(WAVEFORMATEX)) = SIZEOF(WAVEFORMATEX) THEN
                nRet = mmioAscend(hmmioFile, ciSubChunk, 0)
                IF nRet = 0 THEN
                   ciSubChunk.ckid = mmioStringToFOURCC("data", 0)
                   ciSubChunk.cksize = 0
                   nRet = mmioCreateChunk(hmmioFile, ciSubChunk, 0)
                   IF nRet = 0 THEN
                      mmioFlush(hmmioFile, 0)
                   END IF
                END IF
             END IF
          END IF
       END IF
    END IF
    FUNCTION = nRet
END FUNCTION

[WDKyle]

Mais le principe est que le buffer doit être écrit à la suite, il faut donc soit travailler en mode ajout, soit utiliser fSeek pour se positionner correctement.

J'ai bien mis foAjout à la fonction fOuvre() pourtant...

Le mieux c'est de créer une DLL ? J'ai Visual Studio 2013 Express mais je ne maîtrise pas du tout le C#, VB.Net, C++...

Je me vois mal développer une DLL pour gérer ça :s

[OnePoint]

En ce qui concerne le fichier wav, il faut aussi qu'il comporte un header.

La description du format wave est facile à trouver sur le web. Par exemple...

http://fr.wikipedia.org/wiki/WAVEform_audio_format

https://ccrma.stanford.edu/courses/4...ts/WaveFormat/

[WDKyle]

La description du format wave est facile à trouver sur le web. Par exemple...

http://fr.wikipedia.org/wiki/WAVEform_audio_format

https://ccrma.stanford.edu/courses/4...ts/WaveFormat/

Merci de ton aide

J'ai trouvé ceci également : http://msdn.microsoft.com/fr-fr/libr...(v=vs.85).aspx mais comment mettre en place ça sous Windev ?

[WDKyle]

Avez-vous testé ce vieux projet WD10 qui utilise le composant AudioCap.dll

...

Oui, je l'ai testé comme dis plus haut dans les posts, mais c'est une version d'essai ?

[Patrice Terrier]

Je dois pouvoir enlever toute la partie graphique et ne conserver que le code qui permet de capturer le son.
Il faut faire toute l'encapsulation de l'API MMIO bas niveau en WinDev, en espérant que çà fonctionne en p-code.

...

[OnePoint]

Je confirme que la fonction fEcrit modifie la position en cours et qu'il est inutile de faire appel à la fonction fPositionne.

Merci de ton aide

J'ai trouvé ceci également : http://msdn.microsoft.com/fr-fr/libr...(v=vs.85).aspx mais comment mettre en place ça sous Windev ?

En décortiquant le format, on voit que tu as besoin de connaître certaines informations pour enregistrer le fichier au format wave :
AudioFormat: 1 (le format apparemment c'est PCM, donc 1)
NumChannels: 2
SampleRate: 44100
ByteRate: 176400 (== SampleRate * NumChannels * BitsPerSample/8)
BlockAlign: 4 (== NumChannels * BitsPerSample/8)
BitsPerSample: 16

et aussi la taille totale du son enregistré.

Donc j'imagine que la procédure callback va tout enregistrer dans un fichier temporaire.
Puis, une fois la capture terminée et la taille des données connue, il faut :
(1) créer le fichier final (format wav),
(2) y écrire l'entête, puis
(3) y recopier toutes les données provenant du fichier temporaire.

Et pour l'entête, il est facile d'utiliser un type buffer dans lequel tu ajoutes toutes les données descriptives en te conformant au format, et tu utilises fEcrit auquel tu passes l'adresse du buffer et la taille des données qu'il contient.

[Patrice Terrier]

Je suis d'accord avec Monsieur OnePoint, çà devrait marcher.
Sinon j'essaierai de convertir le code en WinDev si je suis dans un bon jour.

[WDKyle]

Je confirme que la fonction fEcrit modifie la position en cours et qu'il est inutile de faire appel à la fonction fPositionne.



En décortiquant le format, on voit que tu as besoin de connaître certaines informations pour enregistrer le fichier au format wave :
AudioFormat: 1 (le format apparemment c'est PCM, donc 1)
NumChannels: 2
SampleRate: 44100
ByteRate: 176400 (== SampleRate * NumChannels * BitsPerSample/8)
BlockAlign: 4 (== NumChannels * BitsPerSample/8)
BitsPerSample: 16

et aussi la taille totale du son enregistré.

Donc j'imagine que la procédure callback va tout enregistrer dans un fichier temporaire.
Puis, une fois la capture terminée et la taille des données connue, il faut :
(1) créer le fichier final (format wav),
(2) y écrire l'entête, puis
(3) y recopier toutes les données provenant du fichier temporaire.

Et pour l'entête, il est facile d'utiliser un type buffer dans lequel tu ajoutes toutes les données descriptives en te conformant au format, et tu utilises fEcrit auquel tu passes l'adresse du buffer et la taille des données qu'il contient.

Ok mais donc j'écris dans le buffer d’entête selon le format ici : http://fr.wikipedia.org/wiki/WAVEform_audio_format ? Donc 44 octets l'un à la suite ?

Merci encore de votre aide

[OnePoint]

Exemple de code pour créer l'entête d'un fichier wave et l'écrire dans un fichier.

Note:
J'ai fait le choix d'une variable de type buffer qui est agrandie par concaténation.
Mais il aurait peut être était plus simple soit de déclarer un buffer de taille fixe (44 octets) et d'y écrire les bonnes valeurs aux bons "offsets", soit de déclarer un type structure calqué sur le format de l'entête et d'affecter les bonnes valeurs aux bons membres.

C'est du Windev 12, et j'ai dû batailler un peu pour concaténer un mot (2 octets) en fin de buffer au lieu d'un double-mot (4 octets)...
d'où la fonction BufferSurDeuxOctets() que j'ai ajoutée à la fin.

Dans l'exemple, la taille des données du son est de 2048 octets.
La taille du fichier wave est de 2048 octets + 44 octets pour l'entête.

Exemple de création d'un entête de fichier wave:

Code WLangage :

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
 
 
nTailleSon est un entier sans signe sur 4 octets = 2048
 
NbrCanaux est un entier sans signe sur 2 octets = 2
BitsPerSample est un entier sans signe sur 2 octets = 16
BytePerBloc est un entier sans signe sur 2 octets = NbrCanaux * BitsPerSample / 8
Frequence est un entier sans signe sur 4 octets = 44100
BytePerSec est un entier sans signe sur 4 octets = Frequence * BytePerBloc
 
xbEntete est un Buffer
 
//	[Bloc de déclaration d'un fichier au format WAVE]
//	   FileTypeBlocID  (4 octets) : Constante «RIFF»  (0x52,0x49,0x46,0x46)
//	   FileSize        (4 octets) : Taille du fichier moins 8 octets
//	   FileFormatID    (4 octets) : Format = «WAVE»  (0x57,0x41,0x56,0x45)
 
xbEntete = "RIFF"
xbEntete += (nTailleSon + 44 - 8)
xbEntete += "WAVE"
 
//	[Bloc décrivant le format audio]
//	   FormatBlocID    (4 octets) : Identifiant «fmt »  (0x66,0x6D, 0x74,0x20)
//	   BlocSize        (4 octets) : Nombre d'octets du bloc - 8  (0x10)
//	   AudioFormat     (2 octets) : Format du stockage dans le fichier (1: PCM, ...)
//	   NbrCanaux       (2 octets) : Nombre de canaux (de 1 à 6)
//	   Frequence       (4 octets) : Fréquence d'échantillonnage (en hertz) [Valeurs standardisées : 11025, 22050, 44100 et éventuellement 48000 et 96000]
//	   BytePerSec      (4 octets) : Nombre d'octets à lire par seconde (i.e., Frequence * BytePerBloc).
//	   BytePerBloc     (2 octets) : Nombre d'octets par bloc d'échantillonnage (i.e., tous canaux confondus : NbrCanaux * BitsPerSample/8).
//	   BitsPerSample   (2 octets) : Nombre de bits utilisés pour le codage de chaque échantillon (8, 16, 24)
 
xbEntete += "fmt "
xbEntete += 0x00000010
xbEntete += BufferSurDeuxOctets(1)
xbEntete += BufferSurDeuxOctets(NbrCanaux)
xbEntete += Frequence
xbEntete += BytePerSec
xbEntete += BufferSurDeuxOctets(BytePerBloc)
xbEntete += BufferSurDeuxOctets(BitsPerSample)
 
//	[Bloc des données]
//	   DataBlocID      (4 octets) : Constante «data»  (0x64,0x61,0x74,0x61)
//	   DataSize        (4 octets) : Nombre d'octets des données (i.e. "Data[]", 
//									i.e. taille_du_fichier - taille_de_l'entête  (qui fait 44 octets normalement).
 
xbEntete += "data"
xbEntete += nTailleSon
 
// pour écrire l'entête
fEcrit(nIDFichier,&xbEntete,Taille(xbEntete))

Et la fonction

Code WLangage :

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

1
2
3
4
5
6
 
FONCTION BufferSurDeuxOctets(n est un entier sans signe sur 2 octets)
 
xb est un Buffer sur 2 octets = n
 
RENVOYER xb

[WDKyle]

Merci pour ton aide !

J'avais en effet commencer sur la même lignée mais avec une structure

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
 
PROCEDURE CreerWav()
 
nIDFichFinal est un entier
nIDFichFinal = fOuvre("C:\Users\Kyle\Documents\test_final.wav", foCréation+foAjout)
 
MonEnteteBuff est un Buffer
MonAudioBuff est un Buffer = fChargeBuffer("C:\Users\Kyle\Documents\test_tempo.wav")
 
STRUCT_WAVE est une structure
	FileTypeBlocID est un entier sans signe sur 4 octets
	FileSize est un entier sans signe sur 4 octets
	FileFormatID est un entier sans signe sur 4 octets
 
	FormatBlocID est un entier sans signe sur 4 octets
	BlocSize est un entier sans signe sur 4 octets
 
	AudioFormat est un entier sans signe sur 2 octets
	NbrCanaux est un entier sans signe sur 2 octets
	Frequence est un entier sans signe sur 4 octets
	BytePerSec est un entier sans signe sur 4 octets
	BytePerBloc est un entier sans signe sur 2 octets
	BitsPerSample est un entier sans signe sur 2 octets
 
	DataBlocID est un entier sans signe sur 4 octets
	DataSize est un entier sans signe sur 4 octets
FIN
 
MonEnteteWave est une STRUCT_WAVE
 
MonEnteteWave:FileTypeBlocID = "RIFF"
MonEnteteWave:FileFormatID = "WAVE"
 
MonEnteteWave:FormatBlocID = "fmt "
 
MonEnteteWave:AudioFormat = 1
MonEnteteWave:NbrCanaux = 2
MonEnteteWave:Frequence = 44100
MonEnteteWave:BitsPerSample = 16
 
MonEnteteWave:DataBlocID = "data"
 
MonEnteteWave:BytePerBloc = MonEnteteWave:NbrCanaux * MonEnteteWave:BitsPerSample / 8
MonEnteteWave:BytePerSec = MonEnteteWave:Frequence * MonEnteteWave:BytePerBloc
MonEnteteWave:BlocSize = 0x00000010
MonEnteteWave:FileSize = Taille(MonEnteteBuff) + Taille(MonAudioBuff) - 8
 
MonEnteteWave:DataSize = Taille(MonAudioBuff)
 
fEcrit(nIDFichFinal, &MonEnteteBuff + &MonAudioBuff, Taille(MonEnteteBuff) + Taille(MonAudioBuff))

Mais c'est moins propre que votre code et peut-être pas fonctionnel

[OnePoint]

La structure c'est bien, car lisible !
Et tu peux l'écrire directement, sans transiter par un buffer. Mais il faut utiliser la fonction Dimension pour obtenir la taille de la variable (ici c'est 44 octets, on le sait déjà ).

Code :

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

1
2
 
MonEnteteWave:FileSize = Dimension(MonEnteteWave) + Taille(MonAudioBuff) - 8

Code :

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

1
2
3
 
fEcrit(nIDFichFinal, &MonEnteteWave, Dimension(MonEnteteWave))
fEcrit(nIDFichFinal, &MonAudioBuff,Taille(MonAudioBuff))