Getting image dimensions without reading the entire file

Question

Is there a cheap way to get the dimensions of an image (jpg, png, ...)? Preferably, I would like to achieve this using only the standard class library (because of hosting restrictions). I know that it should be relatively easy to read the image header and parse it myself, but it seems that something like this should be already there. Also, I’ve verified that the following piece of code reads the entire image (which I don’t want):

using System;
using System.Drawing;

namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Image img = new Bitmap("test.png");
            System.Console.WriteLine(img.Width + " x " + img.Height);
        }
    }
}

Solution 1

Your best bet as always is to find a well tested library. However, you said that is difficult, so here is some dodgy largely untested code that should work for a fair number of cases:

using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;

namespace ImageDimensions
{
    public static class ImageHelper
    {
        const string errorMessage = "Could not recognize image format.";

        private static Dictionary<byte[], Func<BinaryReader, Size>> imageFormatDecoders = new Dictionary<byte[], Func<BinaryReader, Size>>()
        {
            { new byte[]{ 0x42, 0x4D }, DecodeBitmap},
            { new byte[]{ 0x47, 0x49, 0x46, 0x38, 0x37, 0x61 }, DecodeGif },
            { new byte[]{ 0x47, 0x49, 0x46, 0x38, 0x39, 0x61 }, DecodeGif },
            { new byte[]{ 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A }, DecodePng },
            { new byte[]{ 0xff, 0xd8 }, DecodeJfif },
        };

        /// <summary>
        /// Gets the dimensions of an image.
        /// </summary>
        /// <param name="path">The path of the image to get the dimensions of.</param>
        /// <returns>The dimensions of the specified image.</returns>
        /// <exception cref="ArgumentException">The image was of an unrecognized format.</exception>
        public static Size GetDimensions(string path)
        {
            using (BinaryReader binaryReader = new BinaryReader(File.OpenRead(path)))
            {
                try
                {
                    return GetDimensions(binaryReader);
                }
                catch (ArgumentException e)
                {
                    if (e.Message.StartsWith(errorMessage))
                    {
                        throw new ArgumentException(errorMessage, "path", e);
                    }
                    else
                    {
                        throw e;
                    }
                }
            }
        }

        /// <summary>
        /// Gets the dimensions of an image.
        /// </summary>
        /// <param name="path">The path of the image to get the dimensions of.</param>
        /// <returns>The dimensions of the specified image.</returns>
        /// <exception cref="ArgumentException">The image was of an unrecognized format.</exception>    
        public static Size GetDimensions(BinaryReader binaryReader)
        {
            int maxMagicBytesLength = imageFormatDecoders.Keys.OrderByDescending(x => x.Length).First().Length;

            byte[] magicBytes = new byte[maxMagicBytesLength];

            for (int i = 0; i < maxMagicBytesLength; i += 1)
            {
                magicBytes[i] = binaryReader.ReadByte();

                foreach(var kvPair in imageFormatDecoders)
                {
                    if (magicBytes.StartsWith(kvPair.Key))
                    {
                        return kvPair.Value(binaryReader);
                    }
                }
            }

            throw new ArgumentException(errorMessage, "binaryReader");
        }

        private static bool StartsWith(this byte[] thisBytes, byte[] thatBytes)
        {
            for(int i = 0; i < thatBytes.Length; i+= 1)
            {
                if (thisBytes[i] != thatBytes[i])
                {
                    return false;
                }
            }
            return true;
        }

        private static short ReadLittleEndianInt16(this BinaryReader binaryReader)
        {
            byte[] bytes = new byte[sizeof(short)];
            for (int i = 0; i < sizeof(short); i += 1)
            {
                bytes[sizeof(short) - 1 - i] = binaryReader.ReadByte();
            }
            return BitConverter.ToInt16(bytes, 0);
        }

        private static int ReadLittleEndianInt32(this BinaryReader binaryReader)
        {
            byte[] bytes = new byte[sizeof(int)];
            for (int i = 0; i < sizeof(int); i += 1)
            {
                bytes[sizeof(int) - 1 - i] = binaryReader.ReadByte();
            }
            return BitConverter.ToInt32(bytes, 0);
        }

