From 244fa0d557d0993dc9ed66e94d0e7fbd17755b3a Mon Sep 17 00:00:00 2001
From: Max Degterev <me@maxdegterev.name>
Date: Mon, 3 Dec 2012 19:50:07 +0400
Subject: [PATCH] improvements

---
 jquery.exif.js | 1618 ++++++++++++++++++++++++------------------------
 1 file changed, 821 insertions(+), 797 deletions(-)

diff --git a/jquery.exif.js b/jquery.exif.js
index 0bca6af..a307194 100644
--- a/jquery.exif.js
+++ b/jquery.exif.js
@@ -5,235 +5,235 @@
  * Licensed under the MPL License [http://www.nihilogic.dk/licenses/mpl-license.txt]
  */
 
-(function() {
+(function($) {
 
 
 var BinaryFile = function(strData, iDataOffset, iDataLength) {
-	var data = strData;
-	var dataOffset = iDataOffset || 0;
-	var dataLength = 0;
-
-	this.getRawData = function() {
-		return data;
-	}
-
-	if (typeof strData == "string") {
-		dataLength = iDataLength || data.length;
-
-		this.getByteAt = function(iOffset) {
-			return data.charCodeAt(iOffset + dataOffset) & 0xFF;
-		}
-	} else if (typeof strData == "unknown") {
-		dataLength = iDataLength || IEBinary_getLength(data);
-
-		this.getByteAt = function(iOffset) {
-			return IEBinary_getByteAt(data, iOffset + dataOffset);
-		}
-	}
-
-	this.getLength = function() {
-		return dataLength;
-	}
-
-	this.getSByteAt = function(iOffset) {
-		var iByte = this.getByteAt(iOffset);
-		if (iByte > 127)
-			return iByte - 256;
-		else
-			return iByte;
-	}
-
-	this.getShortAt = function(iOffset, bBigEndian) {
-		var iShort = bBigEndian ?
-			(this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1)
-			: (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset)
-		if (iShort < 0) iShort += 65536;
-		return iShort;
-	}
-	this.getSShortAt = function(iOffset, bBigEndian) {
-		var iUShort = this.getShortAt(iOffset, bBigEndian);
-		if (iUShort > 32767)
-			return iUShort - 65536;
-		else
-			return iUShort;
-	}
-	this.getLongAt = function(iOffset, bBigEndian) {
-		var iByte1 = this.getByteAt(iOffset),
-			iByte2 = this.getByteAt(iOffset + 1),
-			iByte3 = this.getByteAt(iOffset + 2),
-			iByte4 = this.getByteAt(iOffset + 3);
-
-		var iLong = bBigEndian ?
-			(((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
-			: (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
-		if (iLong < 0) iLong += 4294967296;
-		return iLong;
-	}
-	this.getSLongAt = function(iOffset, bBigEndian) {
-		var iULong = this.getLongAt(iOffset, bBigEndian);
-		if (iULong > 2147483647)
-			return iULong - 4294967296;
-		else
-			return iULong;
-	}
-	this.getStringAt = function(iOffset, iLength) {
-		var aStr = [];
-		for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
-			aStr[j] = String.fromCharCode(this.getByteAt(i));
-		}
-		return aStr.join("");
-	}
-
-	this.getCharAt = function(iOffset) {
-		return String.fromCharCode(this.getByteAt(iOffset));
-	}
-	this.toBase64 = function() {
-		return window.btoa(data);
-	}
-	this.fromBase64 = function(strBase64) {
-		data = window.atob(strBase64);
-	}
-}
+    var data = strData;
+    var dataOffset = iDataOffset || 0;
+    var dataLength = 0;
+
+    this.getRawData = function() {
+        return data;
+    };
+
+    if (typeof strData == "string") {
+        dataLength = iDataLength || data.length;
+
+        this.getByteAt = function(iOffset) {
+            return data.charCodeAt(iOffset + dataOffset) & 0xFF;
+        };
+    } else if (typeof strData == "unknown") {
+        dataLength = iDataLength || IEBinary_getLength(data);
+
+        this.getByteAt = function(iOffset) {
+            return IEBinary_getByteAt(data, iOffset + dataOffset);
+        };
+    }
+
+    this.getLength = function() {
+        return dataLength;
+    };
+
+    this.getSByteAt = function(iOffset) {
+        var iByte = this.getByteAt(iOffset);
+        if (iByte > 127)
+            return iByte - 256;
+        else
+            return iByte;
+    };
+
+    this.getShortAt = function(iOffset, bBigEndian) {
+        var iShort = bBigEndian ?
+            (this.getByteAt(iOffset) << 8) + this.getByteAt(iOffset + 1)
+            : (this.getByteAt(iOffset + 1) << 8) + this.getByteAt(iOffset);
+        if (iShort < 0) iShort += 65536;
+        return iShort;
+    };
+    this.getSShortAt = function(iOffset, bBigEndian) {
+        var iUShort = this.getShortAt(iOffset, bBigEndian);
+        if (iUShort > 32767)
+            return iUShort - 65536;
+        else
+            return iUShort;
+    };
+    this.getLongAt = function(iOffset, bBigEndian) {
+        var iByte1 = this.getByteAt(iOffset),
+            iByte2 = this.getByteAt(iOffset + 1),
+            iByte3 = this.getByteAt(iOffset + 2),
+            iByte4 = this.getByteAt(iOffset + 3);
+
+        var iLong = bBigEndian ?
+            (((((iByte1 << 8) + iByte2) << 8) + iByte3) << 8) + iByte4
+            : (((((iByte4 << 8) + iByte3) << 8) + iByte2) << 8) + iByte1;
+        if (iLong < 0) iLong += 4294967296;
+        return iLong;
+    };
+    this.getSLongAt = function(iOffset, bBigEndian) {
+        var iULong = this.getLongAt(iOffset, bBigEndian);
+        if (iULong > 2147483647)
+            return iULong - 4294967296;
+        else
+            return iULong;
+    };
+    this.getStringAt = function(iOffset, iLength) {
+        var aStr = [];
+        for (var i=iOffset,j=0;i<iOffset+iLength;i++,j++) {
+            aStr[j] = String.fromCharCode(this.getByteAt(i));
+        }
+        return aStr.join("");
+    };
+
+    this.getCharAt = function(iOffset) {
+        return String.fromCharCode(this.getByteAt(iOffset));
+    };
+    this.toBase64 = function() {
+        return window.btoa(data);
+    };
+    this.fromBase64 = function(strBase64) {
+        data = window.atob(strBase64);
+    };
+};
 
 
 var BinaryAjax = (function() {
 
-	function createRequest() {
-		var oHTTP = null;
-		if (window.XMLHttpRequest) {
-			oHTTP = new XMLHttpRequest();
-		} else if (window.ActiveXObject) {
-			oHTTP = new ActiveXObject("Microsoft.XMLHTTP");
-		}
-		return oHTTP;
-	}
-
-	function getHead(strURL, fncCallback, fncError) {
-		var oHTTP = createRequest();
-		if (oHTTP) {
-			if (fncCallback) {
-				if (typeof(oHTTP.onload) != "undefined") {
-					oHTTP.onload = function() {
-						if (oHTTP.status == "200") {
-							fncCallback(this);
-						} else {
-							if (fncError) fncError();
-						}
-						oHTTP = null;
-					};
-				} else {
-					oHTTP.onreadystatechange = function() {
-						if (oHTTP.readyState == 4) {
-							if (oHTTP.status == "200") {
-								fncCallback(this);
-							} else {
-								if (fncError) fncError();
-							}
-							oHTTP = null;
-						}
-					};
-				}
-			}
-			oHTTP.open("HEAD", strURL, true);
-			oHTTP.send(null);
-		} else {
-			if (fncError) fncError();
-		}
-	}
-
-	function sendRequest(strURL, fncCallback, fncError, aRange, bAcceptRanges, iFileSize) {
-		var oHTTP = createRequest();
-		if (oHTTP) {
-
-			var iDataOffset = 0;
-			if (aRange && !bAcceptRanges) {
-				iDataOffset = aRange[0];
-			}
-			var iDataLen = 0;
-			if (aRange) {
-				iDataLen = aRange[1]-aRange[0]+1;
-			}
-
-			if (fncCallback) {
-				if (typeof(oHTTP.onload) != "undefined") {
-					oHTTP.onload = function() {
-
-						if (oHTTP.status == "200" || oHTTP.status == "206" || oHTTP.status == "0") {
-							this.binaryResponse = new BinaryFile(this.responseText, iDataOffset, iDataLen);
-							this.fileSize = iFileSize || this.getResponseHeader("Content-Length");
-							fncCallback(this);
-						} else {
-							if (fncError) fncError();
-						}
-						oHTTP = null;
-					};
-				} else {
-					oHTTP.onreadystatechange = function() {
-						if (oHTTP.readyState == 4) {
-							if (oHTTP.status == "200" || oHTTP.status == "206" || oHTTP.status == "0") {
-								this.binaryResponse = new BinaryFile(oHTTP.responseBody, iDataOffset, iDataLen);
-								this.fileSize = iFileSize || this.getResponseHeader("Content-Length");
-								fncCallback(this);
-							} else {
-								if (fncError) fncError();
-							}
-							oHTTP = null;
-						}
-					};
-				}
-			}
-			oHTTP.open("GET", strURL, true);
-
-			if (oHTTP.overrideMimeType) oHTTP.overrideMimeType('text/plain; charset=x-user-defined');
-
-			if (aRange && bAcceptRanges) {
-				oHTTP.setRequestHeader("Range", "bytes=" + aRange[0] + "-" + aRange[1]);
-			}
-
-			oHTTP.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 1970 00:00:00 GMT");
-
-			oHTTP.send(null);
-		} else {
-			if (fncError) fncError();
-		}
-	}
-
-	return function(strURL, fncCallback, fncError, aRange) {
-
-		if (aRange) {
-			getHead(
-				strURL,
-				function(oHTTP) {
-					var iLength = parseInt(oHTTP.getResponseHeader("Content-Length"),10);
-					var strAcceptRanges = oHTTP.getResponseHeader("Accept-Ranges");
-
-					var iStart, iEnd;
-					iStart = aRange[0];
-					if (aRange[0] < 0)
-						iStart += iLength;
-					iEnd = iStart + aRange[1] - 1;
-
-					sendRequest(strURL, fncCallback, fncError, [iStart, iEnd], (strAcceptRanges == "bytes"), iLength);
-				}
-			);
-
-		} else {
-			sendRequest(strURL, fncCallback, fncError);
-		}
-	}
+    function createRequest() {
+        var oHTTP = null;
+        if (window.XMLHttpRequest) {
+            oHTTP = new XMLHttpRequest();
+        } else if (window.ActiveXObject) {
+            oHTTP = new ActiveXObject("Microsoft.XMLHTTP");
+        }
+        return oHTTP;
+    }
+
+    function getHead(strURL, fncCallback, fncError) {
+        var oHTTP = createRequest();
+        if (oHTTP) {
+            if (fncCallback) {
+                if (typeof(oHTTP.onload) != "undefined") {
+                    oHTTP.onload = function() {
+                        if (oHTTP.status == "200") {
+                            fncCallback(this);
+                        } else {
+                            if (fncError) fncError();
+                        }
+                        oHTTP = null;
+                    };
+                } else {
+                    oHTTP.onreadystatechange = function() {
+                        if (oHTTP.readyState == 4) {
+                            if (oHTTP.status == "200") {
+                                fncCallback(this);
+                            } else {
+                                if (fncError) fncError();
+                            }
+                            oHTTP = null;
+                        }
+                    };
+                }
+            }
+            oHTTP.open("HEAD", strURL, true);
+            oHTTP.send(null);
+        } else {
+            if (fncError) fncError();
+        }
+    }
+
+    function sendRequest(strURL, fncCallback, fncError, aRange, bAcceptRanges, iFileSize) {
+        var oHTTP = createRequest();
+        if (oHTTP) {
+
+            var iDataOffset = 0;
+            if (aRange && !bAcceptRanges) {
+                iDataOffset = aRange[0];
+            }
+            var iDataLen = 0;
+            if (aRange) {
+                iDataLen = aRange[1]-aRange[0]+1;
+            }
+
+            if (fncCallback) {
+                if (typeof(oHTTP.onload) != "undefined") {
+                    oHTTP.onload = function() {
+
+                        if (oHTTP.status == "200" || oHTTP.status == "206" || oHTTP.status == "0") {
+                            this.binaryResponse = new BinaryFile(this.responseText, iDataOffset, iDataLen);
+                            this.fileSize = iFileSize || this.getResponseHeader("Content-Length");
+                            fncCallback(this);
+                        } else {
+                            if (fncError) fncError();
+                        }
+                        oHTTP = null;
+                    };
+                } else {
+                    oHTTP.onreadystatechange = function() {
+                        if (oHTTP.readyState == 4) {
+                            if (oHTTP.status == "200" || oHTTP.status == "206" || oHTTP.status == "0") {
+                                this.binaryResponse = new BinaryFile(oHTTP.responseBody, iDataOffset, iDataLen);
+                                this.fileSize = iFileSize || this.getResponseHeader("Content-Length");
+                                fncCallback(this);
+                            } else {
+                                if (fncError) fncError();
+                            }
+                            oHTTP = null;
+                        }
+                    };
+                }
+            }
+            oHTTP.open("GET", strURL, true);
+
+            if (oHTTP.overrideMimeType) oHTTP.overrideMimeType('text/plain; charset=x-user-defined');
+
+            if (aRange && bAcceptRanges) {
+                oHTTP.setRequestHeader("Range", "bytes=" + aRange[0] + "-" + aRange[1]);
+            }
+
+            oHTTP.setRequestHeader("If-Modified-Since", "Sat, 1 Jan 1970 00:00:00 GMT");
+
+            oHTTP.send(null);
+        } else {
+            if (fncError) fncError();
+        }
+    }
+
+    return function(strURL, fncCallback, fncError, aRange) {
+
+        if (aRange) {
+            getHead(
+                strURL,
+                function(oHTTP) {
+                    var iLength = parseInt(oHTTP.getResponseHeader("Content-Length"),10);
+                    var strAcceptRanges = oHTTP.getResponseHeader("Accept-Ranges");
+
+                    var iStart, iEnd;
+                    iStart = aRange[0];
+                    if (aRange[0] < 0)
+                        iStart += iLength;
+                    iEnd = iStart + aRange[1] - 1;
+
+                    sendRequest(strURL, fncCallback, fncError, [iStart, iEnd], (strAcceptRanges == "bytes"), iLength);
+                }
+            );
+
+        } else {
+            sendRequest(strURL, fncCallback, fncError);
+        }
+    };
 
 }());
 
 
 document.write(
-	"<script type='text/vbscript'>\r\n"
-	+ "Function IEBinary_getByteAt(strBinary, iOffset)\r\n"
-	+ "	IEBinary_getByteAt = AscB(MidB(strBinary,iOffset+1,1))\r\n"
-	+ "End Function\r\n"
-	+ "Function IEBinary_getLength(strBinary)\r\n"
-	+ "	IEBinary_getLength = LenB(strBinary)\r\n"
-	+ "End Function\r\n"
-	+ "</script>\r\n"
+    "<script type='text/vbscript'>\r\n"
+    + "Function IEBinary_getByteAt(strBinary, iOffset)\r\n"
+    + " IEBinary_getByteAt = AscB(MidB(strBinary,iOffset+1,1))\r\n"
+    + "End Function\r\n"
+    + "Function IEBinary_getLength(strBinary)\r\n"
+    + " IEBinary_getLength = LenB(strBinary)\r\n"
+    + "End Function\r\n"
+    + "</script>\r\n"
 );
 
 
@@ -245,667 +245,691 @@ var bDebug = false;
 
 EXIF.Tags = {
 
-	// version tags
-	0x9000 : "ExifVersion",			// EXIF version
-	0xA000 : "FlashpixVersion",		// Flashpix format version
-
-	// colorspace tags
-	0xA001 : "ColorSpace",			// Color space information tag
-
-	// image configuration
-	0xA002 : "PixelXDimension",		// Valid width of meaningful image
-	0xA003 : "PixelYDimension",		// Valid height of meaningful image
-	0x9101 : "ComponentsConfiguration",	// Information about channels
-	0x9102 : "CompressedBitsPerPixel",	// Compressed bits per pixel
-
-	// user information
-	0x927C : "MakerNote",			// Any desired information written by the manufacturer
-	0x9286 : "UserComment",			// Comments by user
-
-	// related file
-	0xA004 : "RelatedSoundFile",		// Name of related sound file
-
-	// date and time
-	0x9003 : "DateTimeOriginal",		// Date and time when the original image was generated
-	0x9004 : "DateTimeDigitized",		// Date and time when the image was stored digitally
-	0x9290 : "SubsecTime",			// Fractions of seconds for DateTime
-	0x9291 : "SubsecTimeOriginal",		// Fractions of seconds for DateTimeOriginal
-	0x9292 : "SubsecTimeDigitized",		// Fractions of seconds for DateTimeDigitized
-
-	// picture-taking conditions
-	0x829A : "ExposureTime",		// Exposure time (in seconds)
-	0x829D : "FNumber",			// F number
-	0x8822 : "ExposureProgram",		// Exposure program
-	0x8824 : "SpectralSensitivity",		// Spectral sensitivity
-	0x8827 : "ISOSpeedRatings",		// ISO speed rating
-	0x8828 : "OECF",			// Optoelectric conversion factor
-	0x9201 : "ShutterSpeedValue",		// Shutter speed
-	0x9202 : "ApertureValue",		// Lens aperture
-	0x9203 : "BrightnessValue",		// Value of brightness
-	0x9204 : "ExposureBias",		// Exposure bias
-	0x9205 : "MaxApertureValue",		// Smallest F number of lens
-	0x9206 : "SubjectDistance",		// Distance to subject in meters
-	0x9207 : "MeteringMode", 		// Metering mode
-	0x9208 : "LightSource",			// Kind of light source
-	0x9209 : "Flash",			// Flash status
-	0x9214 : "SubjectArea",			// Location and area of main subject
-	0x920A : "FocalLength",			// Focal length of the lens in mm
-	0xA20B : "FlashEnergy",			// Strobe energy in BCPS
-	0xA20C : "SpatialFrequencyResponse",	//
-	0xA20E : "FocalPlaneXResolution", 	// Number of pixels in width direction per FocalPlaneResolutionUnit
-	0xA20F : "FocalPlaneYResolution", 	// Number of pixels in height direction per FocalPlaneResolutionUnit
-	0xA210 : "FocalPlaneResolutionUnit", 	// Unit for measuring FocalPlaneXResolution and FocalPlaneYResolution
-	0xA214 : "SubjectLocation",		// Location of subject in image
-	0xA215 : "ExposureIndex",		// Exposure index selected on camera
-	0xA217 : "SensingMethod", 		// Image sensor type
-	0xA300 : "FileSource", 			// Image source (3 == DSC)
-	0xA301 : "SceneType", 			// Scene type (1 == directly photographed)
-	0xA302 : "CFAPattern",			// Color filter array geometric pattern
-	0xA401 : "CustomRendered",		// Special processing
-	0xA402 : "ExposureMode",		// Exposure mode
-	0xA403 : "WhiteBalance",		// 1 = auto white balance, 2 = manual
-	0xA404 : "DigitalZoomRation",		// Digital zoom ratio
-	0xA405 : "FocalLengthIn35mmFilm",	// Equivalent foacl length assuming 35mm film camera (in mm)
-	0xA406 : "SceneCaptureType",		// Type of scene
-	0xA407 : "GainControl",			// Degree of overall image gain adjustment
-	0xA408 : "Contrast",			// Direction of contrast processing applied by camera
-	0xA409 : "Saturation", 			// Direction of saturation processing applied by camera
-	0xA40A : "Sharpness",			// Direction of sharpness processing applied by camera
-	0xA40B : "DeviceSettingDescription",	//
-	0xA40C : "SubjectDistanceRange",	// Distance to subject
-
-	// other tags
-	0xA005 : "InteroperabilityIFDPointer",
-	0xA420 : "ImageUniqueID"		// Identifier assigned uniquely to each image
+    // version tags
+    0x9000 : "ExifVersion",         // EXIF version
+    0xA000 : "FlashpixVersion",     // Flashpix format version
+
+    // colorspace tags
+    0xA001 : "ColorSpace",          // Color space information tag
+
+    // image configuration
+    0xA002 : "PixelXDimension",     // Valid width of meaningful image
+    0xA003 : "PixelYDimension",     // Valid height of meaningful image
+    0x9101 : "ComponentsConfiguration", // Information about channels
+    0x9102 : "CompressedBitsPerPixel",  // Compressed bits per pixel
+
+    // user information
+    0x927C : "MakerNote",           // Any desired information written by the manufacturer
+    0x9286 : "UserComment",         // Comments by user
+
+    // related file
+    0xA004 : "RelatedSoundFile",        // Name of related sound file
+
+    // date and time
+    0x9003 : "DateTimeOriginal",        // Date and time when the original image was generated
+    0x9004 : "DateTimeDigitized",       // Date and time when the image was stored digitally
+    0x9290 : "SubsecTime",          // Fractions of seconds for DateTime
+    0x9291 : "SubsecTimeOriginal",      // Fractions of seconds for DateTimeOriginal
+    0x9292 : "SubsecTimeDigitized",     // Fractions of seconds for DateTimeDigitized
+
+    // picture-taking conditions
+    0x829A : "ExposureTime",        // Exposure time (in seconds)
+    0x829D : "FNumber",         // F number
+    0x8822 : "ExposureProgram",     // Exposure program
+    0x8824 : "SpectralSensitivity",     // Spectral sensitivity
+    0x8827 : "ISOSpeedRatings",     // ISO speed rating
+    0x8828 : "OECF",            // Optoelectric conversion factor
+    0x9201 : "ShutterSpeedValue",       // Shutter speed
+    0x9202 : "ApertureValue",       // Lens aperture
+    0x9203 : "BrightnessValue",     // Value of brightness
+    0x9204 : "ExposureBias",        // Exposure bias
+    0x9205 : "MaxApertureValue",        // Smallest F number of lens
+    0x9206 : "SubjectDistance",     // Distance to subject in meters
+    0x9207 : "MeteringMode",        // Metering mode
+    0x9208 : "LightSource",         // Kind of light source
+    0x9209 : "Flash",           // Flash status
+    0x9214 : "SubjectArea",         // Location and area of main subject
+    0x920A : "FocalLength",         // Focal length of the lens in mm
+    0xA20B : "FlashEnergy",         // Strobe energy in BCPS
+    0xA20C : "SpatialFrequencyResponse",    //
+    0xA20E : "FocalPlaneXResolution",   // Number of pixels in width direction per FocalPlaneResolutionUnit
+    0xA20F : "FocalPlaneYResolution",   // Number of pixels in height direction per FocalPlaneResolutionUnit
+    0xA210 : "FocalPlaneResolutionUnit",    // Unit for measuring FocalPlaneXResolution and FocalPlaneYResolution
+    0xA214 : "SubjectLocation",     // Location of subject in image
+    0xA215 : "ExposureIndex",       // Exposure index selected on camera
+    0xA217 : "SensingMethod",       // Image sensor type
+    0xA300 : "FileSource",          // Image source (3 == DSC)
+    0xA301 : "SceneType",           // Scene type (1 == directly photographed)
+    0xA302 : "CFAPattern",          // Color filter array geometric pattern
+    0xA401 : "CustomRendered",      // Special processing
+    0xA402 : "ExposureMode",        // Exposure mode
+    0xA403 : "WhiteBalance",        // 1 = auto white balance, 2 = manual
+    0xA404 : "DigitalZoomRation",       // Digital zoom ratio
+    0xA405 : "FocalLengthIn35mmFilm",   // Equivalent foacl length assuming 35mm film camera (in mm)
+    0xA406 : "SceneCaptureType",        // Type of scene
+    0xA407 : "GainControl",         // Degree of overall image gain adjustment
+    0xA408 : "Contrast",            // Direction of contrast processing applied by camera
+    0xA409 : "Saturation",          // Direction of saturation processing applied by camera
+    0xA40A : "Sharpness",           // Direction of sharpness processing applied by camera
+    0xA40B : "DeviceSettingDescription",    //
+    0xA40C : "SubjectDistanceRange",    // Distance to subject
+
+    // other tags
+    0xA005 : "InteroperabilityIFDPointer",
+    0xA420 : "ImageUniqueID"        // Identifier assigned uniquely to each image
 };
 
 EXIF.TiffTags = {
-	0x0100 : "ImageWidth",
-	0x0101 : "ImageHeight",
-	0x8769 : "ExifIFDPointer",
-	0x8825 : "GPSInfoIFDPointer",
-	0xA005 : "InteroperabilityIFDPointer",
-	0x0102 : "BitsPerSample",
-	0x0103 : "Compression",
-	0x0106 : "PhotometricInterpretation",
-	0x0112 : "Orientation",
-	0x0115 : "SamplesPerPixel",
-	0x011C : "PlanarConfiguration",
-	0x0212 : "YCbCrSubSampling",
-	0x0213 : "YCbCrPositioning",
-	0x011A : "XResolution",
-	0x011B : "YResolution",
-	0x0128 : "ResolutionUnit",
-	0x0111 : "StripOffsets",
-	0x0116 : "RowsPerStrip",
-	0x0117 : "StripByteCounts",
-	0x0201 : "JPEGInterchangeFormat",
-	0x0202 : "JPEGInterchangeFormatLength",
-	0x012D : "TransferFunction",
-	0x013E : "WhitePoint",
-	0x013F : "PrimaryChromaticities",
-	0x0211 : "YCbCrCoefficients",
-	0x0214 : "ReferenceBlackWhite",
-	0x0132 : "DateTime",
-	0x010E : "ImageDescription",
-	0x010F : "Make",
-	0x0110 : "Model",
-	0x0131 : "Software",
-	0x013B : "Artist",
-	0x8298 : "Copyright"
-}
+    0x0100 : "ImageWidth",
+    0x0101 : "ImageHeight",
+    0x8769 : "ExifIFDPointer",
+    0x8825 : "GPSInfoIFDPointer",
+    0xA005 : "InteroperabilityIFDPointer",
+    0x0102 : "BitsPerSample",
+    0x0103 : "Compression",
+    0x0106 : "PhotometricInterpretation",
+    0x0112 : "Orientation",
+    0x0115 : "SamplesPerPixel",
+    0x011C : "PlanarConfiguration",
+    0x0212 : "YCbCrSubSampling",
+    0x0213 : "YCbCrPositioning",
+    0x011A : "XResolution",
+    0x011B : "YResolution",
+    0x0128 : "ResolutionUnit",
+    0x0111 : "StripOffsets",
+    0x0116 : "RowsPerStrip",
+    0x0117 : "StripByteCounts",
+    0x0201 : "JPEGInterchangeFormat",
+    0x0202 : "JPEGInterchangeFormatLength",
+    0x012D : "TransferFunction",
+    0x013E : "WhitePoint",
+    0x013F : "PrimaryChromaticities",
+    0x0211 : "YCbCrCoefficients",
+    0x0214 : "ReferenceBlackWhite",
+    0x0132 : "DateTime",
+    0x010E : "ImageDescription",
+    0x010F : "Make",
+    0x0110 : "Model",
+    0x0131 : "Software",
+    0x013B : "Artist",
+    0x8298 : "Copyright"
+};
 
 EXIF.GPSTags = {
-	0x0000 : "GPSVersionID",
-	0x0001 : "GPSLatitudeRef",
-	0x0002 : "GPSLatitude",
-	0x0003 : "GPSLongitudeRef",
-	0x0004 : "GPSLongitude",
-	0x0005 : "GPSAltitudeRef",
-	0x0006 : "GPSAltitude",
-	0x0007 : "GPSTimeStamp",
-	0x0008 : "GPSSatellites",
-	0x0009 : "GPSStatus",
-	0x000A : "GPSMeasureMode",
-	0x000B : "GPSDOP",
-	0x000C : "GPSSpeedRef",
-	0x000D : "GPSSpeed",
-	0x000E : "GPSTrackRef",
-	0x000F : "GPSTrack",
-	0x0010 : "GPSImgDirectionRef",
-	0x0011 : "GPSImgDirection",
-	0x0012 : "GPSMapDatum",
-	0x0013 : "GPSDestLatitudeRef",
-	0x0014 : "GPSDestLatitude",
-	0x0015 : "GPSDestLongitudeRef",
-	0x0016 : "GPSDestLongitude",
-	0x0017 : "GPSDestBearingRef",
-	0x0018 : "GPSDestBearing",
-	0x0019 : "GPSDestDistanceRef",
-	0x001A : "GPSDestDistance",
-	0x001B : "GPSProcessingMethod",
-	0x001C : "GPSAreaInformation",
-	0x001D : "GPSDateStamp",
-	0x001E : "GPSDifferential"
-}
+    0x0000 : "GPSVersionID",
+    0x0001 : "GPSLatitudeRef",
+    0x0002 : "GPSLatitude",
+    0x0003 : "GPSLongitudeRef",
+    0x0004 : "GPSLongitude",
+    0x0005 : "GPSAltitudeRef",
+    0x0006 : "GPSAltitude",
+    0x0007 : "GPSTimeStamp",
+    0x0008 : "GPSSatellites",
+    0x0009 : "GPSStatus",
+    0x000A : "GPSMeasureMode",
+    0x000B : "GPSDOP",
+    0x000C : "GPSSpeedRef",
+    0x000D : "GPSSpeed",
+    0x000E : "GPSTrackRef",
+    0x000F : "GPSTrack",
+    0x0010 : "GPSImgDirectionRef",
+    0x0011 : "GPSImgDirection",
+    0x0012 : "GPSMapDatum",
+    0x0013 : "GPSDestLatitudeRef",
+    0x0014 : "GPSDestLatitude",
+    0x0015 : "GPSDestLongitudeRef",
+    0x0016 : "GPSDestLongitude",
+    0x0017 : "GPSDestBearingRef",
+    0x0018 : "GPSDestBearing",
+    0x0019 : "GPSDestDistanceRef",
+    0x001A : "GPSDestDistance",
+    0x001B : "GPSProcessingMethod",
+    0x001C : "GPSAreaInformation",
+    0x001D : "GPSDateStamp",
+    0x001E : "GPSDifferential"
+};
 
 EXIF.StringValues = {
-	ExposureProgram : {
-		0 : "Not defined",
-		1 : "Manual",
-		2 : "Normal program",
-		3 : "Aperture priority",
-		4 : "Shutter priority",
-		5 : "Creative program",
-		6 : "Action program",
-		7 : "Portrait mode",
-		8 : "Landscape mode"
-	},
-	MeteringMode : {
-		0 : "Unknown",
-		1 : "Average",
-		2 : "CenterWeightedAverage",
-		3 : "Spot",
-		4 : "MultiSpot",
-		5 : "Pattern",
-		6 : "Partial",
-		255 : "Other"
-	},
-	LightSource : {
-		0 : "Unknown",
-		1 : "Daylight",
-		2 : "Fluorescent",
-		3 : "Tungsten (incandescent light)",
-		4 : "Flash",
-		9 : "Fine weather",
-		10 : "Cloudy weather",
-		11 : "Shade",
-		12 : "Daylight fluorescent (D 5700 - 7100K)",
-		13 : "Day white fluorescent (N 4600 - 5400K)",
-		14 : "Cool white fluorescent (W 3900 - 4500K)",
-		15 : "White fluorescent (WW 3200 - 3700K)",
-		17 : "Standard light A",
-		18 : "Standard light B",
-		19 : "Standard light C",
-		20 : "D55",
-		21 : "D65",
-		22 : "D75",
-		23 : "D50",
-		24 : "ISO studio tungsten",
-		255 : "Other"
-	},
-	Flash : {
-		0x0000 : "Flash did not fire",
-		0x0001 : "Flash fired",
-		0x0005 : "Strobe return light not detected",
-		0x0007 : "Strobe return light detected",
-		0x0009 : "Flash fired, compulsory flash mode",
-		0x000D : "Flash fired, compulsory flash mode, return light not detected",
-		0x000F : "Flash fired, compulsory flash mode, return light detected",
-		0x0010 : "Flash did not fire, compulsory flash mode",
-		0x0018 : "Flash did not fire, auto mode",
-		0x0019 : "Flash fired, auto mode",
-		0x001D : "Flash fired, auto mode, return light not detected",
-		0x001F : "Flash fired, auto mode, return light detected",
-		0x0020 : "No flash function",
-		0x0041 : "Flash fired, red-eye reduction mode",
-		0x0045 : "Flash fired, red-eye reduction mode, return light not detected",
-		0x0047 : "Flash fired, red-eye reduction mode, return light detected",
-		0x0049 : "Flash fired, compulsory flash mode, red-eye reduction mode",
-		0x004D : "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected",
-		0x004F : "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected",
-		0x0059 : "Flash fired, auto mode, red-eye reduction mode",
-		0x005D : "Flash fired, auto mode, return light not detected, red-eye reduction mode",
-		0x005F : "Flash fired, auto mode, return light detected, red-eye reduction mode"
-	},
-	SensingMethod : {
-		1 : "Not defined",
-		2 : "One-chip color area sensor",
-		3 : "Two-chip color area sensor",
-		4 : "Three-chip color area sensor",
-		5 : "Color sequential area sensor",
-		7 : "Trilinear sensor",
-		8 : "Color sequential linear sensor"
-	},
-	SceneCaptureType : {
-		0 : "Standard",
-		1 : "Landscape",
-		2 : "Portrait",
-		3 : "Night scene"
-	},
-	SceneType : {
-		1 : "Directly photographed"
-	},
-	CustomRendered : {
-		0 : "Normal process",
-		1 : "Custom process"
-	},
-	WhiteBalance : {
-		0 : "Auto white balance",
-		1 : "Manual white balance"
-	},
-	GainControl : {
-		0 : "None",
-		1 : "Low gain up",
-		2 : "High gain up",
-		3 : "Low gain down",
-		4 : "High gain down"
-	},
-	Contrast : {
-		0 : "Normal",
-		1 : "Soft",
-		2 : "Hard"
-	},
-	Saturation : {
-		0 : "Normal",
-		1 : "Low saturation",
-		2 : "High saturation"
-	},
-	Sharpness : {
-		0 : "Normal",
-		1 : "Soft",
-		2 : "Hard"
-	},
-	SubjectDistanceRange : {
-		0 : "Unknown",
-		1 : "Macro",
-		2 : "Close view",
-		3 : "Distant view"
-	},
-	FileSource : {
-		3 : "DSC"
-	},
-
-	Components : {
-		0 : "",
-		1 : "Y",
-		2 : "Cb",
-		3 : "Cr",
-		4 : "R",
-		5 : "G",
-		6 : "B"
-	}
-}
+    ExposureProgram : {
+        0 : "Not defined",
+        1 : "Manual",
+        2 : "Normal program",
+        3 : "Aperture priority",
+        4 : "Shutter priority",
+        5 : "Creative program",
+        6 : "Action program",
+        7 : "Portrait mode",
+        8 : "Landscape mode"
+    },
+    MeteringMode : {
+        0 : "Unknown",
+        1 : "Average",
+        2 : "CenterWeightedAverage",
+        3 : "Spot",
+        4 : "MultiSpot",
+        5 : "Pattern",
+        6 : "Partial",
+        255 : "Other"
+    },
+    LightSource : {
+        0 : "Unknown",
+        1 : "Daylight",
+        2 : "Fluorescent",
+        3 : "Tungsten (incandescent light)",
+        4 : "Flash",
+        9 : "Fine weather",
+        10 : "Cloudy weather",
+        11 : "Shade",
+        12 : "Daylight fluorescent (D 5700 - 7100K)",
+        13 : "Day white fluorescent (N 4600 - 5400K)",
+        14 : "Cool white fluorescent (W 3900 - 4500K)",
+        15 : "White fluorescent (WW 3200 - 3700K)",
+        17 : "Standard light A",
+        18 : "Standard light B",
+        19 : "Standard light C",
+        20 : "D55",
+        21 : "D65",
+        22 : "D75",
+        23 : "D50",
+        24 : "ISO studio tungsten",
+        255 : "Other"
+    },
+    Flash : {
+        0x0000 : "Flash did not fire",
+        0x0001 : "Flash fired",
+        0x0005 : "Strobe return light not detected",
+        0x0007 : "Strobe return light detected",
+        0x0009 : "Flash fired, compulsory flash mode",
+        0x000D : "Flash fired, compulsory flash mode, return light not detected",
+        0x000F : "Flash fired, compulsory flash mode, return light detected",
+        0x0010 : "Flash did not fire, compulsory flash mode",
+        0x0018 : "Flash did not fire, auto mode",
+        0x0019 : "Flash fired, auto mode",
+        0x001D : "Flash fired, auto mode, return light not detected",
+        0x001F : "Flash fired, auto mode, return light detected",
+        0x0020 : "No flash function",
+        0x0041 : "Flash fired, red-eye reduction mode",
+        0x0045 : "Flash fired, red-eye reduction mode, return light not detected",
+        0x0047 : "Flash fired, red-eye reduction mode, return light detected",
+        0x0049 : "Flash fired, compulsory flash mode, red-eye reduction mode",
+        0x004D : "Flash fired, compulsory flash mode, red-eye reduction mode, return light not detected",
+        0x004F : "Flash fired, compulsory flash mode, red-eye reduction mode, return light detected",
+        0x0059 : "Flash fired, auto mode, red-eye reduction mode",
+        0x005D : "Flash fired, auto mode, return light not detected, red-eye reduction mode",
+        0x005F : "Flash fired, auto mode, return light detected, red-eye reduction mode"
+    },
+    SensingMethod : {
+        1 : "Not defined",
+        2 : "One-chip color area sensor",
+        3 : "Two-chip color area sensor",
+        4 : "Three-chip color area sensor",
+        5 : "Color sequential area sensor",
+        7 : "Trilinear sensor",
+        8 : "Color sequential linear sensor"
+    },
+    SceneCaptureType : {
+        0 : "Standard",
+        1 : "Landscape",
+        2 : "Portrait",
+        3 : "Night scene"
+    },
+    SceneType : {
+        1 : "Directly photographed"
+    },
+    CustomRendered : {
+        0 : "Normal process",
+        1 : "Custom process"
+    },
+    WhiteBalance : {
+        0 : "Auto white balance",
+        1 : "Manual white balance"
+    },
+    GainControl : {
+        0 : "None",
+        1 : "Low gain up",
+        2 : "High gain up",
+        3 : "Low gain down",
+        4 : "High gain down"
+    },
+    Contrast : {
+        0 : "Normal",
+        1 : "Soft",
+        2 : "Hard"
+    },
+    Saturation : {
+        0 : "Normal",
+        1 : "Low saturation",
+        2 : "High saturation"
+    },
+    Sharpness : {
+        0 : "Normal",
+        1 : "Soft",
+        2 : "Hard"
+    },
+    SubjectDistanceRange : {
+        0 : "Unknown",
+        1 : "Macro",
+        2 : "Close view",
+        3 : "Distant view"
+    },
+    FileSource : {
+        3 : "DSC"
+    },
+
+    Components : {
+        0 : "",
+        1 : "Y",
+        2 : "Cb",
+        3 : "Cr",
+        4 : "R",
+        5 : "G",
+        6 : "B"
+    }
+};
 
 function addEvent(oElement, strEvent, fncHandler)
 {
-	if (oElement.addEventListener) {
-		oElement.addEventListener(strEvent, fncHandler, false);
-	} else if (oElement.attachEvent) {
-		oElement.attachEvent("on" + strEvent, fncHandler);
-	}
+    if (oElement.addEventListener) {
+        oElement.addEventListener(strEvent, fncHandler, false);
+    } else if (oElement.attachEvent) {
+        oElement.attachEvent("on" + strEvent, fncHandler);
+    }
 }
 
 
 function imageHasData(oImg)
 {
-	return !!(oImg.exifdata);
+    return !!(oImg.exifdata);
 }
 
 function getImageData(oImg, fncCallback)
 {
-	BinaryAjax(
-		oImg.src,
-		function(oHTTP) {
-			var oEXIF = findEXIFinJPEG(oHTTP.binaryResponse);
-			oImg.exifdata = oEXIF || {};
-			if (fncCallback) fncCallback();
-		}
-	)
+    BinaryAjax(
+        oImg.src,
+        function(oHTTP) {
+            var oEXIF = findEXIFinJPEG(oHTTP.binaryResponse);
+            oImg.exifdata = oEXIF || {};
+            if (fncCallback) fncCallback();
+        }
+    );
 }
 
 function findEXIFinJPEG(oFile) {
-	var aMarkers = [];
+    var aMarkers = [];
 
-	if (oFile.getByteAt(0) != 0xFF || oFile.getByteAt(1) != 0xD8) {
-		return false; // not a valid jpeg
-	}
+    if (oFile.getByteAt(0) != 0xFF || oFile.getByteAt(1) != 0xD8) {
+        return false; // not a valid jpeg
+    }
 
-	var iOffset = 2;
-	var iLength = oFile.getLength();
-	while (iOffset < iLength) {
-		if (oFile.getByteAt(iOffset) != 0xFF) {
-			if (bDebug) console.log("Not a valid marker at offset " + iOffset + ", found: " + oFile.getByteAt(iOffset));
-			return false; // not a valid marker, something is wrong
-		}
+    var iOffset = 2;
+    var iLength = oFile.getLength();
+    while (iOffset < iLength) {
+        if (oFile.getByteAt(iOffset) != 0xFF) {
+            if (bDebug) console.log("Not a valid marker at offset " + iOffset + ", found: " + oFile.getByteAt(iOffset));
+            return false; // not a valid marker, something is wrong
+        }
 
-		var iMarker = oFile.getByteAt(iOffset+1);
+        var iMarker = oFile.getByteAt(iOffset+1);
 
-		// we could implement handling for other markers here,
-		// but we're only looking for 0xFFE1 for EXIF data
+        // we could implement handling for other markers here,
+        // but we're only looking for 0xFFE1 for EXIF data
 
-		if (iMarker == 22400) {
-			if (bDebug) console.log("Found 0xFFE1 marker");
-			return readEXIFData(oFile, iOffset + 4, oFile.getShortAt(iOffset+2, true)-2);
-			iOffset += 2 + oFile.getShortAt(iOffset+2, true);
+        if (iMarker == 22400) {
+            if (bDebug) console.log("Found 0xFFE1 marker");
+            return readEXIFData(oFile, iOffset + 4, oFile.getShortAt(iOffset+2, true)-2);
+            // iOffset += 2 + oFile.getShortAt(iOffset+2, true);
+            // WTF?
 
-		} else if (iMarker == 225) {
-			// 0xE1 = Application-specific 1 (for EXIF)
-			if (bDebug) console.log("Found 0xFFE1 marker");
-			return readEXIFData(oFile, iOffset + 4, oFile.getShortAt(iOffset+2, true)-2);
+        } else if (iMarker == 225) {
+            // 0xE1 = Application-specific 1 (for EXIF)
+            if (bDebug) console.log("Found 0xFFE1 marker");
+            return readEXIFData(oFile, iOffset + 4, oFile.getShortAt(iOffset+2, true)-2);
 
-		} else {
-			iOffset += 2 + oFile.getShortAt(iOffset+2, true);
-		}
+        } else {
+            iOffset += 2 + oFile.getShortAt(iOffset+2, true);
+        }
 
-	}
+    }
 
 }
 
 
 function readTags(oFile, iTIFFStart, iDirStart, oStrings, bBigEnd)
 {
-	var iEntries = oFile.getShortAt(iDirStart, bBigEnd);
-	var oTags = {};
-	for (var i=0;i<iEntries;i++) {
-		var iEntryOffset = iDirStart + i*12 + 2;
-		var strTag = oStrings[oFile.getShortAt(iEntryOffset, bBigEnd)];
-		if (!strTag && bDebug) console.log("Unknown tag: " + oFile.getShortAt(iEntryOffset, bBigEnd));
-		oTags[strTag] = readTagValue(oFile, iEntryOffset, iTIFFStart, iDirStart, bBigEnd);
-	}
-	return oTags;
+    var iEntries = oFile.getShortAt(iDirStart, bBigEnd);
+    var oTags = {};
+    for (var i=0;i<iEntries;i++) {
+        var iEntryOffset = iDirStart + i*12 + 2;
+        var strTag = oStrings[oFile.getShortAt(iEntryOffset, bBigEnd)];
+        if (!strTag && bDebug) console.log("Unknown tag: " + oFile.getShortAt(iEntryOffset, bBigEnd));
+        oTags[strTag] = readTagValue(oFile, iEntryOffset, iTIFFStart, iDirStart, bBigEnd);
+    }
+    return oTags;
 }
 
 
 function readTagValue(oFile, iEntryOffset, iTIFFStart, iDirStart, bBigEnd)
 {
-	var iType = oFile.getShortAt(iEntryOffset+2, bBigEnd);
-	var iNumValues = oFile.getLongAt(iEntryOffset+4, bBigEnd);
-	var iValueOffset = oFile.getLongAt(iEntryOffset+8, bBigEnd) + iTIFFStart;
-
-	switch (iType) {
-		case 1: // byte, 8-bit unsigned int
-		case 7: // undefined, 8-bit byte, value depending on field
-			if (iNumValues == 1) {
-				return oFile.getByteAt(iEntryOffset + 8, bBigEnd);
-			} else {
-				var iValOffset = iNumValues > 4 ? iValueOffset : (iEntryOffset + 8);
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getByteAt(iValOffset + n);
-				}
-				return aVals;
-			}
-			break;
-
-		case 2: // ascii, 8-bit byte
-			var iStringOffset = iNumValues > 4 ? iValueOffset : (iEntryOffset + 8);
-			return oFile.getStringAt(iStringOffset, iNumValues-1);
-			break;
-
-		case 3: // short, 16 bit int
-			if (iNumValues == 1) {
-				return oFile.getShortAt(iEntryOffset + 8, bBigEnd);
-			} else {
-				var iValOffset = iNumValues > 2 ? iValueOffset : (iEntryOffset + 8);
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getShortAt(iValOffset + 2*n, bBigEnd);
-				}
-				return aVals;
-			}
-			break;
-
-		case 4: // long, 32 bit int
-			if (iNumValues == 1) {
-				return oFile.getLongAt(iEntryOffset + 8, bBigEnd);
-			} else {
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getLongAt(iValueOffset + 4*n, bBigEnd);
-				}
-				return aVals;
-			}
-			break;
-		case 5:	// rational = two long values, first is numerator, second is denominator
-			if (iNumValues == 1) {
-				return oFile.getLongAt(iValueOffset, bBigEnd) / oFile.getLongAt(iValueOffset+4, bBigEnd);
-			} else {
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getLongAt(iValueOffset + 8*n, bBigEnd) / oFile.getLongAt(iValueOffset+4 + 8*n, bBigEnd);
-				}
-				return aVals;
-			}
-			break;
-		case 9: // slong, 32 bit signed int
-			if (iNumValues == 1) {
-				return oFile.getSLongAt(iEntryOffset + 8, bBigEnd);
-			} else {
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getSLongAt(iValueOffset + 4*n, bBigEnd);
-				}
-				return aVals;
-			}
-			break;
-		case 10: // signed rational, two slongs, first is numerator, second is denominator
-			if (iNumValues == 1) {
-				return oFile.getSLongAt(iValueOffset, bBigEnd) / oFile.getSLongAt(iValueOffset+4, bBigEnd);
-			} else {
-				var aVals = [];
-				for (var n=0;n<iNumValues;n++) {
-					aVals[n] = oFile.getSLongAt(iValueOffset + 8*n, bBigEnd) / oFile.getSLongAt(iValueOffset+4 + 8*n, bBigEnd);
-				}
-				return aVals;
-			}
-			break;
-	}
+    var iType = oFile.getShortAt(iEntryOffset+2, bBigEnd);
+    var iNumValues = oFile.getLongAt(iEntryOffset+4, bBigEnd);
+    var iValueOffset = oFile.getLongAt(iEntryOffset+8, bBigEnd) + iTIFFStart;
+
+    switch (iType) {
+        case 1: // byte, 8-bit unsigned int
+        case 7: // undefined, 8-bit byte, value depending on field
+            if (iNumValues == 1) {
+                return oFile.getByteAt(iEntryOffset + 8, bBigEnd);
+            } else {
+                var iValOffset = iNumValues > 4 ? iValueOffset : (iEntryOffset + 8);
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getByteAt(iValOffset + n);
+                }
+                return aVals;
+            }
+            break;
+
+        case 2: // ascii, 8-bit byte
+            var iStringOffset = iNumValues > 4 ? iValueOffset : (iEntryOffset + 8);
+            return oFile.getStringAt(iStringOffset, iNumValues-1);
+            // break;
+
+        case 3: // short, 16 bit int
+            if (iNumValues == 1) {
+                return oFile.getShortAt(iEntryOffset + 8, bBigEnd);
+            } else {
+                var iValOffset = iNumValues > 2 ? iValueOffset : (iEntryOffset + 8);
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getShortAt(iValOffset + 2*n, bBigEnd);
+                }
+                return aVals;
+            }
+            // break;
+
+        case 4: // long, 32 bit int
+            if (iNumValues == 1) {
+                return oFile.getLongAt(iEntryOffset + 8, bBigEnd);
+            } else {
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getLongAt(iValueOffset + 4*n, bBigEnd);
+                }
+                return aVals;
+            }
+            break;
+        case 5: // rational = two long values, first is numerator, second is denominator
+            if (iNumValues == 1) {
+                return oFile.getLongAt(iValueOffset, bBigEnd) / oFile.getLongAt(iValueOffset+4, bBigEnd);
+            } else {
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getLongAt(iValueOffset + 8*n, bBigEnd) / oFile.getLongAt(iValueOffset+4 + 8*n, bBigEnd);
+                }
+                return aVals;
+            }
+            break;
+        case 9: // slong, 32 bit signed int
+            if (iNumValues == 1) {
+                return oFile.getSLongAt(iEntryOffset + 8, bBigEnd);
+            } else {
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getSLongAt(iValueOffset + 4*n, bBigEnd);
+                }
+                return aVals;
+            }
+            break;
+        case 10: // signed rational, two slongs, first is numerator, second is denominator
+            if (iNumValues == 1) {
+                return oFile.getSLongAt(iValueOffset, bBigEnd) / oFile.getSLongAt(iValueOffset+4, bBigEnd);
+            } else {
+                var aVals = [];
+                for (var n=0;n<iNumValues;n++) {
+                    aVals[n] = oFile.getSLongAt(iValueOffset + 8*n, bBigEnd) / oFile.getSLongAt(iValueOffset+4 + 8*n, bBigEnd);
+                }
+                return aVals;
+            }
+            break;
+    }
 }
 
 
 function readEXIFData(oFile, iStart, iLength)
 {
-	if (oFile.getStringAt(iStart, 4) != "Exif") {
-		if (bDebug) console.log("Not valid EXIF data! " + oFile.getStringAt(iStart, 4));
-		return false;
-	}
-
-	var bBigEnd;
-
-	var iTIFFOffset = iStart + 6;
-
-	// test for TIFF validity and endianness
-	if (oFile.getShortAt(iTIFFOffset) == 0x4949) {
-		bBigEnd = false;
-	} else if (oFile.getShortAt(iTIFFOffset) == 0x4D4D) {
-		bBigEnd = true;
-	} else {
-		if (bDebug) console.log("Not valid TIFF data! (no 0x4949 or 0x4D4D)");
-		return false;
-	}
-
-	if (oFile.getShortAt(iTIFFOffset+2, bBigEnd) != 0x002A) {
-		if (bDebug) console.log("Not valid TIFF data! (no 0x002A)");
-		return false;
-	}
-
-	if (oFile.getLongAt(iTIFFOffset+4, bBigEnd) != 0x00000008) {
-		if (bDebug) console.log("Not valid TIFF data! (First offset not 8)", oFile.getShortAt(iTIFFOffset+4, bBigEnd));
-		return false;
-	}
-
-	var oTags = readTags(oFile, iTIFFOffset, iTIFFOffset+8, EXIF.TiffTags, bBigEnd);
-
-	if (oTags.ExifIFDPointer) {
-		var oEXIFTags = readTags(oFile, iTIFFOffset, iTIFFOffset + oTags.ExifIFDPointer, EXIF.Tags, bBigEnd);
-		for (var strTag in oEXIFTags) {
-			switch (strTag) {
-				case "LightSource" :
-				case "Flash" :
-				case "MeteringMode" :
-				case "ExposureProgram" :
-				case "SensingMethod" :
-				case "SceneCaptureType" :
-				case "SceneType" :
-				case "CustomRendered" :
-				case "WhiteBalance" :
-				case "GainControl" :
-				case "Contrast" :
-				case "Saturation" :
-				case "Sharpness" :
-				case "SubjectDistanceRange" :
-				case "FileSource" :
-					oEXIFTags[strTag] = EXIF.StringValues[strTag][oEXIFTags[strTag]];
-					break;
-
-				case "ExifVersion" :
-				case "FlashpixVersion" :
-					oEXIFTags[strTag] = String.fromCharCode(oEXIFTags[strTag][0], oEXIFTags[strTag][1], oEXIFTags[strTag][2], oEXIFTags[strTag][3]);
-					break;
-
-				case "ComponentsConfiguration" :
-					oEXIFTags[strTag] =
-						EXIF.StringValues.Components[oEXIFTags[strTag][0]]
-						+ EXIF.StringValues.Components[oEXIFTags[strTag][1]]
-						+ EXIF.StringValues.Components[oEXIFTags[strTag][2]]
-						+ EXIF.StringValues.Components[oEXIFTags[strTag][3]];
-					break;
-			}
-			oTags[strTag] = oEXIFTags[strTag];
-		}
-	}
-
-	if (oTags.GPSInfoIFDPointer) {
-		var oGPSTags = readTags(oFile, iTIFFOffset, iTIFFOffset + oTags.GPSInfoIFDPointer, EXIF.GPSTags, bBigEnd);
-		for (var strTag in oGPSTags) {
-			switch (strTag) {
-				case "GPSVersionID" :
-					oGPSTags[strTag] = oGPSTags[strTag][0]
-						+ "." + oGPSTags[strTag][1]
-						+ "." + oGPSTags[strTag][2]
-						+ "." + oGPSTags[strTag][3];
-					break;
-			}
-			oTags[strTag] = oGPSTags[strTag];
-		}
-	}
-
-	return oTags;
+    if (oFile.getStringAt(iStart, 4) != "Exif") {
+        if (bDebug) console.log("Not valid EXIF data! " + oFile.getStringAt(iStart, 4));
+        return false;
+    }
+
+    var bBigEnd;
+
+    var iTIFFOffset = iStart + 6;
+
+    // test for TIFF validity and endianness
+    if (oFile.getShortAt(iTIFFOffset) == 0x4949) {
+        bBigEnd = false;
+    } else if (oFile.getShortAt(iTIFFOffset) == 0x4D4D) {
+        bBigEnd = true;
+    } else {
+        if (bDebug) console.log("Not valid TIFF data! (no 0x4949 or 0x4D4D)");
+        return false;
+    }
+
+    if (oFile.getShortAt(iTIFFOffset+2, bBigEnd) != 0x002A) {
+        if (bDebug) console.log("Not valid TIFF data! (no 0x002A)");
+        return false;
+    }
+
+    if (oFile.getLongAt(iTIFFOffset+4, bBigEnd) != 0x00000008) {
+        if (bDebug) console.log("Not valid TIFF data! (First offset not 8)", oFile.getShortAt(iTIFFOffset+4, bBigEnd));
+        return false;
+    }
+
+    var oTags = readTags(oFile, iTIFFOffset, iTIFFOffset+8, EXIF.TiffTags, bBigEnd);
+
+    if (oTags.ExifIFDPointer) {
+        var oEXIFTags = readTags(oFile, iTIFFOffset, iTIFFOffset + oTags.ExifIFDPointer, EXIF.Tags, bBigEnd);
+        for (var strTag in oEXIFTags) {
+            switch (strTag) {
+                case "LightSource" :
+                case "Flash" :
+                case "MeteringMode" :
+                case "ExposureProgram" :
+                case "SensingMethod" :
+                case "SceneCaptureType" :
+                case "SceneType" :
+                case "CustomRendered" :
+                case "WhiteBalance" :
+                case "GainControl" :
+                case "Contrast" :
+                case "Saturation" :
+                case "Sharpness" :
+                case "SubjectDistanceRange" :
+                case "FileSource" :
+                    oEXIFTags[strTag] = EXIF.StringValues[strTag][oEXIFTags[strTag]];
+                    break;
+
+                case "ExifVersion" :
+                case "FlashpixVersion" :
+                    oEXIFTags[strTag] = String.fromCharCode(oEXIFTags[strTag][0], oEXIFTags[strTag][1], oEXIFTags[strTag][2], oEXIFTags[strTag][3]);
+                    break;
+
+                case "ComponentsConfiguration" :
+                    oEXIFTags[strTag] =
+                        EXIF.StringValues.Components[oEXIFTags[strTag][0]]
+                        + EXIF.StringValues.Components[oEXIFTags[strTag][1]]
+                        + EXIF.StringValues.Components[oEXIFTags[strTag][2]]
+                        + EXIF.StringValues.Components[oEXIFTags[strTag][3]];
+                    break;
+            }
+            oTags[strTag] = oEXIFTags[strTag];
+        }
+    }
+
+    if (oTags.GPSInfoIFDPointer) {
+        var oGPSTags = readTags(oFile, iTIFFOffset, iTIFFOffset + oTags.GPSInfoIFDPointer, EXIF.GPSTags, bBigEnd);
+        for (var strTag in oGPSTags) {
+            switch (strTag) {
+                case "GPSVersionID" :
+                    oGPSTags[strTag] = oGPSTags[strTag][0]
+                        + "." + oGPSTags[strTag][1]
+                        + "." + oGPSTags[strTag][2]
+                        + "." + oGPSTags[strTag][3];
+                    break;
+            }
+            oTags[strTag] = oGPSTags[strTag];
+        }
+    }
+
+    return oTags;
 }
 
 
 EXIF.getData = function(oImg, fncCallback)
 {
-	if (!oImg.complete) return false;
-	if (!imageHasData(oImg)) {
-		getImageData(oImg, fncCallback);
-	} else {
-		if (fncCallback) fncCallback();
-	}
-	return true;
-}
+    if (!oImg.complete) return false;
+    if (!imageHasData(oImg)) {
+        getImageData(oImg, fncCallback);
+    } else {
+        if (fncCallback) fncCallback();
+    }
+    return true;
+};
 
 EXIF.getTag = function(oImg, strTag)
 {
-	if (!imageHasData(oImg)) return;
-	return oImg.exifdata[strTag];
-}
+    if (!imageHasData(oImg)) return;
+    return oImg.exifdata[strTag];
+};
 
 EXIF.getAllTags = function(oImg)
 {
-	if (!imageHasData(oImg)) return {};
-	var oData = oImg.exifdata;
-	var oAllTags = {};
-	for (var a in oData) {
-		if (oData.hasOwnProperty(a)) {
-			oAllTags[a] = oData[a];
-		}
-	}
-	return oAllTags;
-}
+    if (!imageHasData(oImg)) return {};
+    var oData = oImg.exifdata;
+    var oAllTags = {};
+    for (var a in oData) {
+        if (oData.hasOwnProperty(a)) {
+            oAllTags[a] = oData[a];
+        }
+    }
+    return oAllTags;
+};
 
 EXIF.pretty = function(oImg)
 {
-	if (!imageHasData(oImg)) return "";
-	var oData = oImg.exifdata;
-	var strPretty = "";
-	for (var a in oData) {
-		if (oData.hasOwnProperty(a)) {
-			if (typeof oData[a] == "object") {
-				strPretty += a + " : [" + oData[a].length + " values]\r\n";
-			} else {
-				strPretty += a + " : " + oData[a] + "\r\n";
-			}
-		}
-	}
-	return strPretty;
-}
+    if (!imageHasData(oImg)) return "";
+    var oData = oImg.exifdata;
+    var strPretty = "";
+    for (var a in oData) {
+        if (oData.hasOwnProperty(a)) {
+            if (typeof oData[a] == "object") {
+                strPretty += a + " : [" + oData[a].length + " values]\r\n";
+            } else {
+                strPretty += a + " : " + oData[a] + "\r\n";
+            }
+        }
+    }
+    return strPretty;
+};
 
 EXIF.readFromBinaryFile = function(oFile) {
-	return findEXIFinJPEG(oFile);
-}
+    return findEXIFinJPEG(oFile);
+};
 
