Tester si un fichier BMP est correct

Version imprimable

02/07/2013, 16h22
Mercusyo

Tester si un fichier BMP est correct

Bonjour,

J'aimerais savoir s'il existe en C++ Builder une méthode permettant de tester si un fichier BMP est correctement formaté ? (en gros, est-ce qu'un fichier BMP est bien un BMP, mais pas un fichier renommé en .bmp par exemple) ou est-ce que nous devons utiliser l'API Windows, style avec LoadImage() ou LoadBitmap()?

Merci,
02/07/2013, 17h47
yarp

Bien entendu il est possible d'utiliser les API et en cas d'échec du chargement en déduire que le BMP est mal formaté. TBitmap est bien écrit il n'y a pas besoin de lui substituer le SDK pour ça.
Tout dépend du contexte dans lequel tu fais ça:
- est-ce que tu veux juste savoir quels sont les BMP mal formatés ?
- est-ce que tu veux connaitre le format des images réel de ces images ?
- est-ce que mal formé indique uniquement une conversion de format ou de possibles erreurs aux niveau des données

Quoi qu'il en soit à part avoir la liste des images non chargées, pour savoir tout le reste il faut descendre plus bas que ce qu les API prennent généralement en charge (un loader à pour but de charger une image pas de faire un rapport complet).

A présent pour détecter rapidement si une image est un Bitmap il faut de lire le header du bitmap (avec fopen ou ReadFile). La technique consiste à lire les 2 premiers caractères qui sont 'BM' pour un bitmap. Si ce n'est pas le cas on arrête là, sinon on lit la suite du header (mais attention il y a plusieurs formats, 2 je crois). Mais dans ton cas il peut suffire de lire 'BM', car si ce n'est pas 'BM' c'est que ce n'est pas un bitmap n'est-ce pas ?
Pour un JPEG c'est pareil (identifiant + header).
Pour un PNG aussi.

Il y a pas de code un peu partout pour lire un BMP. Tu trouveras facilement.
Le Top n'est pas forcément dans les librairies les plus connues comme ImageMagick car là le code est plutôt complexe. CXImage est pas mal.
03/07/2013, 10h25
Mercusyo

ok merci yarp pour ton aide, effectivement, je veux faire une méthode qui liste les fichiers qui ne sont pas des BMP dans un répertoire donné; donc la solution de lire le "header" me suffira.
Je regarde tout ça et encore merci

Ok, merci pour le tuyau, j'ai implémenté le code suivant qui fonctionne :

Code:

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
bool __stdcall isBMPFile(String sFile)
{
	FILE *pFile = NULL;
	long lSize;
	char *buffer = NULL;
	AnsiString sResultat = "";
	size_t result;
	bool bResultat = false;
	// lecture binaire du fichier ...
	pFile = fopen (static_cast<AnsiString>(sFile).c_str(), "rb");
	if (pFile == NULL)
	{
		ShowMessage("The file does not exist");
		return bResultat ;
	}
	// Taille du fichier
	fseek (pFile , 0 , SEEK_END);
	lSize = ftell (pFile);
	rewind (pFile);
	// Allocation mémoire ...
	buffer = (char*) malloc (sizeof(char) * lSize);
	if (buffer == NULL)
	{
		ShowMessage("A memory error occured");
		return bResultat ;
	}
	// Copie du fichier dans le buffer ...
	result = fread (buffer, 1, lSize, pFile);
	if (result != lSize)
	{
		ShowMessage("Reading file error");
		return bResultat ;
	}
	sResultat = buffer;
	// http://fr.wikipedia.org/wiki/Windows_bitmap
	if (sResultat.SubString(0,2).UpperCase() == "BM")
		bResultat = true;
	return bResultat ;
}

Tu as vraiment besoin de lire tout le fichier juste pour lire si ça commence par BM ?
Dommage de ne pas avoir suivi le conseil de yarp en ne lisant que le header !

Tu pourrais éliminer sResultat pour réduire la conso mémoire et CPU

Code:

bResultat = ((lSize > 2) && (UpCase(buffer[0]) == 'B') && (UpCase(buffer[1]) == 'M')

Sinon, pourquoi ne pas utiliser un TFileStream cela éviterait le cast en AnsiString en utilisant le TFileName (Ansi sous 2007, Wide sous 2009)

Tu peux t'appuyer sur la VCL :

Code:

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
bool __stdcall isBMPFile(const String sFileName, int *ErrorCode = NULL)
{
  bool Result = false;
  if (ErrorCode) *ErrorCode = 0;
 
  try
  {
    TBitmap* BMP = new TBitmap();
    try
    {
      BMP->LoadFromFile(sFileName);
      Result = true;
    }
    __finally
    {
      delete BMP;
    }	
  }
  catch(const EInvalidGraphic &eig)
  {
    if (ErrorCode) *ErrorCode = -3; // not BM or Empty
  }
  catch(const EFOpenError &efoe)
  {
    if (ErrorCode) *ErrorCode = -2; // "The file does not exist" 
  }
  catch(const Exception &e)
  {
    if (ErrorCode) *ErrorCode = -1; // "A memory error occured" ou "Reading file error"
  }
 
  return Result;
}

ou en s'inspirant du ReadStream du TBitmap

Code:

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
bool __stdcall isBMPFile(const String sFileName, int *ErrorCode = NULL)
{
  bool Result = false;
  if (ErrorCode) *ErrorCode = 0;
 
  try
  {
    TFileStream* Stream = new TFileStream(sFileName, fmOpenRead);
    try
    {
      if (Stream->Size > 0)
      {
        TBitmapFileHeader Bmf;
        Stream->Read((BYTE*)&Bmf, sizeof(Bmf));
        if (Bmf.bfType == 0x4D42) // BM en Hexa, voir TBitmap.ReadStream dans Graphics.pas
         Result = true; 
       else
         if (ErrorCode) *ErrorCode = -3; // not BM  
     }      
     else
       if (ErrorCode) *ErrorCode = -4; // Empty !
    }
    __finally
    {
      delete Stream;
    }
  }
  catch(const EFOpenError &efoe)
  {
    if (ErrorCode) *ErrorCode = -2; // "The file does not exist" 
  }
  catch(const Exception &e)
  {
    if (ErrorCode) *ErrorCode = -1; // "A memory error occured" ou "Reading file error"
  }  
  return Result;
}

04/07/2013, 13h05
yarp

Tu as raison Shai le mieux est de regarder dans le source de la VCL.

En suivant le lien donné par Mercusyo sur la page Wikipédia du BMP je viens de me rappeler qu'on nomme ces codes identifiant les formats de fichier: "magic number".
Donc juste pour info, ça peut servir pour un google search.
05/07/2013, 16h54
Mercusyo

Ok merci à vous pour ces précisions, j'ai adapté mon code dans ce sens.