Valider une image à partir d'un fichier en C#

Question

Je suis en train de charger une image à partir d'un fichier, et je veux savoir comment valider l'image avant qu'elle ne soit entièrement lue à partir du fichier.

string filePath = "image.jpg";
Image newImage = Image.FromFile(filePath);

Le problème se produit lorsque image.jpg n'est pas vraiment un jpg. Par exemple, si je crée un fichier texte vide et que je le renomme en image.jpg, une exception OutOfMemory sera levée lors du chargement du fichier image.jpg.

Je cherche une fonction qui validera une image à partir d'un flux ou d'un chemin de fichier de l'image.

Exemple de prototype de fonction

bool IsValidImage(string fileName);
bool IsValidImage(Stream imageStream);

Answer 1

Voici mon contrôle d'image. Je ne peux pas me fier aux extensions de fichiers et je dois vérifier le format par moi-même. Je charge les BitmapImages dans WPF à partir de tableaux d'octets et je ne connais pas le format à l'avance. WPF détecte bien le format mais ne vous indique pas le format d'image des objets BitmapImage (du moins, je ne connais pas de propriété pour cela). Et je ne veux pas recharger l'image avec System.Drawing uniquement pour détecter le format. Cette solution est rapide et fonctionne bien pour moi.

public enum ImageFormat
{
    bmp,
    jpeg,
    gif,
    tiff,
    png,
    unknown
}

public static ImageFormat GetImageFormat(byte[] bytes)
{
    // see http://www.mikekunz.com/image_file_header.html  
    var bmp    = Encoding.ASCII.GetBytes("BM");     // BMP
    var gif    = Encoding.ASCII.GetBytes("GIF");    // GIF
    var png    = new byte[] { 137, 80, 78, 71 };    // PNG
    var tiff   = new byte[] { 73, 73, 42 };         // TIFF
    var tiff2  = new byte[] { 77, 77, 42 };         // TIFF
    var jpeg   = new byte[] { 255, 216, 255, 224 }; // jpeg
    var jpeg2  = new byte[] { 255, 216, 255, 225 }; // jpeg canon

    if (bmp.SequenceEqual(bytes.Take(bmp.Length)))
        return ImageFormat.bmp;

    if (gif.SequenceEqual(bytes.Take(gif.Length)))
        return ImageFormat.gif;

    if (png.SequenceEqual(bytes.Take(png.Length)))
        return ImageFormat.png;

    if (tiff.SequenceEqual(bytes.Take(tiff.Length)))
        return ImageFormat.tiff;

    if (tiff2.SequenceEqual(bytes.Take(tiff2.Length)))
        return ImageFormat.tiff;

    if (jpeg.SequenceEqual(bytes.Take(jpeg.Length)))
        return ImageFormat.jpeg;

    if (jpeg2.SequenceEqual(bytes.Take(jpeg2.Length)))
        return ImageFormat.jpeg;

    return ImageFormat.unknown;
}

Answer 2

Utilisation de Windows Forms :

bool IsValidImage(string filename)
{
    try
    {
        using(Image newImage = Image.FromFile(filename))
        {}
    }
    catch (OutOfMemoryException ex)
    {
        //The file does not have a valid image format.
        //-or- GDI+ does not support the pixel format of the file

        return false;
    }
    return true;
}

Sinon, si vous êtes utiliser WPF vous pouvez faire ce qui suit :

bool IsValidImage(string filename)
{
    try
    {
        using(BitmapImage newImage = new BitmapImage(filename))
        {}
    }
    catch(NotSupportedException)
    {
        // System.NotSupportedException:
        // No imaging component suitable to complete this operation was found.
        return false;
    }
    return true;
}

Vous devez libérer l'image créée. Sinon, lorsque vous appelez cette fonction un grand nombre de fois, cela lancerait OutOfMemoryException parce que le système a manqué de ressources, et non parce que l'image est corrompue, ce qui donne un résultat incorrect. Si vous supprimez des images après cette étape, vous risquez de supprimer de bonnes images.

Answer 3

Les JPEG n'ont pas de définition d'en-tête formelle, mais ils ont une petite quantité de métadonnées que vous pouvez utiliser.

• Offset 0 (deux octets) : Marqueur JPEG SOI (FFD8 hex)
• Offset 2 (deux octets) : Largeur de l'image en pixels
• Offset 4 (deux octets) : Hauteur de l'image en pixels
• Offset 6 (octet) : Nombre de composants (1 = niveaux de gris, 3 = RGB)

Il y a quelques autres choses après ça, mais ce n'est pas important.

Vous pouvez ouvrir le fichier en utilisant un flux binaire, et lire ces données initiales, et vous assurer que OffSet 0 est 0, et que OffSet 6 est soit 1,2 ou 3.

Cela vous donnerait au moins un peu plus de précision.

Ou vous pouvez simplement piéger l'exception et passer à autre chose, mais je pensais que vous vouliez un défi :)

Answer 4

Eh bien, je me suis lancé et j'ai codé un ensemble de fonctions pour résoudre le problème. Il vérifie d'abord l'en-tête, puis tente de charger l'image dans un bloc try/catch. Il ne vérifie que les fichiers GIF, BMP, JPG et PNG. Vous pouvez facilement ajouter d'autres types en ajoutant un en-tête à imageHeaders.

static bool IsValidImage(string filePath)
{
    return File.Exists(filePath) && IsValidImage(new FileStream(filePath, FileMode.Open, FileAccess.Read));
}

static bool IsValidImage(Stream imageStream)
{
    if(imageStream.Length > 0)
    {
        byte[] header = new byte[4]; // Change size if needed.
        string[] imageHeaders = new[]{
                "\xFF\xD8", // JPEG
                "BM",       // BMP
                "GIF",      // GIF
                Encoding.ASCII.GetString(new byte[]{137, 80, 78, 71})}; // PNG

        imageStream.Read(header, 0, header.Length);

        bool isImageHeader = imageHeaders.Count(str => Encoding.ASCII.GetString(header).StartsWith(str)) > 0;
        if (isImageHeader == true)
        {
            try
            {
                Image.FromStream(imageStream).Dispose();
                imageStream.Close();
                return true;
            }

            catch
            {

            }
        }
    }

    imageStream.Close();
    return false;
}

Answer 5

Vous pouvez faire un typage approximatif en reniflant l'en-tête.

Cela signifie que chaque format de fichier que vous mettez en œuvre devra avoir un en-tête identifiable...

JPEG : Les 4 premiers octets sont FF D8 FF E0 (en fait juste les deux premiers octets le feraient pour un jpeg non jfif, plus d'info ici ).

GIF : Les 6 premiers octets sont soit "GIF87a", soit "GIF89a" (plus d'informations). ici )

PNG : Les 8 premiers octets sont : 89 50 4E 47 0D 0A 1A 0A (plus d'informations) ici )

TIFF : Les 4 premiers octets sont : II42 ou MM42 (plus d'infos ici )

etc... vous pouvez trouver des informations d'en-tête/format pour n'importe quel format graphique qui vous intéresse et ajouter des éléments à ceux qu'il gère si nécessaire. Ce que cela ne fera pas, c'est vous dire si le fichier est une version valide de ce type, mais cela vous donnera un indice sur "image not image ?". Il peut toujours s'agir d'une image corrompue ou incomplète, et donc planter à l'ouverture, donc un try catch autour de l'appel .FromFile est toujours nécessaire.