-function loadAllImages()
-{
-	var aImages = document.getElementsByTagName("img");
-	for (var i=0;i<aImages.length;i++) {
-		if (aImages[i].getAttribute("exif") == "true") {
-			if (!aImages[i].complete) {
-				addEvent(aImages[i], "load",
-					function() {
-						EXIF.getData(this);
-					}
-				);
-			} else {
-				EXIF.getData(aImages[i]);
-			}
-		}
-	}
-}
+// function loadAllImages()
+// {
+//     var aImages = document.getElementsByTagName("img");
+//     var callb = function() {
+//         EXIF.getData(this);
+//     };
+//     for (var i=0;i<aImages.length;i++) {
+//         if (aImages[i].getAttribute("exif") == "true") {
+//             if (!aImages[i].complete) {
+//                 addEvent(aImages[i], "load", callb);
+//             } else {
+//                 EXIF.getData(aImages[i]);
+//             }
+//         }
+//     }
+// }
 
 // automatically load exif data for all images with exif=true when doc is ready
-jQuery(document).ready(loadAllImages);
+// $(document).ready(loadAllImages);
 
 // load data for images manually
-jQuery.fn.exifLoad = function(fncCallback) {
-	return this.each(function() {
-		EXIF.getData(this, fncCallback)
-	});
-}
+$.fn.exifLoad = function(fncCallback) {
+    return this.each(function() {
+        EXIF.getData(this, fncCallback);
+    });
+};
 
