Drawing

Exif Properties in .Net - Part 3 : converting properties

Buz & Skup — Tue, 19 Apr 2005 12:20:00 GMT

In the first post of this Exif series, I talked about a technique for loading Exif properties as fast as GDI+ is able to do.
The second post was dealing with adding new properties to an empty image.

Now it's time to look more precisely at the Exif properties. How is a PropertyItem structured ?
The final goal of this post is to convert the raw data exposed by GDI+ (and the .Net Framework) into more useable data types.

An Exif property consists in the following information:

An identifier, determining the "meaning" of the property.
A data type, indicating how the data are represented.
A length (the number of bytes the property data contains).
A value which is a raw array of bytes.

The Exif property data type is a 16-bit integer, but it's quite simple to build an enum type that maps the values to a more comprehensive type :

Code Copy HideScrollFull

///
     <summary>

     /// Defines types for Exif Properties.
/// </summary>
public enum ExifPropertyType 
    {/// <summary>

     /// Specifies that the value 
      data member is an array of bytes.

     /// </summary>

     Byte = 1,

     /// <summary>

     /// Specifies that the value 
      data member is a null-terminated ASCII string.

     /// </summary>

     /// <remarks>If 
      you set <see 
      cref="PropertyItem.Type">PropertyItem.Type</see>
      to <see cref="PropertyItem.Type"/>, 
      you should set the length data member to the length of the string including the 
      NULL terminator. For example, the string HELLO would have a length of 6.</remarks>

     Ascii = 2,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed short (16-bit) integers.

     /// </summary>

     UInt16 = 3,

     /// <summary>

     /// Specifies that the value 
      data member is an array of unsigned long (32-bit) integers.

     /// </summary>

     UInt32 = 4,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of unsigned long integers. Each pair 
      represents a fraction; the first integer is the numerator and the second 
      integer is the denominator.

     /// </summary>

     URational = 5,

     /// <summary>

     /// Specifies that the value 
      data member is an array of bytes that can hold values of any data type.

     /// </summary>

     Raw = 7,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed long (32-bit) integers.

     /// </summary>

     Int32 = 9,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of signed long integers. Each pair represents 
      a fraction; the first integer is the numerator and the second integer is the 
      denominator.

     /// </summary>

     Rational = 10,

    }

As you can see in the code above, most of the data types are simple and can be directly mapped to .Net data types, excepted for rational and unsigned rational values. We need to create a .Net representation for each of them :

Rational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents a signed rational number.
/// </summary>
public class Rational 
    {private
      int numerator;
private int denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public Rational(int numerator,
      int denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public int Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public int Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

URational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents an unsigned rational number.
/// </summary>
public class URational 
    {private
      uint numerator;
private uint denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public URational(uint 
     numerator, uint denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public uint Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public uint Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

According to the Exif specification, properties may contain arrays of values. Our conversion tool must consequently have the following signature :

Code Copy

public
     static Array FromPropertyItem(PropertyItem propertyItem) {}

The conversion code is quite simple (a switch... case construct branching on different code depending on the data type).
When converting raw data into integers, just take care that Exif properties are stored as big endian values.

Code Copy HideScrollFull

#region
    References

using System;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text;

#endregion

     

     namespace ExifNative {///
      <summary>
/// Summary description for 
      ExifConvert.
/// </summary>
public sealed
      class ExifConvert {private
      ExifConvert() {}

/// <summary>
/// Converts a property item to 
       an array of objects.
/// </summary>
/// <param 
       name="propertyItem">The property item 
       to convert.</param>
/// <returns>An 
       array of <see cref="object"/>
       items.</returns>
public static Array 
      FromPropertyItem(PropertyItem propertyItem) {ExifPropertyType 
       type = (ExifPropertyType) propertyItem.Type;

switch (type) {case
        ExifPropertyType.Raw:// The value 
          represents raw data (a single byte[] value)

         return new
          byte[][] {propertyItem.Value};

         

        
case ExifPropertyType.Ascii:// 
          The value represents an array of strings separated by \0 characters

         string stringValue = 
         Encoding.ASCII.GetString(propertyItem.Value, 0, propertyItem.Len - 1);

         return stringValue.Split('\0');

         

        
case ExifPropertyType.Byte:// 
          The value represents an array of bytes

         return propertyItem.Value;

         

        
case ExifPropertyType.UInt16:// 
          The value represents an array of unsigned 16-bit integers.
int ushortCount = propertyItem.Len/ushortSize;

ushort[] ushortResult = new
          ushort[ushortCount];
for (int i = 0; i 
         < ushortCount; i++)ushortResult[i] = 
          ReadUInt16(propertyItem.Value, i * ushortSize);

         return ushortResult;

case ExifPropertyType.Int32:// 
          The value represents an array of signed 32-bit integers.
int intCount = propertyItem.Len/intSize;

int[] intResult = new
          int[intCount];
for (int i = 0; i 
         < intCount; i++)intResult[i] = 
          ReadInt32(propertyItem.Value, i * intSize);

         return intResult;

case ExifPropertyType.UInt32:// 
          The value represents an array of unsigned 32-bit integers.
int uintCount = propertyItem.Len/uintSize;

uint[] uintResult = new
          uint[uintCount];
for (int i = 0; i 
         < uintCount; i++)uintResult[i] = 
          ReadUInt32(propertyItem.Value, i * uintSize);

         return uintResult;

case ExifPropertyType.Rational:// 
          The value represents an array of signed rational numbers
// Numerator is an Int32 value, denominator a UInt32 value.
int rationalCount = propertyItem.Len/rationalSize;


         Rational[] rationalResult = new Rational[rationalCount];
for (int i = 0; i 
         < rationalCount; i++)rationalResult[i] =
           new Rational(ReadInt32(propertyItem.Value, 
           i * rationalSize),

           ReadInt32(propertyItem.Value, i * rationalSize + intSize));

         

         return rationalResult;

case ExifPropertyType.URational:// 
          The value represents an array of signed rational numbers
// Numerator and denominator are UInt32 values.
int urationalCount = 
         propertyItem.Len/rationalSize;


         URational[] urationalResult = new URational[urationalCount];
for (int i = 0; i 
         < urationalCount; i++)urationalResult[i] =
           new URational(ReadUInt32(propertyItem.Value, 
           i * urationalSize),

           ReadUInt32(propertyItem.Value, i * urationalSize + uintSize));

         

         return urationalResult;

default:return
          null;

       }

      }

#region Static Fields

private static
       readonly int ushortSize = 
      Marshal.SizeOf(typeof (ushort));
private static
       readonly int intSize = Marshal.SizeOf(typeof
      (int));
private static
       readonly int uintSize = Marshal.SizeOf(typeof
      (uint));
private static
       readonly int rationalSize = 2 * 
      Marshal.SizeOf(typeof (int));
private static
       readonly int urationalSize = 2 * 
      Marshal.SizeOf(typeof (uint));

#endregion

       

       #region Private Helpers

private static
       ushort ReadUInt16(byte[] buffer,
       int offset) {return
       (ushort) (((ushort) 
        buffer[offset] +

        ((ushort) buffer[offset + 1] << 8)));

      }

private static
       int ReadInt32(byte[] buffer,
       int offset) {return
       (int) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((int) buffer[offset + 3] << 24)));

      }

private static
       uint ReadUInt32(byte[] buffer,
       int offset) {return
       (uint) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((uint) buffer[offset + 3] << 24)));

      }

#endregion

     }

    }

The following code is a sample console application that make use of the code above to load an image and display the content of Exif properties.

Code Copy

[STAThread]
private static
     void Main(string[] args) {using(Image 
     image = Image.FromFile(args[0])) {Console.WriteLine("{0} 
       : {1} properties", args[0], image.PropertyItems.Length);

foreach (PropertyItem propertyItem
       in image.PropertyItems) {Array result = 
       ExifConvert.FromPropertyItem(propertyItem);

       Console.WriteLine("Property #{0}, type : {1}, {2} 
        value(s)", propertyItem.Id, 
       (ExifPropertyType)propertyItem.Type, result.Length);

foreach (object
        value in result)Console.WriteLine("\t{0}",
         value);

       

       Console.WriteLine();

      }

     }

    }
   

Exif Properties in .Net - Part 2 : creating new properties

Buz & Skup — Sun, 27 Mar 2005 20:04:00 GMT

When you manage Exif properties, you commonly have two basic tasks to handle : reading Exif properties (which is quite simple), and writing Exif properties, which is, in C#, as simple as:

Code Copy

PropertyItem 
    property = ...;

    Image image = ...;

    image.SetPropertyItem(property);

In the code above, the Image object may have been created from a file, a stream, an existing image, or just from scratch...
The PropertyItem may have been retrieved from an image, or... nothing : the System.Drawing.Imaging.PropertyItem class do not have a public constructor!

In this post, I am describing a workaround that enable to create new PropertyItem objects.

The method is, in fact, quite simple. It consists in having a small Jpeg image with Exif information embedded in you application, and loading PropertyItem from it when necessary.

First, you have to add your Jpeg file (let's call it "property.jpg") to your project, and mark it as an embedded resource.

In the Solution Explorer, select the project icon,
In the Project menu, click the Add an existing item menu,
In the dialog box, choose a valid Jpeg file and click Open; the file does appear in the Solution Explorer,
In the Solution Explorer, select the Jpeg file ,
In the Properties view, set the "Build Action" property to "Embedded Resource".

The second step is to add a reference on the System.Drawing assembly to the project, if not present, and to add the following lines at the top of the source file:

Code Copy

using
    System;

    using System.Drawing;

    using System.Drawing.Imaging;

    using System.IO;

    using System.Reflection;

Now when have to load the image and return the first property item it contains :

Code Copy

///
     <summary>

     /// Creates a new property item.
/// </summary>

     /// <returns>A 
     new instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {return resourceImage.PropertyItems[0];

     }

    }
   

The job is almost complete : we can now optimize this code to load the image only once and to return a clean object.

Code Copy HideScrollFull

private
     static Image propertyImage;

private static Image 
    PropertyImage

    {get

     {if (propertyImage==null)propertyImage 
       = LoadPropertyImage();

       
      

      return propertyImage;

     }

    }

private static Image 
    LoadPropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {// Creates a lightweight (1x1 
       pixel) bitmap with a single, empty exif property item.

      // This bitmap will remain in memory during the entire 
       application runtime.

      Image propertyImage = new Bitmap(1, 1);

      PropertyItem propertyItem = resourceImage.PropertyItems[0];

      propertyItem.Id = 0;

      propertyItem.Type = 0;

      propertyItem.Len = 0;

      propertyItem.Value = new byte[0];

      

      propertyImage.SetPropertyItem(propertyItem);

      

      return propertyImage;

     }

    }

/// <summary>

     /// Creates an empty property item.
/// </summary>

     /// <returns>A 
     new, empty instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem()

    {return PropertyImage.PropertyItems[0];

    }

/// <summary>

     /// Creates a new property item having the given 
     id, type and value.
/// </summary>

     /// <param name="id">The 
     identifier of the property item.</param>

     /// <param name="type">The 
     type of value the property item does contain.</param>

     /// <param name="len">The 
     length of the property value.</param>

     /// <param name="value">The 
     property value.</param>

     /// <returns>A 
     new, initialized, instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem(int id, short
    type, int len, byte[]
     value)

    {PropertyItem property = CreatePropertyItem();

     property.Id = id;

     property.Type = type;

     property.Len = len;

     property.Value = value;

    }

. . .

In the next post, we will convert the raw Exif data buffer (the PropertyItem.Value) into the native type.

Managed Gdi Wrapper for Better Performance

Buz & Skup — Tue, 22 Mar 2005 19:04:00 GMT

The days of Avalon have not come yet and Gdi Plus is surely a nice API to create wonderfull UI whith transparency and gradients, but it has a plumbing caveats : It cannot benefit of graphic cards acceleration. Let's see how to wrap Gdi gently in Managed Code to take benefit of it...

Exif Properties in .Net - Part 1 : (fast) loading

Buz & Skup — Thu, 17 Mar 2005 11:51:00 GMT

In .Net, handling a picture's Exif properties seems, at first sight, to be a very simple job.

Since System.Drawing is only a wrapper around GDI+, loading Exif information from an image file is as simple as the following :

Code Copy

public static PropertyItem[] GetExifProperties(string fileName) {
using(Image image = Image.FromFile(fileName))
return image.PropertyItems;
}

Unfortunately, this method requires to load - and validate - all image data in order to access the Exif properties. For instance, if you want to retrieve the thumbnail contained in the Exif properties, you first have to load and uncompress the entire image file.

This problem has been workarounded in the .Net Framework 1.1 Service Pack 1, and now you can process as follow :

Code Copy

public static PropertyItem[] GetExifProperties(string fileName) {
using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (Image image = Image.FromStream(stream,
/* useEmbeddedColorManagement = */ true,
/* validateImageData = */ false))

return image.PropertyItems;
}

However, since there is only a small share of PixVillage users that have the .Net Framework 1.1 Service Pack 1 installed, I eventually have implemented a custom ExifLoader helper class that use Interop to load Exif properties.

The first step is to load the image using the GDI+ Flat API and get the Exif properties raw data :

Code Copy HideScrollFull

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;

