Reading Image Headers to Get Width and Height

Download source - 9.88 KB

Introduction

I had a requirement to cache the orientation of JPEGs within a set of folders. The easiest way is just to load each image and work out whether it is landscape or portrait based on the width and height, possibly like this:

public bool IsLandscape(string path)
{
  using (Bitmap b = new Bitmap(path))
  {
    return b.Width > b.Height;
  }
}

This is great when there are only a few images but it is incredibly slow as the framework has to load the image into GDI and then marshal it over to .NET.

Improvement One - Multi-Threading

Performance could be improved by creating a queue of image paths and then loading them on multiple threads potentially using the ThreadPool bound to the number of physical core on the machine.

foreach (string path in paths)
{
  // add each path as a task in the thread pool
  ThreadPool.QueueUserWorkItem(new WaitCallback(ThreadCallback), path);
}

// wait until all images have been loaded
lock (this.Landscapes)
{
  Monitor.Wait(this.Landscapes);
}

private void ThreadCallback(object stateInfo)
{
  string path = (string)stateInfo;
  bool isLandscape = this.IsLandscape(path);
           
  lock (this.Landscapes)
  {
    if (isLandscape)
    {
      this.Landscapes.Add(path);
    }

    imagesRemaining--;

    if (imagesRemaining == 0)
    {
      // all images loaded, signal the main thread
      Monitor.Pulse(this.Landscapes);
    }
  }
}

Ok so performance is improved however new issues arise:

The main performance bottleneck is IO bound as loading an image from disk and converting it to a usable bitmap takes phenomenally longer than getting the size once it is in memory.
Bitmaps required a lot of memory, we can be talking about upwards of ten megabytes depending on the total number of pixels.
Most computers only have a couple of core so threading is of limited benefit.

Improvement Two – Reading the Headers

It occurred to me that there were a number of applications that read width and height information remarkably quickly, too fast to have read the whole file; turns out there are headers in image files which contain width and height – bingo.

After some searching, I came across this buried forum post which gives a great example of how to read not only JPEG headers but also GIF, PNG and BMP:

The post is great although I found it couldn't read all JPEG file headers for some reason. Firstly I modified DecodeJfif so that the chunk length could be an unsigned 16 bit integer (ushort in C#):

private static Size DecodeJfif(BinaryReader binaryReader)
{
  while (binaryReader.ReadByte() == 0xff)
  {
    byte marker = binaryReader.ReadByte();
    short chunkLength = ReadLittleEndianInt16(binaryReader);
    if (marker == 0xc0)
    {
      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);
}

Secondly, I added a try/catch block around getting the dimensions so that if the header isn't present, it falls back to the slow way:

public static Size GetDimensions(string path)
{
  try
  {
    using (BinaryReader binaryReader = new BinaryReader(File.OpenRead(path)))
    {
      try
      {
        return GetDimensions(binaryReader);
      }
      catch (ArgumentException e)
      {
        string newMessage = string.Format("{0} file: '{1}' ", errorMessage, path);

        throw new ArgumentException(newMessage, "path", e);
      }
    }
  }
  catch (ArgumentException)
  {
    //do it the old fashioned way

    using (Bitmap b = new Bitmap(path))
    {
      return b.Size;
    }              
  }
}

Reading just the headers produced such a massive performance improvement that I removed the multi-threading and just used one thread to process each image sequentially.

Putting It All Together

To further increase performance, I created an XML cache file with width, height and date modified information so that only images that had changed would have their headers checked. I didn't want the XML file to be saved every time an image was cached as that would be a new bottleneck. So I added a timer which saved the data to XML 5 seconds after the save method was called. I used Linq-To-XML to save the list of ImageFileAttributes to disk:

class ImageListToXml
{
  private const string XmlRoot = "Cache";
  private const string XmlImagePath = "ImagePath";
  private const string XmlWidth = "Width";
  private const string XmlHeight = "Height";
  private const string XmlImageCached = "ImageCached";
  private const string XmlLastModified = "LastModified";

  public static void LoadFromXml(string filePath, ImageList list)
  {
    list.Clear();
    XDocument xdoc = XDocument.Load(filePath);
    list.AddRange(
      from d in xdoc.Root.Elements()
      select new ImageFileAttributes(
        (string)d.Attribute(XmlImagePath),
        new Size(
          (int)d.Attribute(XmlWidth),
          (int)d.Attribute(XmlHeight)),
        (DateTime)d.Attribute(XmlLastModified)));
  }

  public static void SaveAsXml(string filePath, ImageList list)
  {
    XElement xml = new XElement(XmlRoot,
      from d in list
      select new XElement(XmlRoot,
        new XAttribute(XmlImagePath, d.Path),
        new XAttribute(XmlWidth, d.Size.Width),
        new XAttribute(XmlHeight, d.Size.Height),
        new XAttribute(XmlLastModified, d.LastModified ?? DateTime.MinValue)));

    xml.Save(filePath);
  }
}

Results

Using header produces tremendous performance improvements and caching the dimension results from the images takes the process from seconds to milliseconds.

Performance improvements for 563 images, from 198257ms to 69ms.

This console output gives an indication of the orders of magnitude that can be gained; we are talking about improving the total time taken from more than 3 minutes to less than one-tenth of a second.