Discussion :

[gronaze]

Bonjour,

Je souhaite faire un fichier *.bmp. D'après ce que j'ai vu les types int char... dépendent des compilos et OS, donc j'ai tenté une écriture en dur.... mais je m'emmêle complétement les pinceaux sur le résultats obtenus entre les %X, fprintf et fwrite

Définition de la structure *.bmp (que j'ai d'ailleurs récupérée sur le net):

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
 
struct {
	/* Debut entete du fichier */
	char bfType [2]; // type du fichier : doit contenir BM (ou en hexadécimal 424D) 
	char bfSize [4]; //taille du fichier en octets 
	char bfReserved1 [2]; // réservé (doit être 0000) 
	char bfReserved2 [2]; // réservé (doit être 0000) 
	char bfOffBits  [4]; // offset des données depuis la structure
	/* Fin entete du fichier */
 
	/* Debut entete de l'image */
	char biSize [4]; // nombre d'octets de la structure 
	char biWidth [4]; // largeur du bitmap en pixels 
	char biHeight [4]; // hauteur de la bitmap en pixels 
	char biPlanes [2]; // nombre de plans (doit être 0001) 
	char biBitCount [2]; // nombre d'octets par pixel (cf. Annotations finales) 
	char biCompression [4]; // type de compression (cf. Annotations finales) 
	char biSizeImage [4]; // taille de l'image en octets (cf. Annotations finales) 
	char biXPelsPerMeter [4]; // résolution horizontale en pixels par mètre 
	char biYPelsPerMeter [4]; // résolution horizontale en pixels par mètre 
	char biClrUsed [4]; // nbre de couleurs utilisées (0=biBitCount) (cf. Annotations finales) 
	char biClrImportant [4]; // nombre de couleurs considérées comme importantes pour afficher le bitmap (si non nul, toutes couleurs importantes) 
	/* Fin entete de l'image */
}bmp_struct;

Ensuite je souhaite remplir mes champs un à un :

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
	/* Remplir la structure du bmp */
	sprintf(bmp_struct.bfType, "BM"); // type du fichier : doit contenir BM (ou en hexadécimal 424D) // 2 octets
printf("Nb : %04d %04x\n", nb_lig_TOT*nb_pix_TOT, nb_lig_TOT*nb_pix_TOT);
	sprintf(s_dbl_octet, "%04x", nb_lig_TOT*nb_pix_TOT);  //taille du fichier en octets // A REVOIR
//printf("|%04x| |%04X|\n", s_dbl_octet, s_dbl_octet);
	sprintf(bmp_struct.bfSize, "%s", s_dbl_octet);  //taille du fichier en octets // A REVOIR
	sprintf(bmp_struct.bfReserved1, 0x0000); // réservé (doit être 0000) // 2 octets
	sprintf(bmp_struct.bfReserved2, 0x0000); // réservé (doit être 0000) // 2 octets
	sprintf(bmp_struct.bfOffBits, "%04d", 2*54); // offset des données depuis la structure
	/* Fin entete du fichier */
 
	/* Debut entete de l'image */
	sprintf(bmp_struct.biSize, "%04d", 40); // nombre d'octets de la structure 
	sprintf(bmp_struct.biWidth, "%04d", nb_pix_TOT); // largeur du bitmap en pixels 
	sprintf(bmp_struct.biHeight, "%04d", nb_lig_TOT); // hauteur de la bitmap en pixels 
	sprintf(bmp_struct.biPlanes, "%02d", 0x0001); // nombre de plans (doit être 0001) // 2 octets
	sprintf(bmp_struct.biBitCount, "%02d", 0x0001); // nombre d'octets par pixel (cf. Annotations finales)  // 2 octets
	sprintf(bmp_struct.biCompression, 0x00000000); // type de compression (cf. Annotations finales) 
	sprintf(bmp_struct.biSizeImage, 0x00000000); // taille de l'image en octets (cf. Annotations finales) 
	sprintf(bmp_struct.biXPelsPerMeter, 0x00000000); // résolution horizontale en pixels par mètre 
	sprintf(bmp_struct.biYPelsPerMeter, 0x00000000); // résolution horizontale en pixels par mètre 
	sprintf(bmp_struct.biClrUsed, 0x00000000); // nbre de couleurs utilisées (0=biBitCount) (cf. Annotations finales) 
	sprintf(bmp_struct.biClrImportant, 0x00000000); // nombre de couleurs considérées comme importantes pour afficher le bitmap (si non nul, toutes couleurs importantes)

