IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

Wav en binaire


Sujet :

C

  1. #1
    Membre averti
    Profil pro
    Inscrit en
    Février 2008
    Messages
    19
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2008
    Messages : 19
    Par défaut Wav en binaire
    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

  2. #2
    Expert confirmé
    Avatar de Melem
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Janvier 2006
    Messages
    3 656
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 39
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Électronique et micro-électronique

    Informations forums :
    Inscription : Janvier 2006
    Messages : 3 656
    Par défaut
    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 ?

  3. #3
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par DelilahHinxs Voir le message
    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/

  4. #4
    Membre averti
    Profil pro
    Inscrit en
    Février 2008
    Messages
    19
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2008
    Messages : 19
    Par défaut
    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.

  5. #5
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par DelilahHinxs Voir le message
    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.

  6. #6
    Membre averti
    Profil pro
    Inscrit en
    Février 2008
    Messages
    19
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2008
    Messages : 19
    Par défaut
    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.

  7. #7
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    Citation Envoyé par DelilahHinxs Voir le message
    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.

  8. #8
    Membre averti
    Profil pro
    Inscrit en
    Février 2008
    Messages
    19
    Détails du profil
    Informations personnelles :
    Localisation : Belgique

    Informations forums :
    Inscription : Février 2008
    Messages : 19
    Par défaut
    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

Discussions similaires

  1. conversion du binaires en wav
    Par pogrebnyak dans le forum C#
    Réponses: 4
    Dernier message: 01/06/2012, 15h53
  2. [Serialisation]Comment transformer données binaires>.wav?
    Par Surfer dans le forum Framework .NET
    Réponses: 1
    Dernier message: 21/02/2006, 18h06
  3. Existe t'il un composant permettant de jouer un son wav?
    Par scorpiwolf dans le forum C++Builder
    Réponses: 5
    Dernier message: 20/06/2002, 14h10
  4. fichier binaire ou texte
    Par soussou dans le forum C++Builder
    Réponses: 4
    Dernier message: 14/06/2002, 13h39
  5. [Kylix] jouer un fichier wav avec kilyx
    Par JlouisI dans le forum EDI
    Réponses: 1
    Dernier message: 14/06/2002, 02h05

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo