C# How can I test a file is a jpeg?

Question

Using C# how can I test a file is a jpeg? Should I check for a .jpg extension?

Thanks

Answer 1

You can use the Path.GetExtension Method.

Answer 2

You could find documentation on the jpeg file format, specifically the header information. Then try to read this information from the file and compare it to the expected jpeg header bytes.

Answer 3

The code here:

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

Shows you how to get the Meta Data. I guess that would throw an exception if your image wasn't a valid JPEG.

Answer 4

Once you have the extension you could use a regular expression to validate it.

^.*\.(jpg|JPG)$

Answer 5

Open the file as a stream and look for the magic number for JPEG.

JPEG image files begin with FF D8 and end with FF D9. JPEG/JFIF files contain the ASCII code for 'JFIF' (4A 46 49 46) as a null terminated string. JPEG/Exif files contain the ASCII code for 'Exif' (45 78 69 66) also as a null terminated string

Answer 6

You could try loading the file into an Image and then check the format

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

Alternatively you could open the file and check the header to get the type

Answer 7

Read the header bytes. This article contains info on several common image formats, including JPEG:

Using Image File Headers To Verify Image Format

JPEG Header Information

Answer 8

Checking the file extension is not enough as the filename might be lying.

A quick and dirty way is to try and load the image using the Image class and catching any exceptions:

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

This isn't ideal as you could get any kind of exception, such as OutOfMemoryException, FileNotFoundException, etc. etc.

The most thorough way is to treat the file as binary and ensure the header matches the JPG format. I'm sure it's described somewhere.

Answer 9

The best way would to try and create an image from it using the Drawing.Bitmap (string) constructor and see if it fails to do so or throws an exception. The problem with some of the answers are this: firstly, the extension is purely arbitrary, it could be jpg, jpeg, jpe, bob, tim, whatever. Secondly, just using the header isn't enough to be 100% sure. It can definately determine that a file isn't a jpeg but can't guarantee that a file is a jpeg, an arbitrary binary file could have the same byte sequence at the start.

Skizz

Answer 10

This will loop through each file in the current directory and will output if any found files with JPG or JPEG extension are Jpeg images.

      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 11

Depending on the context in which you're looking at this file, you need to remember that you can't open the file until the user tells you to open it.

(The link is to a Raymond Chen blog entry.)

Answer 12

Several options:

You can check for the file extension:

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);
}

or check for the correct magic number in the header of the file:

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

        return soi == 0xd8ff && jfif == 0xe0ff;
    }
}

Another option would be to load the image and check for the correct type. However, this is less efficient (unless you are going to load the image anyway) but will probably give you the most reliable result (Be aware of the additional cost of loading and decompression as well as possible exception handling):

static bool IsJpegImage(string filename)
{
    try
    {
        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;
    }
}