Wav en binaire

**DelilahHinxs** · 02/03/2008, 00h20

Re bonjour à tous,

Me revoilà avec une toute nouvelle question, j'ai progressée en C, là j'ai à nouveau un gros problème:
Je dispose de fichier WAV(j'ai été lire sur internet qu'ils étaient structuré avec un Header suivit des data) je souhaiterais extraire de ce fichiers WAV tous les bits qu'il contient et inscrire tous ces bits dans un fichier : genre donnee.data

Je n'ai pas trouvé de tutoriel, ni beaucoup de documentation sur passer de WAV en un fichier contenant tous les bits,...appart : WAV2BIN si quelqu'un connait j'ai lu leur code mais ça ne fait pas du tout ce que je veux et je ne vois pas comment démarrer , j'espère que vous pourrez m'aider !

Merci d'avance,

J'aimerais n'utiliser que le C et pas le C++

Delilah

**Melem** · 02/03/2008, 08h38

Si un fichier wav (wav ou pas wav ...) a un en-tête fixe de disons 100 octets immédiatement suivi des données, comment fais-tu pour copier les données (c'est-à-dire les octets qui suivent immédiatement l'en-tête) vers un autre fichier ?

**Emmanuel Delahaye** · 02/03/2008, 10h11

Envoyé par DelilahHinxs

Me revoilà avec une toute nouvelle question, j'ai progressée en C,

mais pas en français !

là j'ai à nouveau un gros problème:
Je dispose de fichier WAV(j'ai été lire sur internet qu'ils étaient structuré avec un Header suivit des data) je souhaiterais extraire de ce fichiers WAV tous les bits qu'il contient et inscrire tous ces bits dans un fichier : genre donnee.data

Je ne vois pas bien ce que tu veux faire, étant donné qu'un fichier wav non compressé est déjà un fichier binaire qui représente des échantillons de sons sous la forme d'entiers à raison de un par tick horloge et par voie.

http://ccrma.stanford.edu/courses/42...ts/WaveFormat/

**DelilahHinxs** · 02/03/2008, 11h08

Alors, J'ai consulté également le site que tu m'as envoyé, et j'ai commencé à écrire une fonction qui me permet d'extraire le "header",

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
 
