TBITMAPFILEHEADER = Packed Record 
    bfType      :Word; 
    bfSize      :DWORD; 
    bfReserved1 :Word; 
    bfReserved2 :Word; 
    bfOffBits   :DWORD; 
End; 

bfType

Spécifie le type de Bitmap, sa Signature. cette valeur doit contenir 'BM' ou sous format DWord ($424D).
Ce qui équivaut aussi à Chr( $42 ) + Chr($4D );

bfSize

Grosseur total du fichier.

bfReserved1

Réservé.

bfReserved2

Réservé

bfOffBits

Spécifie en Octet(Byte) la distance dans le fichier entre cette structure et le commencement des pixels, donc ceux qui forme l'image contenu dans le Bitmap.

TBITMAPINFO = Packed Record
    bmiHeader :TBitmapInfoHeader;
    bmiColors :Array[0..0] of TRGBQuad;
End;

TRGBQUAD = Packed Record
    rgbBlue     : Byte;
    rgbGreen    : Byte;
    rgbRed      : Byte;
    rgbReserved : Byte;
End;

TBITMAPINFOHEADER = Packed Record
    biSize          : DWORD;
    biWidth         : Longint;
    biHeight        : Longint;
    biPlanes        : Word;
    biBitCount      : Word;
    biCompression   : DWORD;
    biSizeImage     : DWORD;
    biXPelsPerMeter : Longint;
    biYPelsPerMeter : Longint;
    biClrUsed       : DWORD;
    biClrImportant  : DWORD;
End;

bmiHeader

Ce membre pointe vers la structure :TBITMAPINFOHEADER

bmiColors

Ce membre est un tableau vide représentant la palette de couleur du Bitmap. La Palette contient biClrUsed couleurs. Si l'on veut la parcourir alors il faut se servir de la structure TRGBQuad pour stocker chacune des couleurs (Quad = 4 Octets).

biSize

Spécifie la dimension de cette structure en Octet.

biWidth

Largeur de l'image.

biHeight

Hauteur de l'image.

biPlanes

Nombre de plans doit être '0001'.

biBitCount

Nombre de Bits par Pixel.

biCompression

Compression s'il en existe une. Si cette valeur est BI_RGB, c'est que le Bitmap n'est pas compressé. BI_RLE8 signifie qu'il est compressé (RLE) 8 bits par pixel et BI_RLE4 qu'il est compressé (RLE) 4 bits par pixel.

biSizeImage

Spécifie la taille de l'image en octet. Pour bien récupérer cette valeur le bitmap ne doit pas être compressé donc biCompression <> BI_RGB.

biXPelsPerMeter

Résolution Horizontale en pixels par mètre

biYPelsPerMeter

Résolution Verticale en pixels par mètre

biClrUsed

Spécifie le nombre de couleur dans la table qui sont présentement utilisées par le Bitmap. Ce cette valeur est égale à 0, c'est que le Bitmap utilise le maximum des couleurs présentes dans sa table.

biClrImportant

Spécifie le nombre de couleur requise pour afficher le bitmap.

Procedure RecupererInfo( Chemin :String;
                         Var FileSize, Largeur, Hauteur, BitsPerPixel,
                         NbCouleur :Integer );
Const
     FICHEADER  = SizeOf( TBITMAPFILEHEADER );
     BITMAPINFO = SizeOf( TBITMAPINFOHEADER );
	
Var
   FichierTemp :File;
   InfoFichier :TBITMAPFILEHEADER;
   InfoImage   :TBITMAPINFOHEADER;
   
Begin
     AssignFile( FichierTemp, Chemin );
     Reset( FichierTemp, 1 );

     BlockRead( FichierTemp, InfoFichier, FICHEADER );
     BlockRead( FichierTemp, InfoImage,   BITMAPINFO );

     CloseFile( FichierTemp );

     FileSize    := InfoFichier.bfSize;
     Largeur     := InfoImage.biWidth;
     Hauteur     := InfoImage.biHeight;
     BitsPerPixel:= InfoImage.biBitCount;
     NbCouleur   := InfoImage.biClrUsed;
End;

