How to Edit Meta Data Inside JPG Files with C#

Andrew Hay — Mon, 16 Aug 2010 18:36:13 GMT

We just got back from a great weekend at the beach; my sister-in-law got married on the sands near Haystack Rock in Cannon Beach, OR. Really a great trip from start to finish.

My wife accepted the photographer duties and snapped nearly 2K photos with our Nikon D40 and a Nikon D60 that we borrowed from a friend. She had a zoom lens on one and a short lens on the other to avoid the need to change lenses in mid-moment. That part worked great.

The part that we overlooked was the current date/time on each camera; they were not synchronized. This will make sorting photos by time more difficult. No problem, I say, on the drive back home. I’m a developer and JPG files have meta info that I can manipulate, right?

It turns out that its not all that easy. Its actually a remarkable pain in the ass, hence this blog post (that’s the remark-able part).

I started with an online search and found Hanselman’s post about combining PowerShell with Omar Shahine’s library, ImageLibrary.dll that is evidently no longer accessible. Big phat 404 while trying to get that assembly.

Next, I did some searches specific to StackOverflow.com and saw some posts about how difficult reading/writing this meta data can be. At this point, I was beginning to wonder if my wife was going to hear a broken promise or not. It wasn’t looking good.

I found out that JPG files store meta data using EXIF, or Exchangeable Image File Format, a standard used by the digital still camera industry. It looked like C# 4.0 could crack this open, but I might have to do get my hands dirty with some bit shuffling. No worries, I was up for it. It didn’t look like there was a library out there that was going to fall into my lap, so I cracked open Visual Studio 2010 and saw what kind of trouble I could get into with Intellisense and a gin and tonic.

Let’s Take It Out for a Loop

I created a new project, loaded a Bitmap class with a sample JPG and iterated over the properties:

 1: using System;

 2: using System.Drawing;

3:

 4: namespace ReadExifInJPG

 5: {

 6: class Program

 7: {

 8: static void Main()

 9: {

 10: var
bitmap = new Bitmap("c:\\temp\\somephoto.jpg");

11:

 12: foreach (var
item in bitmap.PropertyItems)

 13: {

 14: Console.WriteLine("Id:
{0}, Type: {1}, Value: {2}",

 15: item.Id,
item.Type, item.Value);

 16: }

 17: }

 18: }

 19: }

I had lots of properties in my sample photo:

I was thinking that this was going to be smooth sailing until I saw the values listed as byte arrays. Ugh. Then I read a EXIF specification that said the values can be stored in multiple formats and there are a ton of properties. I had over fifty on a single JPG image. I needed to find the property that told me if the given photo was taken by a Nikon D60 or a D40, and then change the date on the D60 images. Here’s the EXIF specifications: http://www.exif.org/specifications.html, and what a great document to read! Ugh.

I Just Want My Property

I found a list of property tags in numerical order on MSDN, note the id values are listed in hex, so 0x0132 (hex) equals 306 (decimal): http://msdn.microsoft.com/en-us/library/ms534418(VS.85).aspx

When you go about reading or changing a given property, there are three parts to consider:

the id number that identifies the given property
the type number which describes the data format
the actual data, encoded in the least accessible format you could want

Here’s a list of numeric types that identify the corresponding data format:

A Byte
An array of Byte objects encoded as ASCII
A 16-bit integer
A 32-bit integer
An array of two Byte objects that represent a rational number
Not used
Undefined
Not used
SLong
SRational

Fortunately, everything I was interested in was of type 2, a byte array. This is a great MSDN article that gave me a bunch of tips on how to manipulate the EXIF data: http://msdn.microsoft.com/en-us/library/xddt0dz7.aspx

The property id of 306 holds the date of the photo, its a type 2 property, so the value is stored in a byte array. Here’s how to read the string value:

 1: var
property = bitmap.GetPropertyItem(306);

 2: System.Text.ASCIIEncoding
encoding = new System.Text.ASCIIEncoding();

 3: string value =
encoding.GetString(property.Value);

Caution, Byte Counting Ahead

Note, the date properties that I’m interested in updating have values stored as byte arrays. More specifically, they’re exactly 20 bytes long. At first I wasn’t respecting that boundary and I just let .Net do it’s thing to convert my formatted date string into a byte array. When I tried to read the value back, it was empty because I overflowed the value.

After some noodling, I changed my code to write out exactly 20 bytes of data, starting at precisely 23 bytes into my new byte array, as follows.

 1: private void ChangeTimeStamp(Bitmap
bitmap, int minutesToAdd)

 2: {

 3: DateTime
originalDateTime = GetOriginalDateTime(bitmap);

4:

 5: var
newDateTime = originalDateTime.AddMinutes(minutesToAdd);

6:

 7: BinaryFormatter
bf = new BinaryFormatter();

 8: MemoryStream
ms = new MemoryStream();

 9: string formattedNewDateTime
= newDateTime.ToString("yyyy:MM:dd HH:mm:ss");

 10: bf.Serialize(ms,
formattedNewDateTime);

 11: ms.Seek(0,
0);

12:

 13: var
tempArray = ms.ToArray();

14:

 15: byte[]
byteArray = new byte[20];

16:

 17: var
x = 0;

 18: for (int i
= 23; i < (23 + 19); i++)

 19: {

 20: byteArray[x]
= tempArray[i];

 21: x++;

 22: }

23:

 24: SetNewDateTime(bitmap,
byteArray, 306);

 25: SetNewDateTime(bitmap,
byteArray, 36867);

 26: SetNewDateTime(bitmap,
byteArray, 36868);

 27: }