/// <summary>
/// Contains helper methods for loading Exif properties.
/// </summary>
public sealed class ExifLoader {
private ExifLoader() {}

/// <summary>
/// Retrieves Exif properties from a file.
/// </summary>
/// <param name="fileName">The name of the Exif image file.</param>
/// <returns>An array of <see cref="PropertyItem"/> objects containing the Exif properties.</returns>
public static PropertyItem[] GetExifProperties(string fileName) {
// Loads the image file using the GDI+ Flat API
IntPtr imageHandle = IntPtr.Zero;
if (GdipLoadImageFromFile(fileName, out imageHandle)!=0)
throw new InvalidOperationException();
int count;
int totalSize;
IntPtr data = IntPtr.Zero;

try {
// Retrieves the number of properties the image contains
if (GdipGetPropertyCount(imageHandle, out count)!=0)
throw new InvalidOperationException();
// Gets the total size, in bytes, of the properties
if (GdipGetPropertySize(imageHandle, out totalSize, ref count)!=0)
throw new InvalidOperationException();
// There is no available properties...
if (count == 0 || totalSize == 0)
return new PropertyItem[0];
// Loads all properties into memory.
data = Marshal.AllocHGlobal(totalSize);
if (GdipGetAllPropertyItems(imageHandle, totalSize, count, data)!=0)
throw new InvalidOperationException();
// Convert the properties buffer into an array of PropertyItem objects.
return ExifPropertyItem.ConvertFromMemory(data, count);
}
finally {
if (data != IntPtr.Zero)
Marshal.FreeHGlobal(data);
// Releases the GDI+ image.
GdipDisposeImage(imageHandle);
}
}

ExifPropertyItem Helper Class

// GDI+ Interop
[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipLoadImageFromFile(string filename, out IntPtr image);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipDisposeImage(IntPtr image);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetPropertyCount(IntPtr image, out int count);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetPropertySize(IntPtr image, out int totalSize, ref int count);

[DllImport("gdiplus.dll", CharSet=CharSet.Unicode, ExactSpelling=true)]
private static extern int GdipGetAllPropertyItems(IntPtr image, int totalSize, int count, IntPtr buffer);
}

Then, we have to decode the buffer filled by GdipGetAllPropertyItems. This is done using a private inner class, as follow :

Code Copy HideScrollFull

#region ExifPropertyItem Helper Class

/// <summary>
/// Represents an helper class for marshaling Exif property items.
/// </summary>
[StructLayout(LayoutKind.Sequential)]
private class ExifPropertyItem {

// Public members used for marshaling.
public int id = 0;
public int len = 0;
public short type = 0;
public IntPtr value = IntPtr.Zero;

/// <summary>
/// Initializes a new instance of the <see cref="ExifPropertyItem"/> class.
/// </summary>
/// <remarks>Used only by the <see cref="Marshal.PtrToStructure"/> method.</remarks>
public ExifPropertyItem() {}

/// <summary>
/// Gets the value of the property.
/// </summary>
public byte[] Value {
get {
byte[] buffer = new byte[len];
if (len > 0)
Marshal.Copy(value, buffer, 0, len);
return buffer;
}
}

/// <summary>
/// Converts a buffer into an array of PropertyItem objects.
/// </summary>
/// <param name="propertyData">The properties data buffer.</param>
/// <param name="count">The number of properties in the buffer.</param>
/// <returns>An array of <see cref="PropertyItem"/> objects.</returns>
public static PropertyItem[] ConvertFromMemory(IntPtr propertyData, int count) {
PropertyItem[] itemArray = new PropertyItem[count];
for (int i = 0; i < count; i++) {
// Marshals the buffer into a ExifPropertyItem structure.
ExifPropertyItem item = (ExifPropertyItem)Marshal.PtrToStructure(propertyData, typeof(ExifPropertyItem));

// Creates the PropertyItem from the data.
itemArray[i] = Create(item.type,  item.id, item.len, item.Value);

// Seek to next property.
propertyData = (IntPtr)(((long)propertyData) + Marshal.SizeOf(typeof(ExifPropertyItem)));
}

return itemArray;
}

/// <summary>
/// Creates a PropertyItem from its components.
/// </summary>
/// <param name="type">The property type.</param>
/// <param name="tag">The property tag.</param>
/// <param name="len">The length of the property.</param>
/// <param name="value">The property value.</param>
/// <returns></returns>
private static PropertyItem Create(short type, int tag, int len, byte[] value){
PropertyItem item;

// Loads a PropertyItem from a Jpeg image stored in the assembly as a resource.
Assembly assembly = Assembly.GetExecutingAssembly();
using(Stream emptyBitmapStream = assembly.GetManifestResourceStream("ExifLoader.empty.jpg"))
using(Image empty = Image.FromStream(emptyBitmapStream))
item = empty.PropertyItems[0];
// Copies the data to the property item.
item.Type = type;
item.Len = len;
item.Id = tag;
item.Value = new byte[value.Length];
value.CopyTo(item.Value, 0);

return item;
}
}

#endregion

Note that in the class above, we load a jpeg file from resources into memory. This file is named "empty.jpg" but the resource is referenced as "ExifLoader.empty.jpg" since "ExifLoader" is the name of the assembly.

Since the PropertyItem class does not provide a public initializer to create a property "from scratch", we have to use an existing property item.