        private static Size DecodeBitmap(BinaryReader binaryReader)
        {
            binaryReader.ReadBytes(16);
            int width = binaryReader.ReadInt32();
            int height = binaryReader.ReadInt32();
            return new Size(width, height);
        }

        private static Size DecodeGif(BinaryReader binaryReader)
        {
            int width = binaryReader.ReadInt16();
            int height = binaryReader.ReadInt16();
            return new Size(width, height);
        }

        private static Size DecodePng(BinaryReader binaryReader)
        {
            binaryReader.ReadBytes(8);
            int width = binaryReader.ReadLittleEndianInt32();
            int height = binaryReader.ReadLittleEndianInt32();
            return new Size(width, height);
        }

        private static Size DecodeJfif(BinaryReader binaryReader)
        {
            while (binaryReader.ReadByte() == 0xff)
            {
                byte marker = binaryReader.ReadByte();
                short chunkLength = binaryReader.ReadLittleEndianInt16();

                if (marker == 0xc0)
                {
                    binaryReader.ReadByte();

                    int height = binaryReader.ReadLittleEndianInt16();
                    int width = binaryReader.ReadLittleEndianInt16();
                    return new Size(width, height);
                }

                binaryReader.ReadBytes(chunkLength - 2);
            }

            throw new ArgumentException(errorMessage);
        }
    }
}

Hopefully the code is fairly obvious. To add a new file format you add it to imageFormatDecoders with the key being an array of the "magic bits" which appear at the beginning of every file of the given format and the value being a function which extracts the size from the stream. Most formats are simple enough, the only real stinker is jpeg.

Solution 2

using (FileStream file = new FileStream(this.ImageFileName, FileMode.Open, FileAccess.Read))
{
    using (Image tif = Image.FromStream(stream: file, 
                                        useEmbeddedColorManagement: false,
                                        validateImageData: false))
    {
        float width = tif.PhysicalDimension.Width;
        float height = tif.PhysicalDimension.Height;
        float hresolution = tif.HorizontalResolution;
        float vresolution = tif.VerticalResolution;
     }
}

the validateImageData set to false prevents GDI+ from performing costly analysis of the image data, thus severely decreasing load time. This question sheds more light on the subject.

Solution 3

Have you tried using the WPF Imaging classes? System.Windows.Media.Imaging.BitmapDecoder, etc.?

I believe some effort was into making sure those codecs only read a subset of the file in order to determine header information. It's worth a check.

Solution 4

I was looking for something similar a few months earlier. I wanted to read the type, version, height and width of a GIF image but couldn’t find anything useful online.

Fortunately in case of GIF, all the required information was in the first 10 bytes:

Type: Bytes 0-2
Version: Bytes 3-5
Height: Bytes 6-7
Width: Bytes 8-9

PNG are slightly more complex (width and height are 4-bytes each):

Width: Bytes 16-19
Height: Bytes 20-23

As mentioned above, wotsit is a good site for detailed specs on image and data formats though the PNG specs at pnglib are much more detailed. However, I think the Wikipedia entry on PNG and GIF formats is the best place to start.

Here’s my original code for checking GIFs, I have also slapped together something for PNGs:

using System;
using System.IO;
using System.Text;

public class ImageSizeTest
{
    public static void Main()
    {
        byte[] bytes = new byte[10];

        string gifFile = @"D:\Personal\Images&Pics\iProduct.gif";
        using (FileStream fs = File.OpenRead(gifFile))
        {
            fs.Read(bytes, 0, 10); // type (3 bytes), version (3 bytes), width (2 bytes), height (2 bytes)
        }
        displayGifInfo(bytes);

        string pngFile = @"D:\Personal\Images&Pics\WaveletsGamma.png";
        using (FileStream fs = File.OpenRead(pngFile))
        {
            fs.Seek(16, SeekOrigin.Begin); // jump to the 16th byte where width and height information is stored
            fs.Read(bytes, 0, 8); // width (4 bytes), height (4 bytes)
        }
        displayPngInfo(bytes);
    }

    public static void displayGifInfo(byte[] bytes)
    {
        string type = Encoding.ASCII.GetString(bytes, 0, 3);
        string version = Encoding.ASCII.GetString(bytes, 3, 3);

        int width = bytes[6] | bytes[7] << 8; // byte 6 and 7 contain the width but in network byte order so byte 7 has to be left-shifted 8 places and bit-masked to byte 6
        int height = bytes[8] | bytes[9] << 8; // same for height

        Console.WriteLine("GIF\nType: {0}\nVersion: {1}\nWidth: {2}\nHeight: {3}\n", type, version, width, height);
    }

