Getting image dimensions without reading the entire file

C#.NetImageImage Manipulation

C# Problem Overview

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

C# Solutions

Solution 1 - C#

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 - C#

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 - C#

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 - C#

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 - C#

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

    }
}

Solution 6 - C#

Updated ICR's answer to support progressive jPegs & WebP as well :)

internal static class ImageHelper
{
	const string errorMessage = "Could not recognise 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 },
		{ new byte[] { 0x52, 0x49, 0x46, 0x46 }, DecodeWebP },
	};

	/// <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 unrecognised 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(StartsWith(magicBytes, kvPair.Key))
				{
					return kvPair.Value(binaryReader);
				}
			}
		}

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

	private static bool StartsWith(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(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(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 = ReadLittleEndianInt32(binaryReader);
		int height = ReadLittleEndianInt32(binaryReader);
		return new Size(width, height);
	}

	private static Size DecodeJfif(BinaryReader binaryReader)
	{
		while(binaryReader.ReadByte() == 0xff)
		{
			byte marker = binaryReader.ReadByte();
			short chunkLength = ReadLittleEndianInt16(binaryReader);
			if(marker == 0xc0 || marker == 0xc2) // c2: progressive
			{
				binaryReader.ReadByte();
				int height = ReadLittleEndianInt16(binaryReader);
				int width = ReadLittleEndianInt16(binaryReader);
				return new Size(width, height);
			}

			if(chunkLength < 0)
			{
				ushort uchunkLength = (ushort)chunkLength;
				binaryReader.ReadBytes(uchunkLength - 2);
			}
			else
			{
				binaryReader.ReadBytes(chunkLength - 2);
			}
		}

		throw new ArgumentException(errorMessage);
	}

	private static Size DecodeWebP(BinaryReader binaryReader)
	{
		binaryReader.ReadUInt32(); // Size
		binaryReader.ReadBytes(15); // WEBP, VP8 + more
		binaryReader.ReadBytes(3); // SYNC

		var width = binaryReader.ReadUInt16() & 0b00_11111111111111; // 14 bits width
		var height = binaryReader.ReadUInt16() & 0b00_11111111111111; // 14 bits height

		return new Size(width, height);
	}
	
}

Solution 7 - C#

I did this for PNG file

  var buff = new byte[32];
        using (var d =  File.OpenRead(file))
        {            
            d.Read(buff, 0, 32);
        }
        const int wOff = 16;
        const int hOff = 20;            
        var Widht =BitConverter.ToInt32(new[] {buff[wOff + 3], buff[wOff + 2], buff[wOff + 1], buff[wOff + 0],},0);
        var Height =BitConverter.ToInt32(new[] {buff[hOff + 3], buff[hOff + 2], buff[hOff + 1], buff[hOff + 0],},0);

Solution 8 - C#

Yes, you can absolutely do this and the code depends on the file format. I work for an imaging vendor (Atalasoft), and our product provides a GetImageInfo() for every codec that does the minimum to find out dimensions and some other easy to get data.

If you want to roll your own, I suggest starting with wotsit.org, which has detailed specs for pretty much all image formats and you will see how to identify the file and also where information in it can be found.

If you are comfortable working with C, then the free jpeglib can be used to get this information too. I would bet that you can do this with .NET libraries, but I don't know how.

Solution 9 - C#

It's going to depend on the file format. Usually they will state it up in the early bytes of the file. And, usually, a good image-reading implementation will take that into account. I can't point you to one for .NET though.

Categories
Recommended C# Solutions
Recommended .Net Solutions
Recommended Image Solutions
Recommended Image Manipulation Solutions

Previous Solution:

Resizing an Image without losing any quality

C#ImageImage Scaling

Next Solution:

How do I ignore ampersands in a SQL script running from SQL Plus?

SqlOracleSqlplus

Attributions

All content for this solution is sourced from the original question on Stackoverflow.

The content on this page is licensed under the Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) license.

Content TypeOriginal AuthorOriginal Content on Stackoverflow
QuestionJan ZichView Question on Stackoverflow
Solution 1 - C#ICRView Answer on Stackoverflow
Solution 2 - C#KorayView Answer on Stackoverflow
Solution 3 - C#Frank KruegerView Answer on Stackoverflow
Solution 4 - C#AbbasView Answer on Stackoverflow
Solution 5 - C#Jan ZichView Answer on Stackoverflow
Solution 6 - C#bangView Answer on Stackoverflow
Solution 7 - C#Danny DView Answer on Stackoverflow
Solution 8 - C#Lou FrancoView Answer on Stackoverflow
Solution 9 - C#easeoutView Answer on Stackoverflow