-jQuery.fn.exif = function(strTag) {
-	var aStrings = [];
-	this.each(function() {
-		aStrings.push(EXIF.getTag(this, strTag));
-	});
-	return aStrings;
-}
+$.fn.exif = function(strTag) {
+    var aStrings = [];
+    this.each(function() {
+        aStrings.push(EXIF.getTag(this, strTag));
+    });
+    return aStrings;
+};
 
-jQuery.fn.exifAll = function() {
-	var aStrings = [];
-	this.each(function() {
-		aStrings.push(EXIF.getAllTags(this));
-	});
-	return aStrings;
-}
+$.fn.exifAll = function() {
+    var aStrings = [];
+    this.each(function() {
+        aStrings.push(EXIF.getAllTags(this));
+    });
+    return aStrings;
+};
 
-jQuery.fn.exifPretty = function() {
-	var aStrings = [];
-	this.each(function() {
-		aStrings.push(EXIF.pretty(this));
-	});
-	return aStrings;
-}
+$.fn.exifPretty = function() {
+    var aStrings = [];
+    this.each(function() {
+        aStrings.push(EXIF.pretty(this));
+    });
+    return aStrings;
+};
 
-jQuery.fn.fileExif = function(fncCallback) {
+var getFilePart = function(file) {
+    if (file.slice) {
+        filePart = file.slice(0, 131072);
+    } else if (file.webkitSlice) {
+        filePart = file.webkitSlice(0, 131072);
+    } else if (file.mozSlice) {
+        filePart = file.mozSlice(0, 131072);
+    } else {
+        filePart = file;
+    }
+
+    return filePart;
+};
 
+$.fn.fileExif = function(callback) {
     var reader = new FileReader();
+
     reader.onload = function(event) {
         var content = event.target.result;
 
         var binaryResponse = new BinaryFile(content);
 
-        fncCallback(EXIF.readFromBinaryFile(binaryResponse));
+        callback(EXIF.readFromBinaryFile(binaryResponse));
+    };
+
+    reader.readAsBinaryString(getFilePart(this[0].files[0]));
+};
+
+$.fileExif = function(file, callback) {
+    var reader = new FileReader();
+
+    reader.onload = function(event) {
+        var content = event.target.result;
+
+        var binaryResponse = new BinaryFile(content);
 
+        callback(EXIF.readFromBinaryFile(binaryResponse));
     };
 
-    // TODO: Use the slice method to read just the first 128kb
-    // of the image, else reading large images will slow down stuff
-    reader.readAsBinaryString(this[0].files[0]);
-}
+    reader.readAsBinaryString(getFilePart(file));
+};
 
 })();
 
-
-})();
\ No newline at end of file
+})(jQuery);