    public static void displayPngInfo(byte[] bytes)
    {
        int width = 0, height = 0;

        for (int i = 0; i <= 3; i++)
        {
            width = bytes[i] | width << 8;
            height = bytes[i + 4] | height << 8;            
        }

        Console.WriteLine("PNG\nWidth: {0}\nHeight: {1}\n", width, height);  
    }
}

Solution 5

Based on the answers so far and some additional searching, it seems that in the .NET 2 class library there is no functionality for it. So I decided to write my own. Here is a very rough version of it. At the moment, I needed it only for JPG’s. So it completes the answer posted by Abbas.

There is no error checking or any other verification, but I currently need it for a limited task, and it can be eventually easily added. I tested it on some number of images, and it usually does not read more that 6K from an image. I guess it depends on the amount of the EXIF data.

using System;
using System.IO;

namespace Test
{

    class Program
    {

        static bool GetJpegDimension(
            string fileName,
            out int width,
            out int height)
        {

            width = height = 0;
            bool found = false;
            bool eof = false;

            FileStream stream = new FileStream(
                fileName,
                FileMode.Open,
                FileAccess.Read);

            BinaryReader reader = new BinaryReader(stream);

            while (!found || eof)
            {

                // read 0xFF and the type
                reader.ReadByte();
                byte type = reader.ReadByte();

                // get length
                int len = 0;
                switch (type)
                {
                    // start and end of the image
                    case 0xD8: 
                    case 0xD9: 
                        len = 0;
                        break;

                    // restart interval
                    case 0xDD: 
                        len = 2;
                        break;

                    // the next two bytes is the length
                    default: 
                        int lenHi = reader.ReadByte();
                        int lenLo = reader.ReadByte();
                        len = (lenHi << 8 | lenLo) - 2;
                        break;
                }

                // EOF?
                if (type == 0xD9)
                    eof = true;

                // process the data
                if (len > 0)
                {

                    // read the data
                    byte[] data = reader.ReadBytes(len);

                    // this is what we are looking for
                    if (type == 0xC0)
                    {
                        width = data[1] << 8 | data[2];
                        height = data[3] << 8 | data[4];
                        found = true;
                    }

                }

            }

            reader.Close();
            stream.Close();

            return found;

        }

        static void Main(string[] args)
        {
            foreach (string file in Directory.GetFiles(args[0]))
            {
                int w, h;
                GetJpegDimension(file, out w, out h);
                System.Console.WriteLine(file + ": " + w + " x " + h);
            }
        }

    }
}

View more solutions

Comments

[wnoise]

It would help if you were a bit more specific in the question proper. The tags have told me .net and c#, and you want standard library, but what are these hosting restrictions you mentions?

[Charlie]

If you have access to the System.Windows.Media.Imaging namespace (in WPF), see this SO question: stackoverflow.com/questions/784734/…

[Jan Zich]

Thank you. It seems reasonable, but my hosting has .NET 2.

[ojrac]

Excellent answer. If you can get a reference to PresentationCore in your project, this is the way to go.

[Vilx-]

Agreed, JPEG sucks. Btw - a note for the people who want to use this code in the future: this is indeed untested. I've gone through it with a fine comb, and here's what I found: BMP format has another (ancient) header variation where dimensions are 16-bit; plus height can be negative (drop the sign then). As for JPEG - 0xC0 isn't the only header. Basically all of 0xC0 to 0xCF except 0xC4 and 0xCC are valid headers (you can easily get them in interlaced JPGs). And, to make things more fun, height can be 0 and specified later in a 0xDC block. See w3.org/Graphics/JPEG/itu-t81.pdf

[Nariman]

In my unit tests, these classes don't perform any better than GDI... still require ~32K to read JPEGs dimensions.

[Zorkind]

I used your solution as last resource mixed with ICR's solution up above. Had problems with JPEG, and solved with this.

[Chuck Savage]

So to get the OP's image dimensions, how do you use the BitmapDecoder?

