c# - online - metapicz

C#¿Cómo puedo probar que un archivo es un jpeg?

Question

Usando C # ¿cómo puedo probar un archivo es un jpeg? ¿Debo verificar si tengo una extensión .jpg?

Gracias

Answer 1

Abra el archivo como una secuencia y busque el número mágico para JPEG.

Los archivos de imagen JPEG comienzan con FF D8 y terminan con FF D9. Los archivos JPEG / JFIF contienen el código ASCII para ''JFIF'' (4A 46 49 46) como una cadena terminada nula. Los archivos JPEG / Exif contienen el código ASCII para ''Exif'' (45 78 69 66) también como cadena terminada nula

Answer 2

Dependiendo del contexto en el que esté viendo este archivo, debe recordar que no puede abrir el archivo hasta que el usuario le indique que lo abra.

(El enlace es a una entrada del blog de Raymond Chen).

Answer 3

Dios mío, muchos de estos ejemplos de códigos son incorrectos, están equivocados.

Los archivos EXIF ​​tienen un marcador de 0xff * e1 *, los archivos JFIF tienen un marcador de 0xff * e0 *. Por lo tanto, todo el código que se basa en 0xffe0 para detectar un archivo JPEG perderá todos los archivos EXIF.

Aquí hay una versión que detectará ambas cosas, y puede modificarse fácilmente para que solo regrese para JFIF o solo para EXIF. (Útil al tratar de recuperar las imágenes de su iPhone, por ejemplo).

    public static bool HasJpegHeader(string filename)
    {
        try
        {
            // 0000000: ffd8 ffe0 0010 4a46 4946 0001 0101 0048  ......JFIF.....H
            // 0000000: ffd8 ffe1 14f8 4578 6966 0000 4d4d 002a  ......Exif..MM.*    
            using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.ReadWrite)))
            {
                UInt16 soi = br.ReadUInt16();  // Start of Image (SOI) marker (FFD8)
                UInt16 marker = br.ReadUInt16(); // JFIF marker (FFE0) EXIF marker (FFE1)
                UInt16 markerSize = br.ReadUInt16(); // size of marker data (incl. marker)
                UInt32 four = br.ReadUInt32(); // JFIF 0x4649464a or Exif  0x66697845

                Boolean isJpeg = soi == 0xd8ff && (marker & 0xe0ff) == 0xe0ff;
                Boolean isExif = isJpeg && four == 0x66697845;
                Boolean isJfif = isJpeg && four == 0x4649464a;

                if (isJpeg) 
                {
                    if (isExif)
                        Console.WriteLine("EXIF: {0}", filename);
                    else if (isJfif)
                        Console.WriteLine("JFIF: {0}", filename);
                    else
                        Console.WriteLine("JPEG: {0}", filename);
                }

                return isJpeg;
                return isJfif;
                return isExif;
            }
        }
        catch
        {
            return false;
        }
    }

Answer 4

El código aquí:

http://mark.michaelis.net/Blog/RetrievingMetaDataFromJPEGFilesUsingC.aspx

Le muestra cómo obtener los meta datos. Supongo que arrojaría una excepción si su imagen no era un JPEG válido.

Answer 5

Esto recorrerá cada archivo en el directorio actual y saldrá si los archivos encontrados con extensión JPG o JPEG son imágenes JPEG.

      foreach (FileInfo f in new DirectoryInfo(".").GetFiles())
        {
            if (f.Extension.ToUpperInvariant() == ".JPG"
                || f.Extension.ToUpperInvariant() == ".JPEG")
            {
                Image image = Image.FromFile(f.FullName);

                if (image.RawFormat == ImageFormat.Jpeg)
                {
                    Console.WriteLine(f.FullName + " is a Jpeg image");
                }
            }
        }

Answer 6

La mejor manera sería tratar de crear una imagen a partir del constructor Drawing.Bitmap (cadena) y ver si falla al hacerlo o lanza una excepción. El problema con algunas de las respuestas es este: en primer lugar, la extensión es puramente arbitraria, podría ser jpg, jpeg, jpe, bob, tim, lo que sea. En segundo lugar, solo usar el encabezado no es suficiente para estar 100% seguro. Definitivamente puede determinar que un archivo no es un jpeg, pero no puede garantizar que un archivo sea un jpeg, un archivo binario arbitrario podría tener la misma secuencia de bytes al inicio.

Answer 7

Lee los bytes del encabezado. Este artículo contiene información sobre varios formatos de imagen comunes, incluido JPEG:

Usar encabezados de archivos de imagen para verificar el formato de la imagen

Información de encabezado JPEG