Note, the previous code shows I’m writing the same date to three different property settings (306, 36867, and 36868). They all had the same date value, so I figured the best thing to do was keep them all in sync.

It Works on My Machine

So, I was finally done with the code and I tested it with a bunch of files on my machine. Worked great. I installed VS 2010 C# Express on my netbook so I could create a console application and run it on my wife’s laptop. I had been abusing a ASP.Net Web Forms application with Visual Web Developer Express on my netbook. I made a quick console app, copied it to my wife’s laptop and ka-pow! It no worky. Puzzled, I tried to think what was wrong for about 30 minutes. After a couple of assertions inserted into my code, I realized she had some non-JPG files in the folder and my program wasn’t filtering for only JPG files. Doh! I did manage to get in a quick “hey, it works on my machine” comment to my wife, but she didn’t think it was as funny as I did.

Nothing But The Code, The Whole Code, So Help Me .Net Runtime?

Here’s the final class I built, in “good enough” format. The entire coding time, not including the installation of VS 2010 Express on my netbook, or .Net 4 on my wife’s laptop was about 90 minutes. The console program just takes this class, passes in the source and destination directories, along with the number of minutes to adjust the timestamp on the photo.

 1: using System;

 2: using System.Collections.Generic;

 3: using System.Linq;

 4: using System.Text;

 5: using System.IO;

 6: using System.Drawing;

 7: using System.Runtime.Serialization.Formatters.Binary;

8:

 9: namespace ImageMetaTool

 10: {

 11: public class TimeEditorService

 12: {

 13: public void AdjustDateTime(string soureDir, string destDir, int minutesToAdd)

 14: {

 15: if (!Directory.Exists(soureDir))

 16: {

 17: Console.WriteLine("Source
directory does not exist.");

 18: return;

 19: }

20:

 21: if (!Directory.Exists(destDir))

 22: {

 23: Console.WriteLine("Destination
directory does not exist.");

 24: return;

 25: }

26:

 27: int x
= 0;

 28: var
list = Directory.GetFiles(soureDir, "*.jpg");

 29: foreach (var
filename in list)

 30: {

 31: Console.WriteLine("Processing
image {0} of {1}; {2}", x, list.Length, filename);

32:

 33: using (var
fs = File.OpenRead(filename))

 34: {

 35: var
bitmap = new Bitmap(fs);

 36: ProcessFile(bitmap,
minutesToAdd);

 37: bitmap.Save(Path.Combine(destDir,
Path.GetFileName(filename)));

 38: x++;

 39: }

 40: }

41:

 42: Console.WriteLine("Processing
completed.");

 43: }

44:

 45: private void ProcessFile(Bitmap
bitmap, int minutesToAdd)

 46: {

 47: if (!IsD60(bitmap))

 48: return;

49:

 50: ChangeTimeStamp(bitmap,
minutesToAdd);

 51: }

52:

 53: private void ChangeTimeStamp(Bitmap
bitmap, int minutesToAdd)

 54: {

 55: DateTime
originalDateTime = GetOriginalDateTime(bitmap);

56:

 57: var
newDateTime = originalDateTime.AddMinutes(minutesToAdd);

58:

 59: BinaryFormatter
bf = new BinaryFormatter();

 60: MemoryStream
ms = new MemoryStream();

 61: string formattedNewDateTime
= newDateTime.ToString("yyyy:MM:dd HH:mm:ss");

 62: bf.Serialize(ms,
formattedNewDateTime);

 63: ms.Seek(0,
0);

64:

 65: var
tempArray = ms.ToArray();

66:

 67: byte[]
byteArray = new byte[20];

68:

 69: var
x = 0;

 70: for (int i
= 23; i < (23 + 19); i++)

 71: {

 72: byteArray[x]
= tempArray[i];

 73: x++;

 74: }

75:

 76: SetNewDateTime(bitmap,
byteArray, 306);

 77: SetNewDateTime(bitmap,
byteArray, 36867);

 78: SetNewDateTime(bitmap,
byteArray, 36868);

 79: }

80:

 81: private void SetNewDateTime(Bitmap
bitmap, byte[] newDateTime, int propertyNumber)

 82: {

 83: var
property = bitmap.GetPropertyItem(propertyNumber);

 84: property.Value
= newDateTime;

85:

 86: bitmap.SetPropertyItem(property);

 87: }

88:

 89: private DateTime
GetOriginalDateTime(Bitmap bitmap)

 90: {

 91: var
property = bitmap.GetPropertyItem(306);

92:

 93: System.Text.ASCIIEncoding
encoding = new System.Text.ASCIIEncoding();

 94: string value =
encoding.GetString(property.Value);

95:

 96: string value2
= value.Split(' ')[0].Replace(":", "/")
+ " " + value.Split('
')[1];

97:

 98: return DateTime.Parse(value2); //2010:08:14
14:23:14

 99: }

 100:

 101: private bool IsD60(Bitmap
bitmap)

 102: {

 103: var
modelProperty = bitmap.GetPropertyItem(272);

 104:

 105: System.Text.ASCIIEncoding
encoding = new System.Text.ASCIIEncoding();

 106: string modelName
= encoding.GetString(modelProperty.Value);

 107:

 108: if (modelName.Contains("D60")) //
NIKON D60

 109: return true;

 110:

 111: return false;

 112: }

 113: }

 114: }

I hope you have a good time futzing with your EXIF data!

Andrew Hay - utilities

How to Edit Meta Data Inside JPG Files with C#

Creating Large Files with fsutil.exe