/* Structure du signal entrant */
struct signal
{
	FILE* fichier;
	int frequence;
	char* nom;
};
/*	Fonction qui permet de lire l'entête et d'en extraire les données    */
int lecture_header_wav(signal sig_in,ulong* pointeur_frequence)
{
	/* Variables */
	char string[20];
	ulong tmp_long;
	ushort tmp_short;
	int erreur;
 
	do
	{
		/* Constante "R.I.F.F." ? + Lecture de la constante "R.I.F.F." */
		erreur = lecture_string_fichier(string,4,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if (strcmp(string,"RIFF") != 0)
		{
			printf("\nErreur dans le HEADER : RIFF\n");
			erreur = -1;
			break;
		}
		/* Lecture de la constante "R.I.F.F" */
		erreur = lecture_long_fichier(&tmp_long,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		/*	Vérification de WAVEfmt et lecture */
		erreur = lecture_string_fichier(string,8,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(strcmp(string,"WAVEfmt ") != 0)
		{
			printf("\nWAVEfmt erreur!\n");
			erreur = -1;
			break;
		}
		erreur = lecture_long_fichier(&tmp_long,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		/* Vérification format PCM + lecture */
		erreur = lecture_short_fichier(&tmp_short,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(tmp_short != 1)
		{
			printf("\nErreur format(PCM)\n");
			erreur = -1;
			break;
		}
		/* Mono / stereo  !!!!A MODIFIER JE PENSE !!!!*/
		erreur = lecture_short_fichier(&tmp_short,&sig_in.fichier);
				if(erreur != 0)
		{
			break;
		}
		if(tmp_short != 1 && tmp_short != 2)
		{
			printf("\nFormat ni stereo ni mono!\n");
			erreur = -1;
			break;
		}
		/*          Frequence         */
		erreur = lecture_long_fichier(pointeur_frequence,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		erreur = lecture_long_fichier(&tmp_long,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		/*			   Bytes			*/
		erreur = lecture_short_fichier(&tmp_short,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(tmp_short != 1)
		{
			printf("Erreur de format diffère d'un Byte");
			erreur = -1;
			break;
		}
		erreur = lecture_short_fichier(&tmp_short,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(tmp_short != 8)
		{
			printf("Erreur de format diffère de 8 Bytes");
			erreur = -1;
			break;
		}
		/*		'data'	    */
		erreur = lecture_string_fichier(string,4,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(strcmp(string,"data") != 0) 
		{
			erreur = fseek(sig_in.fichier,-2,SEEK_CUR);
			if(erreur != 0)
			{
				printf("Impossible de deplacer le pointeur dans le fichier");
				break;
			}
		}
		erreur = lecture_string_fichier(string,4,&sig_in.fichier);
		if(erreur != 0)
		{
			break;
		}
		if(strcmp(string,"data") != 0) 
		{
			erreur = lecture_string_fichier(string,8,&sig_in.fichier);
			if(erreur != 0)
			{
				break;
			}
			erreur = lecture_string_fichier(string,4,&sig_in.fichier);
			if(erreur != 0)
			{
				break;
			}
			if(strcmp(string,"data") != 0)
			{
				printf("Erreur DATA HEADER : 'data')");
				erreur = -1;
				break;
			}
		}
	erreur = lecture_long_fichier(&tmp_long,&sig_in.fichier);
	if(erreur != 0)
	{
		break;
	}
 
  }while(0);
return erreur;
}

Maintenant (si ce que j'ai fait est correct), j'ai vérifié l'header et je l'ai lu, j'aimerais convertir maintenant mon fichier WAV en un fichier .bin ou quelque chose comme ça qui serait une suite de 1 et 0. Ce qui me permettra par après de faire des découpage dedans et d'aller chercher la ou les séquences qui m'intéresse. Mais j'aimerais d'abord passer par un fichier ne contenant que des 1 et 0.

Merci,

ps: je vais essayer de surveiller mon orthographe et d'être clair.

**Emmanuel Delahaye** · 02/03/2008, 11h50

Envoyé par DelilahHinxs

j'aimerais convertir maintenant mon fichier WAV en un fichier .bin ou quelque chose comme ça qui serait une suite de 1 et 0.

Euh, bizarre... Un fichier binaire contient des octets formés chacun de 8 bits valant 0 ou 1. Mais c'est le cas de toutes les données informatiques actuelles.

Ce qui me permettra par après de faire des découpage dedans et d'aller chercher la ou les séquences qui m'intéresse. Mais j'aimerais d'abord passer par un fichier ne contenant que des 1 et 0.

Bah, techniquement, on peux 'étendre' les octets en bits valant 0 ou 1 (ou '0' ou '1'), mais non seulement ça va multiplier la taille du fichier par 8, mais de plus, ça n'aura aucun sens pour un être humain et ça n'aidera en rien à faire un montage, même en mode texte.

Une conversion des entiers en texte, oui.

**DelilahHinxs** · 02/03/2008, 11h58

Oui, je pense que j'ai un problème de vocabulaire: un octet = 8 bits? mais en faite je pense que tu as raison, les informations contenues dans le header font minimum 2 octets donc ça ne sert à rien de découper en bits(à part alourdir mon fichier).

Donc je pars de l'idée que je veux extraire des octets, de plus je peux connaître le taille de la partie 'data' de mon fichier WAV en effet, 4 octets dans le header sont consacrés a donné la taille du bloc 'data'.

Maintenant j'ai écris la fonction qui extrait les données du Header, il suffit d'intégrer ses données à ma structure, et j'aurais mémorisé toutes les informations sur mon fichier WAV.

Maintenant on arrive au moment où je bloque extraire les octets et les transcrire en entier dans un fichier texte.

**Emmanuel Delahaye** · 02/03/2008, 18h38

Envoyé par DelilahHinxs

Oui, je pense que j'ai un problème de vocabulaire: un octet = 8 bits? mais en faite je pense que tu as raison, les informations contenues dans le header font minimum 2 octets donc ça ne sert à rien de découper en bits(à part alourdir mon fichier).

Donc je pars de l'idée que je veux extraire des octets, de plus je peux connaître le taille de la partie 'data' de mon fichier WAV en effet, 4 octets dans le header sont consacrés a donné la taille du bloc 'data'.

Maintenant j'ai écris la fonction qui extrait les données du Header, il suffit d'intégrer ses données à ma structure, et j'aurais mémorisé toutes les informations sur mon fichier WAV.

Maintenant on arrive au moment où je bloque extraire les octets et les transcrire en entier dans un fichier texte.

Dejà, ce ne sont pas des octets, mais des mots de 16-bit qu'il faut écrire au format texte dans le fichier. Pour ça, il faut lire 2 octets (LSB, MSB selon la convention de Microsoft) et les placer dans un entier non signé (unsigned int, par exemple) à l'aide des opérateurs bits :

Code :

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

1
2
3
4
 
   unsigned data = 0;
   data |= (fgetc(fp) << (8 * 0));  /* LSB */
   data |= (fgetc(fp) << (8 * 1));

ensuite, on convertit data en texte dans un fichier avec fprint() (décimal, hexa...). Prévoir un séparateur entre les valeurs, c'est plus clair.

Ca va faire une gros fichier texte. Nota : le format hexa prend moins de place, mais n'est pas forcément très lisible. Le format décimal permet d'utiliser un mode signé si on utilise les bons types et les bonnes conversions.

**DelilahHinxs** · 05/03/2008, 18h15

Alors d'abord merci! mais je ne pense pas avoir bien compris, j'ai modifié tout monde code voilà où j'en suis :

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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
 
/* Redéfinitions de types (8,16,32) bits */
typedef unsigned char uchar;
typedef unsigned short ushort;
typedef unsigned long ulong;
/* Structure du signal entrant et Chunk Signal*/
typedef struct
{
	char ID_riff[4];
	char ID_wave[4];
	char ID_fmt[4];
 
	ulong riff_len;
	ulong pcm_len_header;
	ulong format_tags;
	ulong sample_par_seconde;
	ulong bytes_par_seconde;
 
	ushort nbr_canaux;
	ushort nbr_block_align;
	ushort nbr_bits_par_sample;
 
}signal_header;
typedef struct
{
	char ID_data[4];
	ulong data_len;
}chunk_header;
 
signal_header lecture_head_wave(signal_header sig_in,char *nom_fichier)
{
	/* Variables */
	FILE* fichier;
	int i_octet;
	ulong status;
	char o_buffer[80];
 
	signal_header *wav;
	chunk_header *chunk;
	ushort *pointeur_ushort;
	uchar *pointeur_char;
	int flag;
	int num_isample;
	ulong max_isample;
	ulong header_more;
 
	double *data_in;
	char *buffer_w;
	int buffer_len;
 
	/*		Lecture Header WAVE	*/				
 
	/*			Allocation mémoire WAV et CHUNK	 */
	wav = new signal_header;
	chunk = new chunk_header;
	if(wav == NULL || chunk == NULL)
	{
		printf("Allocation mémoire impossible!");
		exit(1);
	}
	/*					Ouverture fichier		*/			
	fichier = fopen(nom_fichier,"rb");
	if(fichier == NULL)
	{
		printf("Aucun fichier n'a pu etre ouvert!");
		exit(1);
	}
	/*					   Lecture RIFF			*/
	status = fread((void *)wav,sizeof(signal_header),(size_t)1,fichier);
	if(status != 1)
	{
		printf("impossible de lire dans le fichier,RIFF");
		exit(1);
	}
	/*		Vérification FORMAT		*/
	/*			  RIFF			      */
	for(i_octet=0;i_octet<4;i_octet++)
	{
		o_buffer[i_octet] = wav->ID_riff[i_octet];
		o_buffer[4] = 0;
	}
	if(strcmp(o_buffer,"RIFF")!= 0)
	{
		printf("Erreur pas un fichier WAV");
		exit(1);
	}
	/*		WAVE		*/
	for(i_octet=0;i_octet<4;i_octet++)
	{
		o_buffer[i_octet] = wav->ID_wave[i_octet];
		o_buffer[4] = 0;
	}
	if(strcmp(o_buffer,"WAVE")!= 0)
	{
		printf("Erreur pas un fichier WAVE");
		exit(1);
	}
	/*			fmt			*/
	for(i_octet=0;i_octet<3;i_octet++)
	{
		o_buffer[i_octet] = wav->ID_fmt[i_octet];
		o_buffer[3] = 0;
	}
	if(strcmp(o_buffer,"fmt"))
	{
		printf("Erreur pas un fichier WAVE");
		exit(1);
	}
	/*			Format Tags		*/
	if(wav->format_tags != 1)
	{
		printf("erreur format tags");
	}
	if((wav->nbr_bits_par_sample != 8)&&(wav->nbr_bits_par_sample != 16))
	{
		printf("Erreur Sample ni 8 bits ni 16 bits");
		exit(1);
	}
	/*				On va passer le reste du wav header     */
	header_more = wav->pcm_len_header - (sizeof(signal_header) - 20);
	status = fseek(fichier,header_more,SEEK_CUR);
	if(status != 0)
	{
		printf("erreur SEEK");
		exit(1);
	}
	/*			Lecture des CHUNKS jusqu'au 'data'	*/
	flag = 1;
	do
	{
		if(flag > 10)
		{
			printf("Trop de CHUNKS à lire");
			exit(1);
		}
			/* On lit les chunks */
			status = fread((void*)chunk,sizeof(chunk_header),(size_t) 1,fichier);
			if(status != 1)
			{
				printf("Erreur fread chunk");
			}
			/* Vérifié le type de chunk */
			for(i_octet=0;i_octet<4;i_octet++)
			{
				o_buffer[i_octet] = chunk->ID_data[i_octet];
				o_buffer[4] = 0 ;
			}
			if(strcmp(chunk->ID_data,"data")== 0)
			{
				break;
			}
			/* On passe le chunk lu */
			flag++;
			status = fseek(fichier,chunk->data_len,SEEK_CUR);
			if(status != 0)
			{
				printf("Erreur fseek, chunk, data lenght");
				exit(1);
			}
	}while(flag !=0);
	/*		On doit trouver la taille des données restantes		*/
	buffer_len = chunk->data_len;
	/*	On cherche le nombre de samples	*/
	max_isample = chunk->data_len;
	max_isample /= wav->nbr_bits_par_sample / 8;
	/*		Allocation des nouveaux buffers	*/
	buffer_w = new char[buffer_len];
	if(buffer_w == NULL)
	{
		printf("erreur allocation buffer_len");
		exit(1);
	}
	data_in = new double[max_isample];
	if(data_in == NULL)
	{
		printf("erreur allocation buffer_len"); 
		exit(1);
	}
 
	/* Lecture data signal */
	status = fread((void *)buffer_w,buffer_len,(size_t) 1,fichier);
	if(status != 1)
	{
		printf("erreur fread, data");
		exit(1);
	}
	/*				On convertir le signal en bits			   */
 
return sig_in;
}

C'est là que je bloque, je dois écrire une autre fonctions qui va convertir mes données en des '1' et '0' et les inscrire dans un fichier, j'ai regardé ce que vous m'avez dit mais je ne comprend pas du tout ce que cela veut dire (à propos des opérateur binaire etc...)

Merci

Wav en binaire

C

Discussions similaires

Partager

Partager