Procedure LireBitmap( Chemin :String );
Var
   BmpFichier     :File;              {Fichier Bitmap}
   BmpINFOFichier :TBITMAPFILEHEADER; {Structure #1}
   BmpINFO        :TBITMAPINFOHEADER; {Structure #2}

   GrosseurPal    :Cardinal;          {Grosseur de la palette}
   PtrDebutPal    :Pointer;           {Pointeur sur le début de la palette}

   DimBitmapInfo  :Cardinal;          {Grosseur de la structure TBITMAPINFO}
   pBmpINFO       :PBITMAPINFO;       {Pointeur sur une structure TBITMAPINFO}

   pTabPixels     :PByte;             {Pointeur sur une région de pixels en mémoire}

Begin
     {Vérification de l'existance du fichier}
     If Not FileExists( Chemin ) Then
        Exit;
        

     {Ouverture du fichier}
     AssignFile( BmpFichier, Chemin );
     Reset( BmpFichier, 1);


     {Lecture de l'entête TBITMAPFILEHEADER.
      Vérifier si c'est bien un bitmap "BM".}
     BlockRead( BmpFichier, BmpINFOFichier, SizeOf(BmpINFOFichier) );
     If BmpINFOFichier.bfType <> ( Ord('M') Shl 8 + Ord('B') ) Then
        Exit;

		
     {Lecture de l'entête TBITMAPINFO.
     Vérifier si la dimension/version de l'entête est correct.}
     BlockRead( BmpFichier, BmpINFO, SizeOf(BmpINFO) );
     If BmpINFO.biSize <> SizeOf(BmpINFO) Then
        Exit;

		
     {Déterminer le nombre de couleur dans la palette}
     If BmpINFO.biClrUsed = 0 Then
        PalNbCouleurs := 1 Shl BmpINFO.biBitCount
     Else
         PalNbCouleurs := BmpINFO.biClrUsed;

		 
     {Déterminer la grosseur de la palette}
     If BmpINFO.biBitCount < 16 Then
          GrosseurPal := PalNbCouleurs * SizeOf( TRGBQUAD )
     Else
         GrosseurPal := 256 * SizeOf( TRGBQUAD );

         
     {Déterminer la dimension de la table de couleur ainsi 
      que la structure BITMAPINFOHEADER pour enfin connaître 
      la vraie dimension de la structure
	  
          TBITMAPINFO + La table de couleur (TRGBQUAD)
     }
      DimBitmapInfo := Sizeof( TBITMAPINFOHEADER ) + GrosseurPal;

	  
     {Déterminer où débute le tableau de pixel dans le fichier bitmap.
      On aurait pu aussi utiliser cette ligne qui calcul l'"offset" déplacement
      entre la structure TBITMAPINFO et la fin du fichier, dont ce qui nous
      donnes les donnés pixel. Ne pas oublier que TBITMAPINFO contient aussi
      un tableau de couleur pour la palette (Si existante)

         DimTableauPixel := BmpINFOFichier.bfSize - BmpINFOFichier.bfOffBits;
     }
      DimTableauPixels := BmpINFO.biHeight * 
              ((((BmpINFO.biWidth * BmpINFO.biBitCount ) + 31) And -31) Shr 3);


     {Allocation de mémoire pour récupérer la structure : "TBITMAPINFO"
          BITMAPINFOHEADER + Table de couleur (TRGBQUAD)}
      GetMem( pBmpINFO, DimBitmapInfo );

	  
     {Copier la structure BITMAPINFOHEADER à l'intérieur de TBITMAPINFO}
      CopyMemory( pBmpINFO, @BmpInfo, SizeOf(TBITMAPINFOHEADER) );

	  
     {Ajouter la palette(TRGBQUAD) à la structure TBITMAPINFO et
	     par la même occasion récupérer un pointeur sur la palette}
      PtrDebutPal := Pointer( Cardinal(pBmpINFO) + SizeOf(TBITMAPINFOHEADER) );
      BlockRead( BmpFichier, TBITMAPINFO( PtrDebutPal^ ), GrosseurPal );

	  
     {Allouer de la mémoire pour récupérer les pixels du Bitmap}
      GetMem( pTabPixels, DimTableauPixels );

	  
     {Positionner le curseur de lecture du fichier, sur le début du
      tableau de pixels}
      Seek( BmpFichier, BmpINFOFichier.bfOffBits );


     {Récupérer le tableau de pixels en mémoire}
      BlockRead( BmpFichier, pTabPixels^, DimTableauPixels );

	  
     {Fermeture du fichier}
      CloseFile( BmpFichier );
End;