///////////////////////////////////////////////////////////////////////
//                                                                   //
//  bmp.h :      Ce fichier contient les définitions de structures   //
//               contenant les informations pour l'en-tête des       //
//               fichiers .bmp dans lesquels on enregistre l'image.  //
//                                                                   //
///////////////////////////////////////////////////////////////////////

#ifndef BMP_H
#define BMP_H

struct bmpfileheader
{
	unsigned short bfType;		// Type de fichier, 'MB' dans notre cas
	unsigned long bfSize;		// Grandeur du fichier
	unsigned short bfReserved1;	// Doit être égal à 0
	unsigned short bfReserved2;	// Doit être égal à 0
	unsigned long bfOffBits;	// Offset, donc grandeur du bmpfileheader, du bmpinfoheader et
								// de la table de couleurs s'il y en a une
};


struct bmpinfoheader
{
	unsigned long biSize;
	long biWidth;
	long biHeight;
	unsigned short biPlanes;
	unsigned short biBitCount;
	unsigned long biCompression;
	unsigned long biSizeImage;
	long biXPelsPerMeter;
	long biYPelsPerMeter;
	unsigned long biClrUsed;
	unsigned long biClrImportant;
};

struct type_couleur
{
	unsigned char Bleu;
	unsigned char Vert;
	unsigned char Rouge;
	int Frequence;

	bool operator == (const type_couleur& Coul) const
	{ return ( (Bleu == Coul.Bleu) && (Vert == Coul.Vert) && (Rouge == Coul.Rouge) ); }
};

#endif

/*

****bmpinfoheader****

biSize: contient l'espace occupé (sizeof) par le bmpinfoheader

biWidth: largeur de l'image en pixels
biHeight: hauteur de l'image en pixels

biPlanes: doit être 1 dans le cas d'un .bmp

biCount: contient:
  - 1 si l'image n'a que deux couleurs dans la table de couleur.  Chaque bit dans le tableau 
    de bitmap représente un pixel: la première couleur de la table si le bit est 0, la seconde 
	si le bit est 1.
  - 4 si l'image a 16 couleurs.  Chaque pixel est représenté par 4 bit (la moitié d'un octet) 
    dans le tableau de bitmap.  0 correspond à la première couleur, 1 à la seconde, etc...
  - 8 si l'image a 256 couleurs.  Chaque pixel est représenté par 1 octet dans le tableau
    de bitmap.  0 correspond à la première couleur, 1 à la seconde, etc...
  - 24 si l'image a 2^24 couleurs.  Chaque pixel est représenté par 3 octets qui représente 
    l'intensité de rouge, vert et bleu (0 à 255).

biCompression:
  - BI_RGB  (0L): pas de compression
  - BI_RLE8 (1L): Compression pour les 8 bits (1 octet) par pixel.  Une unité d'information 
                  contient 2 octets.  Le premier contient le nombre de pixels consécutifs à 
  dessiner avec la couleur de l'index contenu dans le 2e octet.  Si le premier octet est 0,
  le deuxième octet égal à 0 signifie une fin de ligne, égal à 1 signifie une fin de bitmap,
  égal à 2 signifie un delta (???).  Si le second octet est plus grand que 2, il contient 
  le nombre de pixels (donc octet) qui suivent qui seront en mode "absolute", c'est-à-dire 
  non compressé.  S'il y a un nombre impair, on termine le dernier par zéro.
  - BI_RLE4 (2L): Compression pour les 4 bits par pixel.  Une unité d'information contient
                  2 octets.  Le premier contient le nombre de pixels consécutifs à dessiner 
  avec les couleurs de l'index contenu dans le 2e octet.  Le premier pixel est dessiné avec 
  la couleur contenu dans les 4 premiers bits, le second avec les 4 autres, etc.

biSizeImage: grandeur de l'image en octets, sans les headers et la table

biXPelsPerMeter, BiYPelsPerMeter: résolution, qui peut être utilisé par une application pour 
                                  choisir une image qui lui convient

biClrUsed: le nombre de couleurs vraiment utilisées dans la table s'il n'est pas 16 ou 256.
           S'il est 0, c'est le nombre maximale 2^biCount.

biClrImportant: dit quelles couleurs de la table sont importantes.  Si c'est 0, toutes les 
                couleurs sont importantes

*/