Answer 8

Puede encontrar documentación sobre el formato de archivo jpeg, específicamente la información del encabezado. Luego intente leer esta información del archivo y compárela con los bytes del encabezado jpeg esperados.

Answer 9

Puede usar el método Path.GetExtension .

Answer 10

Puedes intentar cargar el archivo en una Imagen y luego verificar el formato

Image img = Image.FromFile(filePath);
bool isBitmap = img.RawFormat.Equals(ImageFormat.Jpeg);

Alternativamente, podría abrir el archivo y verificar el encabezado para obtener el tipo

Answer 11

Simplemente tome el tipo de archivo multimedia y verifique:

private bool isJpeg()
        {
string p = currFile.Headers.ContentType.MediaType;
            return p.ToLower().Equals("image/jpeg") || p.ToLower().Equals("image/pjpeg") || p.ToLower().Equals("image/png");
        }

Answer 12

Una vez que tenga la extensión, puede usar una expresión regular para validarla.

^.*/.(jpg|JPG)$

Answer 13

Varias opciones:

Puede verificar la extensión del archivo:

static bool HasJpegExtension(string filename)
{
    // add other possible extensions here
    return Path.GetExtension(filename).Equals(".jpg", StringComparison.InvariantCultureIgnoreCase)
        || Path.GetExtension(filename).Equals(".jpeg", StringComparison.InvariantCultureIgnoreCase);
}

o verifique el número mágico correcto en el encabezado del archivo:

static bool HasJpegHeader(string filename)
{
    using (BinaryReader br = new BinaryReader(File.Open(filename, FileMode.Open, FileAccess.Read)))
    {
        UInt16 soi = br.ReadUInt16();  // Start of Image (SOI) marker (FFD8)
        UInt16 marker = br.ReadUInt16(); // JFIF marker (FFE0) or EXIF marker(FF01)

        return soi == 0xd8ff && (marker & 0xe0ff) == 0xe0ff;
    }
}

Otra opción sería cargar la imagen y verificar el tipo correcto. Sin embargo, esto es menos eficiente (a menos que vaya a cargar la imagen de todos modos) pero probablemente le dará el resultado más confiable (tenga en cuenta el costo adicional de carga y descompresión, así como el posible manejo de excepciones):

static bool IsJpegImage(string filename)
{
    try
    {
        using (System.Drawing.Image img = System.Drawing.Image.FromFile(filename)) 
        {           
            // Two image formats can be compared using the Equals method
            // See http://msdn.microsoft.com/en-us/library/system.drawing.imaging.imageformat.aspx
            //
            return img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg);
        }
    }
    catch (OutOfMemoryException)
    {
        // Image.FromFile throws an OutOfMemoryException 
        // if the file does not have a valid image format or
        // GDI+ does not support the pixel format of the file.
        //
        return false;
    }
}

Answer 14

Verificar la extensión del archivo no es suficiente ya que el nombre del archivo podría estar mintiendo.

Una manera rápida y sucia es tratar de cargar la imagen usando la clase Image y capturando cualquier excepción:

Image image = Image.FromFile(@"c:/temp/test.jpg");

Esto no es ideal, ya que podría obtener cualquier tipo de excepción, como OutOfMemoryException, FileNotFoundException, etc., etc.

La forma más completa es tratar el archivo como binario y asegurarse de que el encabezado coincida con el formato JPG. Estoy seguro de que está descrito en alguna parte.

Answer 15

después de comprobar la extensión del archivo, lea los primeros cuatro bytes de la imagen y dos últimos bytes de la imagen como esta, hágalo por dos últimos bytes para el valor 255, 217 para otros archivos puede hacerlo Validar imagen desde el archivo en C # http://www.garykessler.net/library/file_sigs.html

// after check extention of file
byte[] ValidFileSignture = new byte[] { 255, 216, 255, 224 };
byte[] bufferforCheck = new byte[ValidFileSignture.Length];
Stream _inputStream = file.InputStream;
byte[] bufferforCheck1 = new byte[] { 255, 216, 255, 224 };
_inputStream.Read(bufferforCheck, 0, ValidFileSignture.Length);
if (!Enumerable.SequenceEqual(bufferforCheck, ValidFileSignture))
{
    //file OK
}

Answer 16

System.Web.MimeMapping.GetMimeMapping(filename).StartsWith("image/");
MimeMapping.GetMimeMapping produces these results:

file.jpg: image/jpeg
file.gif: image/gif
file.jpeg: image/jpeg
file.png: image/png
file.bmp: image/bmp
file.tiff: image/tiff
file.svg: application/octet-stream