[Charlie]

See this SO question: stackoverflow.com/questions/784734/…

[drzaus]

is it safe to assume that using new AtalaImage(filepath).Width does something similar?

[drzaus]

or just Atalasoft.Imaging.Codec.RegisteredDecoders.GetImageInfo ( fullPath ) .Size

[SirDarius]

The first (AtalaImage) reads the entire image -- the second (GetImageInfo) reads the minimal metadata to get the elements of an image info object.

[Ryan Barton]

Tweaked the DecodeJfif method above to expand the original (marker == 0xC0) check to accept 0xC1 and 0xC2 as well. These other start-of-frame headers SOF1 and SOF2 encode width/height in the same byte positions. SOF2 is fairly common.

[Eregrith]

Standard warning: You should never write throw e; but simply throw; instead. Your XML doc comments on the second GetDimensions also show path instead of binaryReader

[Steve Johnson]

@RyanBarton Can you post your code changes please? It will really help me a lot with similar problem. Thanks.

[Ryan Barton]

@SteveJohnson: edited code to include SOF1/SOF2 checks in DecodeJfif.

[Jason Sturges]

Width and height are reversed when I try this.

[AeonOfTime]

I recently tried this in a project where I had to query the size of 2000+ images (jpg and png mostly, very mixed sizes), and it was indeed much faster than the traditional way using new Bitmap().

[cwills]

Also, seems this code doesn't accept JPEGs encoded in EXIF/TIFF format which is output by many digital cameras. It only supports JFIF.

[dynamichael]

System.Drawing.Image.FromStream(stream, false, false) will give you the dimensions without loading the entire image, and it works on any image .Net can load. Why this messy and incomplete solution has so many upvotes is beyond understanding.

[dynamichael]

Best answer. Quick, clean, and effective.

[zhengchun]

This function is perfect on windows. but it not working on linux, it will still read entire file on linux. (.net core 2.2)

[MattyMatt]

@dynamichael there can be situations when you don't have access to that lib, so these solutions are needed.

[dynamichael]

@MattyMatt2 From the OP: "Preferably, I would like to achieve this using only the standard class library"

[Andrew Morton]

@JasonSturges You may need to take into account the Exif Orientation tag.

[Markus]

Thanks for getting webp started. DecodeWebP works only for Webp Lossy images - developers.google.com/speed/webp/gallery1

[Nyerguds]

@dynamichael System.Drawing is not a standard library these days; it relies on GDI+, and there are plenty of c# platforms on which it is not available.

[Nyerguds]

By the way, BinaryReader is specifically specced to read little endian. The helper functions are unnecessary. In fact, you need a big-endian read for the PNG part; png internals are all big-endian.

[Nyerguds]

The internals of png are all big-endian (gif too, I believe). And BinaryReader always reads little-endian anyway, regardless of system endianness, so the existing helper functions are useless.

[Anomalous Underdog]

@RyanBarton: Am I missing something? I checked the revisions (stackoverflow.com/posts/112711/revisions) and the only changes made were spelling changes. No changes were made in the DecodeJfif method.

[Samuel Johnson]

I cant seem to get any jpeg i try to decode using this example or the other; after it reads the 0xff, the next bytes are not C0 or C2 so it just jumps straight out or fails trying to read beyond end of stream

[Karl Stephen]

@SamuelJohnson Possible reasons : Most likely, your jpegs only have SOF1 and SOF2 segments (requires 0xC1 and 0xC2 equality on the marker check - edit your code, it's missing here). Possibly, you made some changes, or your copy is incomplete, which may lead to the logic exiting the loop prematurely. Or, your system is bigEndian (BE) : the littleEndian (LE) functions here are not reading LE data, they are converting BE data from the jpeg to LE and works only on a LE system like on a Windows PC. On a BE system, you'll likely never find the SOF segment and exceed the length of the file.

[Karl Stephen]

@Nyerguds You are correct, but the issue here is the code assumes you are on a little endian system (it will probably fail on a big endian one, I didn't check). The meaning of each function, let's say ReadLittleEndianInt16 is not "I'm going to read a little endian binary data and get the value in memory", what they do is "I'm assuming those datas are big endian, and I'll swap the bytes for a little endian configuration no matter the endianness of the system I'm on".