puis (j'attends à m'attirer les foudres de tous le monde) j'écris l'ensemble de ma structure dans un fichier texte :

Code :

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

1
2
3
4
	char *pt_s_buf;
	[...]
	pt_s_buf = (void *) &bmp_struct;
	fwrite(pt_s_buf, sizeof(char), sizeof(bmp_struct), f_temp);

Sachant que nb_lig_TOT = 11 et nb_pix_TOT = 17 d'ou le produit vaut 187.
J'aurais aimé avoir dans mon fichier pour le champ bfSize :
la valeur ascii de 0xBB (soit un double guillemet fermé)

C'est là que je m'emmêle, j'obtiens soit 00BB, soit d'autres trucs est ce que les fonctions sprintf et/ou fwrite modifie la valeur en char ?

Merci de m'aider ou de m'indiquer ou chercher !

[Elijha]

Bonsoir,

Si la déclaration est de type char, cela ne veut pas dire que ce qu'il contient est obligatoirement un caractère alphanumérique.
Pour le champ bfType[], effectivement, il doit y avoir 2 caractères. En utilisant la fonction sprintf, cette dernière va essayer de mettre les lettres BM et le caractère \0 (donc 3 octets et non pas 2 comme défini dans la structure). Je te conseillerai de mettre directement tes caractères dans ce champ.

Code :

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

1
2
bmp_struct.bfType[0] = 'B' ;
bmp_struct.bfType[1] = 'M' ;

Pour les autres champs, cela ressemble fortement à des valeurs numériques. Par exemple en déclarant ta structure de la manière suivante, tu pourras contrôler qu'elle "doit" faire la même taille que ta structure (dépend de ta machine) :

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
struct stBitmap {
    char           bfType[2] ;          // type du fichier : doit contenir BM (ou en hexadécimal 424D)
    unsigned long  bfSize ;             // taille du fichier en octets
    unsigned short bfReserved1 ;        // réservé (doit être 0000)
    unsigned short bfReserved2 ;        // réservé (doit être 0000)
    unsigned long  bfOffBits ;          // offset des données depuis la structure
 
    unsigned long  biSize ;             // nombre d'octets de la structure
    unsigned long  biWidth ;            // largeur du bitmap en pixels
    unsigned long  biHeight ;           // hauteur de la bitmap en pixels
    unsigned short biPlanes ;           // nombre de plans (doit être 0001)
    unsigned short biBitCount ;         // nombre d'octets par pixel (cf. Annotations finales)
    unsigned long  biCompression ;      // type de compression (cf. Annotations finales)
    unsigned long  biSizeImage ;        // taille de l'image en octets (cf. Annotations finales)
    unsigned long  biXPelsPerMeter ;    // résolution horizontale en pixels par mètre
    unsigned long  biYPelsPerMeter ;    // résolution horizontale en pixels par mètre
    unsigned long  biClrUsed ;          // nbre de couleurs utilisées (0=biBitCount) (cf. Annotations finales)
    unsigned long  biClrImportant ;     // nombre de couleurs considérées comme importantes pour afficher le bitmap
                                        // (si non nul, toutes couleurs importantes)
} __attribute__ ((packed)) ;

Donc tu sais que ton image fais bmp_struct.biWidth de large par bmp_struct.biHeight de haut.

Pour l'écriture dans un fichier (voir man fwrite)

Code :

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

fwrite(&bmp_struct, sizeof(struct stBitmap), 1, f_temp) ;

Nota : La directive __attribute__ ((packed)) indique au compilateur qu'une structure doit occuper le moins de place possible en mémoire.

Edit : Tu peux aller voir les informations sur les bitmaps ici : wikipedia BMP file format

[gronaze]

Merci Elijha, le site que tu m'as donné est parfait pour le BMP

[gronaze]

Nouveau jour égale plus de recul, voici la fonction qui me manquait :

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
/* Fonction qui transforme le nombre val donné en entrée en valeur ascii calculée octet par octet */
int getAscii(char *s_buf, int val, int nbOctets)
{
	int size, indice;
 
	/* Initialisation des variables */
	size = nbOctets;	
	indice = 0;
 
	while (size > 0)
	{
		s_buf[indice] = (int) (val % 256);
		//printf("s_buf[%d] = %x ou |%c|\n(val MODULO 256) = %x\n", indice, s_buf[indice], s_buf[indice], (val % 265));
		val = val / 256; /* Decrémenter la valeur a encoder */
		if (val < 0)
			val = 0;
		size--;
		indice++;
	}
 
	return 1;
}