Update to MediaWiki 1.18.0

* also update ArchLinux skin to chagnes in MonoBook
* Use only css to hide our menu bar when printing

23 files changed, 7622 insertions, 318 deletions

diff --git a/includes/media/BMP.php b/includes/media/BMP.php
index de836b59..6886e950 100644
--- a/includes/media/BMP.php
+++ b/includes/media/BMP.php
@@ -13,22 +13,39 @@
  * @ingroup Media
  */
 class BmpHandler extends BitmapHandler {
-	// We never want to use .bmp in an <img/> tag
+
+	/**
+	 * @param $file
+	 * @return bool
+	 */
 	function mustRender( $file ) {
 		return true;
 	}
 
-	// Render files as PNG
+	/**
+	 * Render files as PNG
+	 *
+	 * @param $text
+	 * @param $mime
+	 * @param $params
+	 * @return array
+	 */
 	function getThumbType( $text, $mime, $params = null ) {
 		return array( 'png', 'image/png' );
 	}
 
-	/*
+	/**
 	 * Get width and height from the bmp header.
+	 *
+	 * @param $image
+	 * @param $filename
+	 * @return array
 	 */
 	function getImageSize( $image, $filename ) {
-		$f = fopen( $filename, 'r' );
-		if(!$f) return false;
+		$f = fopen( $filename, 'rb' );
+		if( !$f ) {
+			return false;
+		}
 		$header = fread( $f, 54 );
 		fclose($f);
 
@@ -37,8 +54,12 @@ class BmpHandler extends BitmapHandler {
 		$h = substr( $header, 22, 4);
 
 		// Convert the unsigned long 32 bits (little endian):
-		$w = unpack( 'V' , $w );
-		$h = unpack( 'V' , $h );
+		try {
+			$w = wfUnpack( 'V', $w, 4 );
+			$h = wfUnpack( 'V', $h, 4 );
+		} catch ( MWException $e ) {
+			return false;
+		}
 		return array( $w[1], $h[1] );
 	}
 }
diff --git a/includes/media/Bitmap.php b/includes/media/Bitmap.php
index f5f7ba6d..5f796095 100644
--- a/includes/media/Bitmap.php
+++ b/includes/media/Bitmap.php
@@ -12,6 +12,14 @@
  * @ingroup Media
  */
 class BitmapHandler extends ImageHandler {
+
+	/**
+	 * @param $image File
+	 * @param $params array Transform parameters. Entries with the keys 'width'
+	 * and 'height' are the respective screen width and height, while the keys
+	 * 'physicalWidth' and 'physicalHeight' indicate the thumbnail dimensions.
+	 * @return bool
+	 */
 	function normaliseParams( $image, &$params ) {
 		global $wgMaxImageArea;
 		if ( !parent::normaliseParams( $image, $params ) ) {
@@ -19,25 +27,26 @@ class BitmapHandler extends ImageHandler {
 		}
 
 		$mimeType = $image->getMimeType();
+		# Obtain the source, pre-rotation dimensions
 		$srcWidth = $image->getWidth( $params['page'] );
 		$srcHeight = $image->getHeight( $params['page'] );
 
 		# Don't make an image bigger than the source
-		$params['physicalWidth'] = $params['width'];
-		$params['physicalHeight'] = $params['height'];
-
 		if ( $params['physicalWidth'] >= $srcWidth ) {
 			$params['physicalWidth'] = $srcWidth;
 			$params['physicalHeight'] = $srcHeight;
+
 			# Skip scaling limit checks if no scaling is required
-			if ( !$image->mustRender() )
+			# due to requested size being bigger than source.
+			if ( !$image->mustRender() ) {
 				return true;
+			}
 		}
-
+		
 		# Don't thumbnail an image so big that it will fill hard drives and send servers into swap
 		# JPEG has the handy property of allowing thumbnailing without full decompression, so we make
 		# an exception for it.
-		# FIXME: This actually only applies to ImageMagick
+		# @todo FIXME: This actually only applies to ImageMagick
 		if ( $mimeType !== 'image/jpeg' &&
 			$srcWidth * $srcHeight > $wgMaxImageArea )
 		{
@@ -46,6 +55,30 @@ class BitmapHandler extends ImageHandler {
 
 		return true;
 	}
+	
+	/**
+	 * Extracts the width/height if the image will be scaled before rotating
+	 * 
+	 * This will match the physical size/aspect ratio of the original image
+	 * prior to application of the rotation -- so for a portrait image that's
+	 * stored as raw landscape with 90-degress rotation, the resulting size
+	 * will be wider than it is tall.
+	 *
+	 * @param $params array Parameters as returned by normaliseParams
+	 * @param $rotation int The rotation angle that will be applied
+	 * @return array ($width, $height) array
+	 */
+	public function extractPreRotationDimensions( $params, $rotation ) {
+		if ( $rotation == 90 || $rotation == 270 ) {
+			# We'll resize before rotation, so swap the dimensions again
+			$width = $params['physicalHeight'];
+			$height = $params['physicalWidth'];
+		} else {
+			$width = $params['physicalWidth'];
+			$height = $params['physicalHeight'];
+		}
+		return array( $width, $height );
+	}
 
 
 	// Function that returns the number of pixels to be thumbnailed.
@@ -54,10 +87,15 @@ class BitmapHandler extends ImageHandler {
 		return $width * $height;
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $dstPath
+	 * @param  $dstUrl
+	 * @param  $params
+	 * @param int $flags
+	 * @return MediaTransformError|ThumbnailImage|TransformParameterError
+	 */
 	function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
-		global $wgUseImageMagick;
-		global $wgCustomConvertCommand, $wgUseImageResize;
-
 		if ( !$this->normaliseParams( $image, $params ) ) {
 			return new TransformParameterError( $params );
 		}
@@ -79,6 +117,7 @@ class BitmapHandler extends ImageHandler {
 			'mimeType' => $image->getMimeType(),
 			'srcPath' => $image->getPath(),
 			'dstPath' => $dstPath,
+			'dstUrl' => $dstUrl,
 		);
 
 		wfDebug( __METHOD__ . ": creating {$scalerParams['physicalDimensions']} thumbnail at $dstPath\n" );
@@ -93,20 +132,7 @@ class BitmapHandler extends ImageHandler {
 		}
 
 		# Determine scaler type
-		if ( !$dstPath ) {
-			# No output path available, client side scaling only
-			$scaler = 'client';
-		} elseif ( !$wgUseImageResize ) {
-			$scaler = 'client';
-		} elseif ( $wgUseImageMagick ) {
-			$scaler = 'im';
-		} elseif ( $wgCustomConvertCommand ) {
-			$scaler = 'custom';
-		} elseif ( function_exists( 'imagecreatetruecolor' ) ) {
-			$scaler = 'gd';
-		} else {
-			$scaler = 'client';
-		}
+		$scaler = self::getScalerType( $dstPath );
 		wfDebug( __METHOD__ . ": scaler $scaler\n" );
 
 		if ( $scaler == 'client' ) {
@@ -127,13 +153,28 @@ class BitmapHandler extends ImageHandler {
 			return $this->getClientScalingThumbnailImage( $image, $scalerParams );
 		}
 
+		# Try a hook
+		$mto = null;
+		wfRunHooks( 'BitmapHandlerTransform', array( $this, $image, &$scalerParams, &$mto ) );
+		if ( !is_null( $mto ) ) {
+			wfDebug( __METHOD__ . ": Hook to BitmapHandlerTransform created an mto\n" );
+			$scaler = 'hookaborted';
+		}
+
 		switch ( $scaler ) {
+			case 'hookaborted':
+				# Handled by the hook above
+				$err = $mto->isError() ? $mto : false;
+				break;
 			case 'im':
 				$err = $this->transformImageMagick( $image, $scalerParams );
 				break;
 			case 'custom':
 				$err = $this->transformCustom( $image, $scalerParams );
 				break;
+			case 'imext':
+				$err = $this->transformImageMagickExt( $image, $scalerParams );
+				break;
 			case 'gd':
 			default:
 				$err = $this->transformGd( $image, $scalerParams );
@@ -149,6 +190,8 @@ class BitmapHandler extends ImageHandler {
 			# Thumbnail was zero-byte and had to be removed
 			return new MediaTransformError( 'thumbnail_error',
 				$scalerParams['clientWidth'], $scalerParams['clientHeight'] );
+		} elseif ( $mto ) {
+			return $mto;
 		} else {
 			return new ThumbnailImage( $image, $dstUrl, $scalerParams['clientWidth'],
 				$scalerParams['clientHeight'], $dstPath );
@@ -156,12 +199,49 @@ class BitmapHandler extends ImageHandler {
 	}
 
 	/**
+	 * Returns which scaler type should be used. Creates parent directories
+	 * for $dstPath and returns 'client' on error
+	 *
+	 * @return string client,im,custom,gd
+	 */
+	protected static function getScalerType( $dstPath, $checkDstPath = true ) {
+		global $wgUseImageResize, $wgUseImageMagick, $wgCustomConvertCommand;
+
+		if ( !$dstPath && $checkDstPath ) {
+			# No output path available, client side scaling only
+			$scaler = 'client';
+		} elseif ( !$wgUseImageResize ) {
+			$scaler = 'client';
+		} elseif ( $wgUseImageMagick ) {
+			$scaler = 'im';
+		} elseif ( $wgCustomConvertCommand ) {
+			$scaler = 'custom';
+		} elseif ( function_exists( 'imagecreatetruecolor' ) ) {
+			$scaler = 'gd';
+		} elseif ( class_exists( 'Imagick' ) ) {
+			$scaler = 'imext';
+		} else {
+			$scaler = 'client';
+		}
+
+		if ( $scaler != 'client' && $dstPath ) {
+			if ( !wfMkdirParents( dirname( $dstPath ) ) ) {
+				# Unable to create a path for the thumbnail
+				return 'client';
+			}
+		}
+		return $scaler;
+	}
+
+	/**
 	 * Get a ThumbnailImage that respresents an image that will be scaled
 	 * client side
 	 *
 	 * @param $image File File associated with this thumbnail
 	 * @param $params array Array with scaler params
 	 * @return ThumbnailImage
+	 *
+	 * @fixme no rotation support
 	 */
 	protected function getClientScalingThumbnailImage( $image, $params ) {
 		return new ThumbnailImage( $image, $image->getURL(),
@@ -215,7 +295,7 @@ class BitmapHandler extends ImageHandler {
 				// We optimize the output, but -optimize is broken,
 				// use optimizeTransparency instead (bug 11822)
 				if ( version_compare( $this->getMagickVersion(), "6.3.5" ) >= 0 ) {
-					$animation_post = '-fuzz 5% -layers optimizeTransparency +map';
+					$animation_post = '-fuzz 5% -layers optimizeTransparency';
 				}
 			}
 		}
@@ -225,6 +305,9 @@ class BitmapHandler extends ImageHandler {
 		if ( strval( $wgImageMagickTempDir ) !== '' ) {
 			$env['MAGICK_TMPDIR'] = $wgImageMagickTempDir;
 		}
+		
+		$rotation = $this->getRotation( $image );
+		list( $width, $height ) = $this->extractPreRotationDimensions( $params, $rotation );
 
 		$cmd  =
 			wfEscapeShellArg( $wgImageMagickConvertCommand ) .
@@ -237,12 +320,13 @@ class BitmapHandler extends ImageHandler {
 			// For the -thumbnail option a "!" is needed to force exact size,
 			// or ImageMagick may decide your ratio is wrong and slice off
 			// a pixel.
-			" -thumbnail " . wfEscapeShellArg( "{$params['physicalDimensions']}!" ) .
+			" -thumbnail " . wfEscapeShellArg( "{$width}x{$height}!" ) .
 			// Add the source url as a comment to the thumb, but don't add the flag if there's no comment
 			( $params['comment'] !== ''
 				? " -set comment " . wfEscapeShellArg( $this->escapeMagickProperty( $params['comment'] ) )
 				: '' ) .
-			" -depth 8 $sharpen" .
+			" -depth 8 $sharpen " .
+			" -rotate -$rotation " .
 			" {$animation_post} " .
 			wfEscapeShellArg( $this->escapeMagickOutput( $params['dstPath'] ) ) . " 2>&1";
 
@@ -261,6 +345,84 @@ class BitmapHandler extends ImageHandler {
 	}
 
 	/**
+	 * Transform an image using the Imagick PHP extension
+	 *
+	 * @param $image File File associated with this thumbnail
+	 * @param $params array Array with scaler params
+	 *
+	 * @return MediaTransformError Error object if error occured, false (=no error) otherwise
+	 */
+	protected function transformImageMagickExt( $image, $params ) {
+		global $wgSharpenReductionThreshold, $wgSharpenParameter, $wgMaxAnimatedGifArea;
+
+		try {
+			$im = new Imagick();
+			$im->readImage( $params['srcPath'] );
+
+			if ( $params['mimeType'] == 'image/jpeg' ) {
+				// Sharpening, see bug 6193
+				if ( ( $params['physicalWidth'] + $params['physicalHeight'] )
+						/ ( $params['srcWidth'] + $params['srcHeight'] )
+						< $wgSharpenReductionThreshold ) {
+					// Hack, since $wgSharpenParamater is written specifically for the command line convert
+					list( $radius, $sigma ) = explode( 'x', $wgSharpenParameter );
+					$im->sharpenImage( $radius, $sigma );
+				}
+				$im->setCompressionQuality( 80 );
+			} elseif( $params['mimeType'] == 'image/png' ) {
+				$im->setCompressionQuality( 95 );
+			} elseif ( $params['mimeType'] == 'image/gif' ) {
+				if ( $this->getImageArea( $image, $params['srcWidth'],
+						$params['srcHeight'] ) > $wgMaxAnimatedGifArea ) {
+					// Extract initial frame only; we're so big it'll
+					// be a total drag. :P
+					$im->setImageScene( 0 );
+				} elseif ( $this->isAnimatedImage( $image ) ) {
+					// Coalesce is needed to scale animated GIFs properly (bug 1017).
+					$im = $im->coalesceImages();
+				}
+			}
+
+			$rotation = $this->getRotation( $image );
+			list( $width, $height ) = $this->extractPreRotationDimensions( $params, $rotation );
+
+			$im->setImageBackgroundColor( new ImagickPixel( 'white' ) );
+
+			// Call Imagick::thumbnailImage on each frame
+			foreach ( $im as $i => $frame ) {
+				if ( !$frame->thumbnailImage( $width, $height, /* fit */ false ) ) {
+					return $this->getMediaTransformError( $params, "Error scaling frame $i" );
+				}
+			}
+			$im->setImageDepth( 8 );
+
+			if ( $rotation ) {
+				if ( !$im->rotateImage( new ImagickPixel( 'white' ), 360 - $rotation ) ) {
+					return $this->getMediaTransformError( $params, "Error rotating $rotation degrees" );
+				}
+			}
+
+			if ( $this->isAnimatedImage( $image ) ) {
+				wfDebug( __METHOD__ . ": Writing animated thumbnail\n" );
+				// This is broken somehow... can't find out how to fix it
+				$result = $im->writeImages( $params['dstPath'], true );
+			} else {
+				$result = $im->writeImage( $params['dstPath'] );
+			}
+			if ( !$result ) {
+				return $this->getMediaTransformError( $params,
+					"Unable to write thumbnail to {$params['dstPath']}" );
+			}
+
+		} catch ( ImagickException $e ) {
+			return $this->getMediaTransformError( $params, $e->getMessage() );
+		}
+
+		return false;
+
+	}
+
+	/**
 	 * Transform an image using a custom command
 	 *
 	 * @param $image File File associated with this thumbnail
@@ -306,12 +468,12 @@ class BitmapHandler extends ImageHandler {
 	}
 	/**
 	 * Get a MediaTransformError with error 'thumbnail_error'
-	 * 
+	 *
 	 * @param $params array Parameter array as passed to the transform* functions
 	 * @param $errMsg string Error message
 	 * @return MediaTransformError
 	 */
-	protected function getMediaTransformError( $params, $errMsg ) {
+	public function getMediaTransformError( $params, $errMsg ) {
 		return new MediaTransformError( 'thumbnail_error', $params['clientWidth'],
 					$params['clientHeight'], $errMsg );
 	}
@@ -360,8 +522,10 @@ class BitmapHandler extends ImageHandler {
 		}
 
 		$src_image = call_user_func( $loader, $params['srcPath'] );
-		$dst_image = imagecreatetruecolor( $params['physicalWidth'],
-			$params['physicalHeight'] );
+
+		$rotation = function_exists( 'imagerotate' ) ? $this->getRotation( $image ) : 0;
+		list( $width, $height ) = $this->extractPreRotationDimensions( $params, $rotation );
+		$dst_image = imagecreatetruecolor( $width, $height );
 
 		// Initialise the destination image to transparent instead of
 		// the default solid black, to support PNG and GIF transparency nicely
@@ -374,15 +538,21 @@ class BitmapHandler extends ImageHandler {
 			// It may just uglify them, and completely breaks transparency.
 			imagecopyresized( $dst_image, $src_image,
 				0, 0, 0, 0,
-				$params['physicalWidth'], $params['physicalHeight'],
+				$width, $height,
 				imagesx( $src_image ), imagesy( $src_image ) );
 		} else {
 			imagecopyresampled( $dst_image, $src_image,
 				0, 0, 0, 0,
-				$params['physicalWidth'], $params['physicalHeight'],
+				$width, $height,
 				imagesx( $src_image ), imagesy( $src_image ) );
 		}
 
+		if ( $rotation % 360 != 0 && $rotation % 90 == 0 ) {
+			$rot_image = imagerotate( $dst_image, $rotation, 0 );
+			imagedestroy( $dst_image );
+			$dst_image = $rot_image;
+		}
+
 		imagesavealpha( $dst_image, true );
 
 		call_user_func( $saveType, $dst_image, $params['dstPath'] );
@@ -508,98 +678,57 @@ class BitmapHandler extends ImageHandler {
 		imagejpeg( $dst_image, $thumbPath, 95 );
 	}
 
-
-	function getMetadata( $image, $filename ) {
-		global $wgShowEXIF;
-		if ( $wgShowEXIF && file_exists( $filename ) ) {
-			$exif = new Exif( $filename );
-			$data = $exif->getFilteredData();
-			if ( $data ) {
-				$data['MEDIAWIKI_EXIF_VERSION'] = Exif::version();
-				return serialize( $data );
-			} else {
-				return '0';
-			}
-		} else {
-			return '';
-		}
-	}
-
-	function getMetadataType( $image ) {
-		return 'exif';
-	}
-
-	function isMetadataValid( $image, $metadata ) {
-		global $wgShowEXIF;
-		if ( !$wgShowEXIF ) {
-			# Metadata disabled and so an empty field is expected
-			return true;
-		}
-		if ( $metadata === '0' ) {
-			# Special value indicating that there is no EXIF data in the file
-			return true;
-		}
-		wfSuppressWarnings();
-		$exif = unserialize( $metadata );
-		wfRestoreWarnings();
-		if ( !isset( $exif['MEDIAWIKI_EXIF_VERSION'] ) ||
-			$exif['MEDIAWIKI_EXIF_VERSION'] != Exif::version() )
-		{
-			# Wrong version
-			wfDebug( __METHOD__ . ": wrong version\n" );
-			return false;
-		}
-		return true;
+	/**
+	 * On supporting image formats, try to read out the low-level orientation
+	 * of the file and return the angle that the file needs to be rotated to
+	 * be viewed.
+	 *
+	 * This information is only useful when manipulating the original file;
+	 * the width and height we normally work with is logical, and will match
+	 * any produced output views.
+	 *
+	 * The base BitmapHandler doesn't understand any metadata formats, so this
+	 * is left up to child classes to implement.
+	 *
+	 * @param $file File
+	 * @return int 0, 90, 180 or 270
+	 */
+	public function getRotation( $file ) {
+		return 0;
 	}
 
 	/**
-	 * Get a list of EXIF metadata items which should be displayed when
-	 * the metadata table is collapsed.
+	 * Returns whether the current scaler supports rotation (im and gd do)
 	 *
-	 * @return array of strings
-	 * @access private
+	 * @return bool
 	 */
-	function visibleMetadataFields() {
-		$fields = array();
-		$lines = explode( "\n", wfMsgForContent( 'metadata-fields' ) );
-		foreach ( $lines as $line ) {
-			$matches = array();
-			if ( preg_match( '/^\\*\s*(.*?)\s*$/', $line, $matches ) ) {
-				$fields[] = $matches[1];
-			}
+	public static function canRotate() {
+		$scaler = self::getScalerType( null, false );
+		switch ( $scaler ) {
+			case 'im':
+				# ImageMagick supports autorotation
+				return true;
+			case 'imext':
+				# Imagick::rotateImage
+				return true;
+			case 'gd':
+				# GD's imagerotate function is used to rotate images, but not
+				# all precompiled PHP versions have that function
+				return function_exists( 'imagerotate' );
+			default:
+				# Other scalers don't support rotation
+				return false;
 		}
-		$fields = array_map( 'strtolower', $fields );
-		return $fields;
 	}
 
-	function formatMetadata( $image ) {
-		$result = array(
-			'visible' => array(),
-			'collapsed' => array()
-		);
-		$metadata = $image->getMetadata();
-		if ( !$metadata ) {
-			return false;
-		}
-		$exif = unserialize( $metadata );
-		if ( !$exif ) {
-			return false;
-		}
-		unset( $exif['MEDIAWIKI_EXIF_VERSION'] );
-		$format = new FormatExif( $exif );
-
-		$formatted = $format->getFormattedData();
-		// Sort fields into visible and collapsed
-		$visibleFields = $this->visibleMetadataFields();
-		foreach ( $formatted as $name => $value ) {
-			$tag = strtolower( $name );
-			self::addMeta( $result,
-				in_array( $tag, $visibleFields ) ? 'visible' : 'collapsed',
-				'exif',
-				$tag,
-				$value
-			);
-		}
-		return $result;
+	/**
+	 * Rerurns whether the file needs to be rendered. Returns true if the
+	 * file requires rotation and we are able to rotate it.
+	 *
+	 * @param $file File
+	 * @return bool
+	 */
+	public function mustRender( $file ) {
+		return self::canRotate() && $this->getRotation( $file ) != 0;
 	}
 }
diff --git a/includes/media/BitmapMetadataHandler.php b/includes/media/BitmapMetadataHandler.php
new file mode 100644
index 00000000..d1caa67a
--- /dev/null
+++ b/includes/media/BitmapMetadataHandler.php
@@ -0,0 +1,269 @@
+<?php
+/**
+Class to deal with reconciling and extracting metadata from bitmap images.
+This is meant to comply with http://www.metadataworkinggroup.org/pdf/mwg_guidance.pdf
+
+This sort of acts as an intermediary between MediaHandler::getMetadata
+and the various metadata extractors.
+
+@todo other image formats.
+*/
+class BitmapMetadataHandler {
+
+	private $metadata = array();
+	private $metaPriority = array(
+		20 => array( 'other' ),
+		40 => array( 'native' ),
+		60 => array( 'iptc-good-hash', 'iptc-no-hash' ),
+		70 => array( 'xmp-deprecated' ),
+		80 => array( 'xmp-general' ),
+		90 => array( 'xmp-exif' ),
+		100 => array( 'iptc-bad-hash' ),
+		120 => array( 'exif' ),
+	);
+	private $iptcType = 'iptc-no-hash';
+
+	/**
+	* This does the photoshop image resource app13 block
+	* of interest, IPTC-IIM metadata is stored here.
+	*
+	* Mostly just calls doPSIR and doIPTC
+	*
+	* @param String $app13 String containing app13 block from jpeg file
+	*/
+	private function doApp13 ( $app13 ) {
+		$this->iptcType = JpegMetadataExtractor::doPSIR( $app13 );
+
+		$iptc = IPTC::parse( $app13 );
+		$this->addMetadata( $iptc, $this->iptcType );
+	}
+
+
+	/**
+	 * Get exif info using exif class.
+	 * Basically what used to be in BitmapHandler::getMetadata().
+	 * Just calls stuff in the Exif class.
+	 *
+	 * @param $filename string
+	 */
+	function getExif ( $filename, $byteOrder ) {
+		global $wgShowEXIF;
+		if ( file_exists( $filename ) && $wgShowEXIF ) {
+			$exif = new Exif( $filename, $byteOrder );
+			$data = $exif->getFilteredData();
+			if ( $data ) {
+				$this->addMetadata( $data, 'exif' );
+			}
+		}
+	}
+	/** Add misc metadata. Warning: atm if the metadata category
+	* doesn't have a priority, it will be silently discarded.
+	*
+	* @param Array $metaArray array of metadata values
+	* @param string $type type. defaults to other. if two things have the same type they're merged
+	*/
+	function addMetadata ( $metaArray, $type = 'other' ) {
+		if ( isset( $this->metadata[$type] ) ) {
+			/* merge with old data */
+			$metaArray = $metaArray + $this->metadata[$type];
+		}
+
+		$this->metadata[$type] = $metaArray;
+	}
+
+	/**
+	* Merge together the various types of metadata
+	* the different types have different priorites,
+	* and are merged in order.
+	*
+	* This function is generally called by the media handlers' getMetadata()
+	*
+	* @return Array metadata array
+	*/
+	function getMetadataArray () {
+		// this seems a bit ugly... This is all so its merged in right order
+		// based on the MWG recomendation.
+		$temp = Array();
+		krsort( $this->metaPriority );
+		foreach ( $this->metaPriority as $pri ) {
+			foreach ( $pri as $type ) {
+				if ( isset( $this->metadata[$type] ) ) {
+					// Do some special casing for multilingual values.
+					// Don't discard translations if also as a simple value.
+					foreach ( $this->metadata[$type] as $itemName => $item ) {
+						if ( is_array( $item ) && isset( $item['_type'] ) && $item['_type'] === 'lang' ) {
+							if ( isset( $temp[$itemName] ) && !is_array( $temp[$itemName] ) ) {
+								$default = $temp[$itemName];
+								$temp[$itemName] = $item;
+								$temp[$itemName]['x-default'] = $default;
+								unset( $this->metadata[$type][$itemName] );
+							}
+						}
+					}
+
+					$temp = $temp + $this->metadata[$type];
+				}
+			}
+		}
+		return $temp;
+	}
+
+	/** Main entry point for jpeg's.
+	 *
+	 * @param $filename string filename (with full path)
+	 * @return metadata result array.
+	 * @throws MWException on invalid file.
+	 */
+	static function Jpeg ( $filename ) {
+		$showXMP = function_exists( 'xml_parser_create_ns' );
+		$meta = new self();
+
+		$seg = JpegMetadataExtractor::segmentSplitter( $filename );
+		if ( isset( $seg['COM'] ) && isset( $seg['COM'][0] ) ) {
+			$meta->addMetadata( Array( 'JPEGFileComment' => $seg['COM'] ), 'native' );
+		}
+		if ( isset( $seg['PSIR'] ) ) {
+			$meta->doApp13( $seg['PSIR'] );
+		}
+		if ( isset( $seg['XMP'] ) && $showXMP ) {
+			$xmp = new XMPReader();
+			$xmp->parse( $seg['XMP'] );
+			foreach ( $seg['XMP_ext'] as $xmpExt ) {
+				/* Support for extended xmp in jpeg files
+				 * is not well tested and a bit fragile.
+				 */
+				$xmp->parseExtended( $xmpExt );
+
+			}
+			$res = $xmp->getResults();
+			foreach ( $res as $type => $array ) {
+				$meta->addMetadata( $array, $type );
+			}
+		}
+		if ( isset( $seg['byteOrder'] ) ) {
+			$meta->getExif( $filename, $seg['byteOrder'] );
+		}
+		return $meta->getMetadataArray();
+	}
+
+	/** Entry point for png
+	 * At some point in the future this might
+	 * merge the png various tEXt chunks to that
+	 * are interesting, but for now it only does XMP
+	 *
+	 * @param $filename String full path to file
+	 * @return Array Array for storage in img_metadata.
+	 */
+	static public function PNG ( $filename ) {
+		$showXMP = function_exists( 'xml_parser_create_ns' );
+
+		$meta = new self();
+		$array = PNGMetadataExtractor::getMetadata( $filename );
+		if ( isset( $array['text']['xmp']['x-default'] ) && $array['text']['xmp']['x-default'] !== '' && $showXMP ) {
+			$xmp = new XMPReader();
+			$xmp->parse( $array['text']['xmp']['x-default'] );
+			$xmpRes = $xmp->getResults();
+			foreach ( $xmpRes as $type => $xmpSection ) {
+				$meta->addMetadata( $xmpSection, $type );
+			}
+		}
+		unset( $array['text']['xmp'] );
+		$meta->addMetadata( $array['text'], 'native' );
+		unset( $array['text'] );
+		$array['metadata'] = $meta->getMetadataArray();
+		$array['metadata']['_MW_PNG_VERSION'] = PNGMetadataExtractor::VERSION;
+		return $array;
+	}
+
+	/** function for gif images.
+	 *
+	 * They don't really have native metadata, so just merges together
+	 * XMP and image comment.
+	 *
+	 * @param $filename full path to file
+	 * @return Array metadata array
+	 */
+	static public function GIF ( $filename ) {
+
+		$meta = new self();
+		$baseArray = GIFMetadataExtractor::getMetadata( $filename );
+
+		if ( count( $baseArray['comment'] ) > 0 ) {
+			$meta->addMetadata( array( 'GIFFileComment' => $baseArray['comment'] ), 'native' );
+		}
+
+		if ( $baseArray['xmp'] !== '' && function_exists( 'xml_parser_create_ns' ) ) {
+			$xmp = new XMPReader();
+			$xmp->parse( $baseArray['xmp'] );
+			$xmpRes = $xmp->getResults();
+			foreach ( $xmpRes as $type => $xmpSection ) {
+				$meta->addMetadata( $xmpSection, $type );
+			}
+
+		}
+
+		unset( $baseArray['comment'] );
+		unset( $baseArray['xmp'] );
+	
+		$baseArray['metadata'] = $meta->getMetadataArray();
+		$baseArray['metadata']['_MW_GIF_VERSION'] = GIFMetadataExtractor::VERSION;
+		return $baseArray;
+	}
+
+	/**
+	 * This doesn't do much yet, but eventually I plan to add
+	 * XMP support for Tiff. (PHP's exif support already extracts
+	 * but needs some further processing because PHP's exif support
+	 * is stupid...)
+	 *
+	 * @todo Add XMP support, so this function actually makes
+	 * sense to put here.
+	 *
+	 * The various exceptions this throws are caught later.
+	 * @param $filename String
+	 * @return Array The metadata.
+	 */
+	static public function Tiff ( $filename ) {
+		if ( file_exists( $filename ) ) {
+			$byteOrder = self::getTiffByteOrder( $filename );
+			if ( !$byteOrder ) {
+				throw new MWException( "Error determining byte order of $filename" );
+			}
+			$exif = new Exif( $filename, $byteOrder );
+			$data = $exif->getFilteredData();
+			if ( $data ) {
+				$data['MEDIAWIKI_EXIF_VERSION'] = Exif::version();
+				return $data;
+			} else {
+				throw new MWException( "Could not extract data from tiff file $filename" );
+			}
+		} else {
+			throw new MWException( "File doesn't exist - $filename" );
+		}
+	}
+	/**
+	 * Read the first 2 bytes of a tiff file to figure out
+	 * Little Endian or Big Endian. Needed for exif stuff.
+	 *
+	 * @param $filename String The filename
+	 * @return String 'BE' or 'LE' or false
+	 */
+	static function getTiffByteOrder( $filename ) {
+		$fh = fopen( $filename, 'rb' );
+		if ( !$fh ) return false;
+		$head = fread( $fh, 2 );
+		fclose( $fh );
+
+		switch( $head ) {
+			case 'II':
+				return 'LE'; // II for intel.
+			case 'MM':
+				return 'BE'; // MM for motorla.
+			default:
+				return false; // Something went wrong.
+
+		}
+	}
+
+
+}
diff --git a/includes/media/Bitmap_ClientOnly.php b/includes/media/Bitmap_ClientOnly.php
index 9f6f7b33..50679229 100644
--- a/includes/media/Bitmap_ClientOnly.php
+++ b/includes/media/Bitmap_ClientOnly.php
@@ -15,10 +15,24 @@
  * @ingroup Media
  */
 class BitmapHandler_ClientOnly extends BitmapHandler {
+
+	/**
+	 * @param $image File
+	 * @param  $params
+	 * @return bool
+	 */
 	function normaliseParams( $image, &$params ) {
 		return ImageHandler::normaliseParams( $image, $params );
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $dstPath
+	 * @param  $dstUrl
+	 * @param  $params
+	 * @param int $flags
+	 * @return ThumbnailImage|TransformParameterError
+	 */
 	function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
 		if ( !$this->normaliseParams( $image, $params ) ) {
 			return new TransformParameterError( $params );
diff --git a/includes/media/DjVu.php b/includes/media/DjVu.php
index cc3f1db5..2833f683 100644
--- a/includes/media/DjVu.php
+++ b/includes/media/DjVu.php
@@ -5,13 +5,17 @@
  * @file
  * @ingroup Media
  */
- 
+
 /**
  * Handler for DjVu images
  *
  * @ingroup Media
  */
 class DjVuHandler extends ImageHandler {
+
+	/**
+	 * @return bool
+	 */
 	function isEnabled() {
 		global $wgDjvuRenderer, $wgDjvuDump, $wgDjvuToXML;
 		if ( !$wgDjvuRenderer || ( !$wgDjvuDump && !$wgDjvuToXML ) ) {
@@ -22,9 +26,25 @@ class DjVuHandler extends ImageHandler {
 		}
 	}
 
-	function mustRender( $file ) { return true; }
-	function isMultiPage( $file ) { return true; }
+	/**
+	 * @param $file
+	 * @return bool
+	 */
+	function mustRender( $file ) {
+		return true;
+	}
+
+	/**
+	 * @param $file
+	 * @return bool
+	 */
+	function isMultiPage( $file ) {
+		return true;
+	}
 
+	/**
+	 * @return array
+	 */
 	function getParamMap() {
 		return array(
 			'img_width' => 'width',
@@ -32,6 +52,11 @@ class DjVuHandler extends ImageHandler {
 		);
 	}
 
+	/**
+	 * @param $name
+	 * @param $value
+	 * @return bool
+	 */
 	function validateParam( $name, $value ) {
 		if ( in_array( $name, array( 'width', 'height', 'page' ) ) ) {
 			if ( $value <= 0 ) {
@@ -44,6 +69,10 @@ class DjVuHandler extends ImageHandler {
 		}
 	}
 
+	/**
+	 * @param $params
+	 * @return bool|string
+	 */
 	function makeParamString( $params ) {
 		$page = isset( $params['page'] ) ? $params['page'] : 1;
 		if ( !isset( $params['width'] ) ) {
@@ -52,6 +81,10 @@ class DjVuHandler extends ImageHandler {
 		return "page{$page}-{$params['width']}px";
 	}
 
+	/**
+	 * @param $str
+	 * @return array|bool
+	 */
 	function parseParamString( $str ) {
 		$m = false;
 		if ( preg_match( '/^page(\d+)-(\d+)px$/', $str, $m ) ) {
@@ -61,6 +94,10 @@ class DjVuHandler extends ImageHandler {
 		}
 	}
 
+	/**
+	 * @param $params
+	 * @return array
+	 */
 	function getScriptParams( $params ) {
 		return array(
 			'width' => $params['width'],
@@ -68,6 +105,14 @@ class DjVuHandler extends ImageHandler {
 		);
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $dstPath
+	 * @param  $dstUrl
+	 * @param  $params
+	 * @param int $flags
+	 * @return MediaTransformError|ThumbnailImage|TransformParameterError
+	 */
 	function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
 		global $wgDjvuRenderer, $wgDjvuPostProcessor;
 
@@ -75,7 +120,9 @@ class DjVuHandler extends ImageHandler {
 		// normaliseParams will inevitably give.
 		$xml = $image->getMetadata();
 		if ( !$xml ) {
-			return new MediaTransformError( 'thumbnail_error', @$params['width'], @$params['height'],
+			$width = isset( $params['width'] ) ? $params['width'] : 0;
+			$height = isset( $params['height'] ) ? $params['height'] : 0;
+			return new MediaTransformError( 'thumbnail_error', $width, $height,
 				wfMsg( 'djvu_no_xml' ) );
 		}
 
@@ -100,7 +147,8 @@ class DjVuHandler extends ImageHandler {
 
 		# Use a subshell (brackets) to aggregate stderr from both pipeline commands
 		# before redirecting it to the overall stdout. This works in both Linux and Windows XP.
-		$cmd = '(' . wfEscapeShellArg( $wgDjvuRenderer ) . " -format=ppm -page={$page} -size={$width}x{$height} " .
+		$cmd = '(' . wfEscapeShellArg( $wgDjvuRenderer ) . " -format=ppm -page={$page}" . 
+			" -size={$params['physicalWidth']}x{$params['physicalHeight']} " .
 			wfEscapeShellArg( $srcPath );
 		if ( $wgDjvuPostProcessor ) {
 			$cmd .= " | {$wgDjvuPostProcessor}";
@@ -125,6 +173,8 @@ class DjVuHandler extends ImageHandler {
 
 	/**
 	 * Cache an instance of DjVuImage in an Image object, return that instance
+	 *
+	 * @return DjVuImage
 	 */
 	function getDjVuImage( $image, $path ) {
 		if ( !$image ) {
@@ -139,6 +189,7 @@ class DjVuHandler extends ImageHandler {
 
 	/**
 	 * Cache a document tree for the DjVu XML metadata
+	 * @param $image File
 	 */
 	function getMetaTree( $image , $gettext = false ) {
 		if ( isset( $image->dejaMetaTree ) ) {
@@ -159,11 +210,11 @@ class DjVuHandler extends ImageHandler {
 			$image->djvuTextTree = false;
 			$tree = new SimpleXMLElement( $metadata );
 			if( $tree->getName() == 'mw-djvu' ) {
-				foreach($tree->children() as $b){ 
+				foreach($tree->children() as $b){
 					if( $b->getName() == 'DjVuTxt' ) {
 						$image->djvuTextTree = $b;
 					}
-					else if ( $b->getName() == 'DjVuXML' ) {
+					elseif ( $b->getName() == 'DjVuXML' ) {
 						$image->dejaMetaTree = $b;
 					}
 				}
diff --git a/includes/media/Exif.php b/includes/media/Exif.php
new file mode 100644
index 00000000..345a6f19
--- /dev/null
+++ b/includes/media/Exif.php
@@ -0,0 +1,836 @@
+<?php
+/**
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @ingroup Media
+ * @author Ævar Arnfjörð Bjarmason <avarab@gmail.com>
+ * @copyright Copyright © 2005, Ævar Arnfjörð Bjarmason, 2009 Brent Garber
+ * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License
+ * @see http://exif.org/Exif2-2.PDF The Exif 2.2 specification
+ * @file
+ */
+
+/**
+ * Class to extract and validate Exif data from jpeg (and possibly tiff) files.
+ * @ingroup Media
+ */
+class Exif {
+
+	const BYTE      = 1;    //!< An 8-bit (1-byte) unsigned integer.
+	const ASCII     = 2;    //!< An 8-bit byte containing one 7-bit ASCII code. The final byte is terminated with NULL.
+	const SHORT     = 3;    //!< A 16-bit (2-byte) unsigned integer.
+	const LONG      = 4;    //!< A 32-bit (4-byte) unsigned integer.
+	const RATIONAL  = 5;    //!< Two LONGs. The first LONG is the numerator and the second LONG expresses the denominator
+	const UNDEFINED = 7;    //!< An 8-bit byte that can take any value depending on the field definition
+	const SLONG     = 9;    //!< A 32-bit (4-byte) signed integer (2's complement notation),
+	const SRATIONAL = 10;   //!< Two SLONGs. The first SLONG is the numerator and the second SLONG is the denominator.
+	const IGNORE    = -1;   // A fake value for things we don't want or don't support.
+
+	//@{
+	/* @var array
+	 * @private
+	 */
+
+	/**
+	 * Exif tags grouped by category, the tagname itself is the key and the type
+	 * is the value, in the case of more than one possible value type they are
+	 * separated by commas.
+	 */
+	var $mExifTags;
+
+	/**
+	 * The raw Exif data returned by exif_read_data()
+	 */
+	var $mRawExifData;
+
+	/**
+	 * A Filtered version of $mRawExifData that has been pruned of invalid
+	 * tags and tags that contain content they shouldn't contain according
+	 * to the Exif specification
+	 */
+	var $mFilteredExifData;
+
+	/**
+	 * Filtered and formatted Exif data, see FormatMetadata::getFormattedData()
+	 */
+	var $mFormattedExifData;
+
+	//@}
+
+	//@{
+	/* @var string
+	 * @private
+	 */
+
+	/**
+	 * The file being processed
+	 */
+	var $file;
+
+	/**
+	 * The basename of the file being processed
+	 */
+	var $basename;
+
+	/**
+	 * The private log to log to, e.g. 'exif'
+	 */
+	var $log = false;
+
+	/**
+	 * The byte order of the file. Needed because php's
+	 * extension doesn't fully process some obscure props.
+	 */
+	private $byteOrder;
+	//@}
+
+	/**
+	 * Constructor
+	 *
+	 * @param $file String: filename.
+	 * @todo FIXME: The following are broke:
+	 * SubjectArea. Need to test the more obscure tags.
+	 *
+	 * DigitalZoomRatio = 0/0 is rejected. need to determine if that's valid.
+	 * possibly should treat 0/0 = 0. need to read exif spec on that.
+	 */
+	function __construct( $file, $byteOrder = '' ) {
+		/**
+		 * Page numbers here refer to pages in the EXIF 2.2 standard
+		 *
+		 * Note, Exif::UNDEFINED is treated as a string, not as an array of bytes
+		 * so don't put a count parameter for any UNDEFINED values.
+		 *
+		 * @link http://exif.org/Exif2-2.PDF The Exif 2.2 specification
+		 */
+		$this->mExifTags = array(
+			# TIFF Rev. 6.0 Attribute Information (p22)
+			'IFD0' => array(
+				# Tags relating to image structure
+				'ImageWidth' => Exif::SHORT.','.Exif::LONG,		# Image width
+				'ImageLength' => Exif::SHORT.','.Exif::LONG,		# Image height
+				'BitsPerSample' => array( Exif::SHORT, 3 ),		# Number of bits per component
+				# "When a primary image is JPEG compressed, this designation is not"
+				# "necessary and is omitted." (p23)
+				'Compression' => Exif::SHORT,				# Compression scheme #p23
+				'PhotometricInterpretation' => Exif::SHORT,		# Pixel composition #p23
+				'Orientation' => Exif::SHORT,				# Orientation of image #p24
+				'SamplesPerPixel' => Exif::SHORT,			# Number of components
+				'PlanarConfiguration' => Exif::SHORT,			# Image data arrangement #p24
+				'YCbCrSubSampling' => array( Exif::SHORT, 2),		# Subsampling ratio of Y to C #p24
+				'YCbCrPositioning' => Exif::SHORT,			# Y and C positioning #p24-25
+				'XResolution' => Exif::RATIONAL,			# Image resolution in width direction
+				'YResolution' => Exif::RATIONAL,			# Image resolution in height direction
+				'ResolutionUnit' => Exif::SHORT,			# Unit of X and Y resolution #(p26)
+
+				# Tags relating to recording offset
+				'StripOffsets' => Exif::SHORT.','.Exif::LONG,			# Image data location
+				'RowsPerStrip' => Exif::SHORT.','.Exif::LONG,			# Number of rows per strip
+				'StripByteCounts' => Exif::SHORT.','.Exif::LONG,		# Bytes per compressed strip
+				'JPEGInterchangeFormat' => Exif::SHORT.','.Exif::LONG,		# Offset to JPEG SOI
+				'JPEGInterchangeFormatLength' => Exif::SHORT.','.Exif::LONG,	# Bytes of JPEG data
+
+				# Tags relating to image data characteristics
+				'TransferFunction' => Exif::IGNORE,			# Transfer function
+				'WhitePoint' => array( Exif::RATIONAL, 2),		# White point chromaticity
+				'PrimaryChromaticities' => array( Exif::RATIONAL, 6),	# Chromaticities of primarities
+				'YCbCrCoefficients' => array( Exif::RATIONAL, 3),	# Color space transformation matrix coefficients #p27
+				'ReferenceBlackWhite' => array( Exif::RATIONAL, 6),	# Pair of black and white reference values
+
+				# Other tags
+				'DateTime' => Exif::ASCII,				# File change date and time
+				'ImageDescription' => Exif::ASCII,			# Image title
+				'Make' => Exif::ASCII,					# Image input equipment manufacturer
+				'Model' => Exif::ASCII,					# Image input equipment model
+				'Software' => Exif::ASCII,				# Software used
+				'Artist' => Exif::ASCII,				# Person who created the image
+				'Copyright' => Exif::ASCII,				# Copyright holder
+			),
+
+			# Exif IFD Attribute Information (p30-31)
+			'EXIF' => array(
+				# TODO: NOTE: Nonexistence of this field is taken to mean nonconformance
+				# to the EXIF 2.1 AND 2.2 standards
+				'ExifVersion' =>  Exif::UNDEFINED,			# Exif version
+				'FlashPixVersion' => Exif::UNDEFINED,			# Supported Flashpix version #p32
+
+				# Tags relating to Image Data Characteristics
+				'ColorSpace' => Exif::SHORT,				# Color space information #p32
+
+				# Tags relating to image configuration
+				'ComponentsConfiguration' => Exif::UNDEFINED,			# Meaning of each component #p33
+				'CompressedBitsPerPixel' => Exif::RATIONAL,			# Image compression mode
+				'PixelYDimension' => Exif::SHORT.','.Exif::LONG,		# Valid image width
+				'PixelXDimension' => Exif::SHORT.','.Exif::LONG,		# Valid image height
+
+				# Tags relating to related user information
+				'MakerNote' => Exif::IGNORE,				# Manufacturer notes
+				'UserComment' => Exif::UNDEFINED,			# User comments #p34
+
+				# Tags relating to related file information
+				'RelatedSoundFile' => Exif::ASCII,			# Related audio file
+
+				# Tags relating to date and time
+				'DateTimeOriginal' => Exif::ASCII,			# Date and time of original data generation #p36
+				'DateTimeDigitized' => Exif::ASCII,			# Date and time of original data generation
+				'SubSecTime' => Exif::ASCII,				# DateTime subseconds
+				'SubSecTimeOriginal' => Exif::ASCII,			# DateTimeOriginal subseconds
+				'SubSecTimeDigitized' => Exif::ASCII,			# DateTimeDigitized subseconds
+
+				# Tags relating to picture-taking conditions (p31)
+				'ExposureTime' => Exif::RATIONAL,			# Exposure time
+				'FNumber' => Exif::RATIONAL,				# F Number
+				'ExposureProgram' => Exif::SHORT,			# Exposure Program #p38
+				'SpectralSensitivity' => Exif::ASCII,			# Spectral sensitivity
+				'ISOSpeedRatings' => Exif::SHORT,			# ISO speed rating
+				'OECF' => Exif::IGNORE,
+				# Optoelectronic conversion factor. Note: We don't have support for this atm.
+				'ShutterSpeedValue' => Exif::SRATIONAL,			# Shutter speed
+				'ApertureValue' => Exif::RATIONAL,			# Aperture
+				'BrightnessValue' => Exif::SRATIONAL,			# Brightness
+				'ExposureBiasValue' => Exif::SRATIONAL,			# Exposure bias
+				'MaxApertureValue' => Exif::RATIONAL,			# Maximum land aperture
+				'SubjectDistance' => Exif::RATIONAL,			# Subject distance
+				'MeteringMode' => Exif::SHORT,				# Metering mode #p40
+				'LightSource' => Exif::SHORT,				# Light source #p40-41
+				'Flash' => Exif::SHORT,					# Flash #p41-42
+				'FocalLength' => Exif::RATIONAL,			# Lens focal length
+				'SubjectArea' => array( Exif::SHORT, 4 ),		# Subject area
+				'FlashEnergy' => Exif::RATIONAL,			# Flash energy
+				'SpatialFrequencyResponse' => Exif::IGNORE,		# Spatial frequency response. Not supported atm.
+				'FocalPlaneXResolution' => Exif::RATIONAL,		# Focal plane X resolution
+				'FocalPlaneYResolution' => Exif::RATIONAL,		# Focal plane Y resolution
+				'FocalPlaneResolutionUnit' => Exif::SHORT,		# Focal plane resolution unit #p46
+				'SubjectLocation' => array( Exif::SHORT, 2),		# Subject location
+				'ExposureIndex' => Exif::RATIONAL,			# Exposure index
+				'SensingMethod' => Exif::SHORT,				# Sensing method #p46
+				'FileSource' => Exif::UNDEFINED,			# File source #p47
+				'SceneType' => Exif::UNDEFINED,				# Scene type #p47
+				'CFAPattern' => Exif::IGNORE,				# CFA pattern. not supported atm.
+				'CustomRendered' => Exif::SHORT,			# Custom image processing #p48
+				'ExposureMode' => Exif::SHORT,				# Exposure mode #p48
+				'WhiteBalance' => Exif::SHORT,				# White Balance #p49
+				'DigitalZoomRatio' => Exif::RATIONAL,			# Digital zoom ration
+				'FocalLengthIn35mmFilm' => Exif::SHORT,			# Focal length in 35 mm film
+				'SceneCaptureType' => Exif::SHORT,			# Scene capture type #p49
+				'GainControl' => Exif::SHORT,				# Scene control #p49-50
+				'Contrast' => Exif::SHORT,				# Contrast #p50
+				'Saturation' => Exif::SHORT,				# Saturation #p50
+				'Sharpness' => Exif::SHORT,				# Sharpness #p50
+				'DeviceSettingDescription' => Exif::IGNORE,
+				# Device settings description. This could maybe be supported. Need to find an
+				# example file that uses this to see if it has stuff of interest in it.
+				'SubjectDistanceRange' => Exif::SHORT,			# Subject distance range #p51
+
+				'ImageUniqueID' => Exif::ASCII,				# Unique image ID
+			),
+
+			# GPS Attribute Information (p52)
+			'GPS' => array(
+				'GPSVersion' => Exif::UNDEFINED,
+				# Should be an array of 4 Exif::BYTE's. However php treats it as an undefined
+				# Note exif standard calls this GPSVersionID, but php doesn't like the id suffix
+				'GPSLatitudeRef' => Exif::ASCII,			# North or South Latitude #p52-53
+				'GPSLatitude' => array( Exif::RATIONAL, 3 ),		# Latitude
+				'GPSLongitudeRef' => Exif::ASCII,			# East or West Longitude #p53
+				'GPSLongitude' => array( Exif::RATIONAL, 3),		# Longitude
+				'GPSAltitudeRef' => Exif::UNDEFINED,
+				# Altitude reference. Note, the exif standard says this should be an EXIF::Byte,
+				# but php seems to disagree.
+				'GPSAltitude' => Exif::RATIONAL,			# Altitude
+				'GPSTimeStamp' => array( Exif::RATIONAL, 3),		# GPS time (atomic clock)
+				'GPSSatellites' => Exif::ASCII,				# Satellites used for measurement
+				'GPSStatus' => Exif::ASCII,				# Receiver status #p54
+				'GPSMeasureMode' => Exif::ASCII,			# Measurement mode #p54-55
+				'GPSDOP' => Exif::RATIONAL,				# Measurement precision
+				'GPSSpeedRef' => Exif::ASCII,				# Speed unit #p55
+				'GPSSpeed' => Exif::RATIONAL,				# Speed of GPS receiver
+				'GPSTrackRef' => Exif::ASCII,				# Reference for direction of movement #p55
+				'GPSTrack' => Exif::RATIONAL,				# Direction of movement
+				'GPSImgDirectionRef' => Exif::ASCII,			# Reference for direction of image #p56
+				'GPSImgDirection' => Exif::RATIONAL,			# Direction of image
+				'GPSMapDatum' => Exif::ASCII,				# Geodetic survey data used
+				'GPSDestLatitudeRef' => Exif::ASCII,			# Reference for latitude of destination #p56
+				'GPSDestLatitude' => array( Exif::RATIONAL, 3 ),	# Latitude destination
+				'GPSDestLongitudeRef' => Exif::ASCII,			# Reference for longitude of destination #p57
+				'GPSDestLongitude' => array( Exif::RATIONAL, 3 ),	# Longitude of destination
+				'GPSDestBearingRef' => Exif::ASCII,			# Reference for bearing of destination #p57
+				'GPSDestBearing' => Exif::RATIONAL,			# Bearing of destination
+				'GPSDestDistanceRef' => Exif::ASCII,			# Reference for distance to destination #p57-58
+				'GPSDestDistance' => Exif::RATIONAL,			# Distance to destination
+				'GPSProcessingMethod' => Exif::UNDEFINED,		# Name of GPS processing method
+				'GPSAreaInformation' => Exif::UNDEFINED,		# Name of GPS area
+				'GPSDateStamp' => Exif::ASCII,				# GPS date
+				'GPSDifferential' => Exif::SHORT,			# GPS differential correction
+			),
+		);
+
+		$this->file = $file;
+		$this->basename = wfBaseName( $this->file );
+		if ( $byteOrder === 'BE' || $byteOrder === 'LE' ) {
+			$this->byteOrder = $byteOrder;
+		} else {
+			// Only give a warning for b/c, since originally we didn't
+			// require this. The number of things affected by this is
+			// rather small.
+			wfWarn( 'Exif class did not have byte order specified. '
+			 . 'Some properties may be decoded incorrectly.' );
+			$this->byteOrder = 'BE'; // BE seems about twice as popular as LE in jpg's.
+		}
+
+		$this->debugFile( $this->basename, __FUNCTION__, true );
+		if( function_exists( 'exif_read_data' ) ) {
+			wfSuppressWarnings();
+			$data = exif_read_data( $this->file, 0, true );
+			wfRestoreWarnings();
+		} else {
+			throw new MWException( "Internal error: exif_read_data not present. \$wgShowEXIF may be incorrectly set or not checked by an extension." );
+		}
+		/**
+		 * exif_read_data() will return false on invalid input, such as
+		 * when somebody uploads a file called something.jpeg
+		 * containing random gibberish.
+		 */
+		$this->mRawExifData = $data ? $data : array();
+		$this->makeFilteredData();
+		$this->collapseData();
+		$this->debugFile( __FUNCTION__, false );
+	}
+
+	/**
+	 * Make $this->mFilteredExifData
+	 */
+	function makeFilteredData() {
+		$this->mFilteredExifData = Array();
+
+		foreach ( array_keys( $this->mRawExifData ) as $section ) {
+			if ( !in_array( $section, array_keys( $this->mExifTags ) ) ) {
+				$this->debug( $section , __FUNCTION__, "'$section' is not a valid Exif section" );
+				continue;
+			}
+
+			foreach ( array_keys( $this->mRawExifData[$section] ) as $tag ) {
+				if ( !in_array( $tag, array_keys( $this->mExifTags[$section] ) ) ) {
+					$this->debug( $tag, __FUNCTION__, "'$tag' is not a valid tag in '$section'" );
+					continue;
+				}
+
+				$this->mFilteredExifData[$tag] = $this->mRawExifData[$section][$tag];
+				// This is ok, as the tags in the different sections do not conflict.
+				// except in computed and thumbnail section, which we don't use.
+
+				$value = $this->mRawExifData[$section][$tag];
+				if ( !$this->validate( $section, $tag, $value ) ) {
+					$this->debug( $value, __FUNCTION__, "'$tag' contained invalid data" );
+					unset( $this->mFilteredExifData[$tag] );
+				}
+			}
+		}
+	}
+
+	/**
+	* Collapse some fields together.
+	* This converts some fields from exif form, to a more friendly form.
+	* For example GPS latitude to a single number.
+	*
+	* The rationale behind this is that we're storing data, not presenting to the user
+	* For example a longitude is a single number describing how far away you are from
+	* the prime meridian. Well it might be nice to split it up into minutes and seconds
+	* for the user, it doesn't really make sense to split a single number into 4 parts
+	* for storage. (degrees, minutes, second, direction vs single floating point number).
+	*
+	* Other things this might do (not really sure if they make sense or not):
+	* Dates -> mediawiki date format.
+	* convert values that can be in different units to be in one standardized unit.
+	*
+	* As an alternative approach, some of this could be done in the validate phase
+	* if we make up our own types like Exif::DATE.
+	*/
+	function collapseData( ) {
+
+		$this->exifGPStoNumber( 'GPSLatitude' );
+		$this->exifGPStoNumber( 'GPSDestLatitude' );
+		$this->exifGPStoNumber( 'GPSLongitude' );
+		$this->exifGPStoNumber( 'GPSDestLongitude' );
+
+		if ( isset( $this->mFilteredExifData['GPSAltitude'] ) && isset( $this->mFilteredExifData['GPSAltitudeRef'] ) ) {
+			if ( $this->mFilteredExifData['GPSAltitudeRef'] === "\1" ) {
+				$this->mFilteredExifData['GPSAltitude'] *= - 1;
+			}
+			unset( $this->mFilteredExifData['GPSAltitudeRef'] );
+		}
+
+		$this->exifPropToOrd( 'FileSource' );
+		$this->exifPropToOrd( 'SceneType' );
+
+		$this->charCodeString( 'UserComment' );
+		$this->charCodeString( 'GPSProcessingMethod');
+		$this->charCodeString( 'GPSAreaInformation' );
+		
+		//ComponentsConfiguration should really be an array instead of a string...
+		//This turns a string of binary numbers into an array of numbers.
+
+		if ( isset ( $this->mFilteredExifData['ComponentsConfiguration'] ) ) {
+			$val = $this->mFilteredExifData['ComponentsConfiguration'];
+			$ccVals = array();
+			for ($i = 0; $i < strlen($val); $i++) {
+				$ccVals[$i] = ord( substr($val, $i, 1) );
+			}
+			$ccVals['_type'] = 'ol'; //this is for formatting later.
+			$this->mFilteredExifData['ComponentsConfiguration'] = $ccVals;
+		}
+	
+		//GPSVersion(ID) is treated as the wrong type by php exif support.
+		//Go through each byte turning it into a version string.
+		//For example: "\x02\x02\x00\x00" -> "2.2.0.0"
+
+		//Also change exif tag name from GPSVersion (what php exif thinks it is)
+		//to GPSVersionID (what the exif standard thinks it is).
+
+		if ( isset ( $this->mFilteredExifData['GPSVersion'] ) ) {
+			$val = $this->mFilteredExifData['GPSVersion'];
+			$newVal = '';
+			for ($i = 0; $i < strlen($val); $i++) {
+				if ( $i !== 0 ) {
+					$newVal .= '.';
+				}
+				$newVal .= ord( substr($val, $i, 1) );
+			}
+			if ( $this->byteOrder === 'LE' ) {
+				// Need to reverse the string
+				$newVal2 = '';
+				for ( $i = strlen( $newVal ) - 1; $i >= 0; $i-- ) {
+					$newVal2 .= substr( $newVal, $i, 1 );
+				}
+				$this->mFilteredExifData['GPSVersionID'] = $newVal2;
+			} else {
+				$this->mFilteredExifData['GPSVersionID'] = $newVal;
+			}
+			unset( $this->mFilteredExifData['GPSVersion'] );
+		}
+
+	}
+	/**
+	* Do userComment tags and similar. See pg. 34 of exif standard.
+	* basically first 8 bytes is charset, rest is value.
+	* This has not been tested on any shift-JIS strings.
+	* @param $prop String prop name.
+	*/
+	private function charCodeString ( $prop ) {
+		if ( isset( $this->mFilteredExifData[$prop] ) ) {
+
+			if ( strlen($this->mFilteredExifData[$prop]) <= 8 ) {
+				//invalid. Must be at least 9 bytes long.
+
+				$this->debug( $this->mFilteredExifData[$prop] , __FUNCTION__, false );
+				unset($this->mFilteredExifData[$prop]);
+				return;
+			}
+			$charCode = substr( $this->mFilteredExifData[$prop], 0, 8);
+			$val = substr( $this->mFilteredExifData[$prop], 8);
+			
+			
+			switch ($charCode) {
+				case "\x4A\x49\x53\x00\x00\x00\x00\x00":
+					//JIS
+					$charset = "Shift-JIS";
+					break;
+				case "UNICODE\x00":
+					$charset = "UTF-16" . $this->byteOrder;
+					break;
+				default: //ascii or undefined.
+					$charset = "";
+					break;
+			}
+			// This could possibly check to see if iconv is really installed
+			// or if we're using the compatibility wrapper in globalFunctions.php
+			if ($charset) {
+				wfSuppressWarnings();
+				$val = iconv($charset, 'UTF-8//IGNORE', $val);
+				wfRestoreWarnings();
+			} else {
+				// if valid utf-8, assume that, otherwise assume windows-1252
+				$valCopy = $val;
+				UtfNormal::quickIsNFCVerify( $valCopy ); //validates $valCopy.
+				if ( $valCopy !== $val ) {
+					wfSuppressWarnings();
+					$val = iconv('Windows-1252', 'UTF-8//IGNORE', $val);
+					wfRestoreWarnings();
+				}
+			}
+			
+			//trim and check to make sure not only whitespace.
+			$val = trim($val);
+			if ( strlen( $val ) === 0 ) {
+				//only whitespace.
+				$this->debug( $this->mFilteredExifData[$prop] , __FUNCTION__, "$prop: Is only whitespace" );
+				unset($this->mFilteredExifData[$prop]);
+				return;
+			}
+
+			//all's good.
+			$this->mFilteredExifData[$prop] = $val;
+		}
+	}
+	/**
+	* Convert an Exif::UNDEFINED from a raw binary string
+	* to its value. This is sometimes needed depending on
+	* the type of UNDEFINED field
+	* @param $prop String name of property
+	*/
+	private function exifPropToOrd ( $prop ) {
+		if ( isset( $this->mFilteredExifData[$prop] ) ) {
+			$this->mFilteredExifData[$prop] = ord( $this->mFilteredExifData[$prop] );
+		}
+	}
+	/**
+	* Convert gps in exif form to a single floating point number
+	* for example 10 degress 20`40`` S -> -10.34444
+	* @param String $prop a gps coordinate exif tag name (like GPSLongitude)
+	*/
+	private function exifGPStoNumber ( $prop ) {
+		$loc =& $this->mFilteredExifData[$prop];
+		$dir =& $this->mFilteredExifData[$prop . 'Ref'];
+		$res = false;
+
+		if ( isset( $loc ) && isset( $dir ) && ( $dir === 'N' || $dir === 'S' || $dir === 'E' || $dir === 'W' ) ) {
+			list( $num, $denom ) = explode( '/', $loc[0] );
+			$res = $num / $denom;
+			list( $num, $denom ) = explode( '/', $loc[1] );
+			$res += ( $num / $denom ) * ( 1 / 60 );
+			list( $num, $denom ) = explode( '/', $loc[2] );
+			$res += ( $num / $denom ) * ( 1 / 3600 );
+
+			if ( $dir === 'S' || $dir === 'W' ) {
+				$res *= - 1; // make negative
+			}
+		}
+
+		// update the exif records.
+
+		if ( $res !== false ) { // using !== as $res could potentially be 0
+			$this->mFilteredExifData[$prop] = $res;
+			unset( $this->mFilteredExifData[$prop . 'Ref'] );
+		} else { // if invalid
+			unset( $this->mFilteredExifData[$prop] );
+			unset( $this->mFilteredExifData[$prop . 'Ref'] );
+		}
+	}
+
+	/**
+	 * Use FormatMetadata to create formatted values for display to user
+	 * (is this ever used?)
+	 *
+	 * @deprecated since 1.18
+	 */
+	function makeFormattedData( ) {
+		wfDeprecated( __METHOD__ );
+		$this->mFormattedExifData = FormatMetadata::getFormattedData(
+			$this->mFilteredExifData );
+	}
+	/**#@-*/
+
+	/**#@+
+	 * @return array
+	 */
+	/**
+	 * Get $this->mRawExifData
+	 */
+	function getData() {
+		return $this->mRawExifData;
+	}
+
+	/**
+	 * Get $this->mFilteredExifData
+	 */
+	function getFilteredData() {
+		return $this->mFilteredExifData;
+	}
+
+	/**
+	 * Get $this->mFormattedExifData
+	 *
+	 * This returns the data for display to user.
+	 * Its unclear if this is ever used.
+	 *
+	 * @deprecated since 1.18
+	 */
+	function getFormattedData() {
+		wfDeprecated( __METHOD__ );
+		if (!$this->mFormattedExifData) {
+			$this->makeFormattedData();
+		}
+		return $this->mFormattedExifData;
+	}
+	/**#@-*/
+
+	/**
+	 * The version of the output format
+	 *
+	 * Before the actual metadata information is saved in the database we
+	 * strip some of it since we don't want to save things like thumbnails
+	 * which usually accompany Exif data. This value gets saved in the
+	 * database along with the actual Exif data, and if the version in the
+	 * database doesn't equal the value returned by this function the Exif
+	 * data is regenerated.
+	 *
+	 * @return int
+	 */
+	public static function version() {
+		return 2; // We don't need no bloddy constants!
+	}
+
+	/**#@+
+	 * Validates if a tag value is of the type it should be according to the Exif spec
+	 *
+	 * @private
+	 *
+	 * @param $in Mixed: the input value to check
+	 * @return bool
+	 */
+	private function isByte( $in ) {
+		if ( !is_array( $in ) && sprintf('%d', $in) == $in && $in >= 0 && $in <= 255 ) {
+			$this->debug( $in, __FUNCTION__, true );
+			return true;
+		} else {
+			$this->debug( $in, __FUNCTION__, false );
+			return false;
+		}
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isASCII( $in ) {
+		if ( is_array( $in ) ) {
+			return false;
+		}
+
+		if ( preg_match( "/[^\x0a\x20-\x7e]/", $in ) ) {
+			$this->debug( $in, __FUNCTION__, 'found a character not in our whitelist' );
+			return false;
+		}
+
+		if ( preg_match( '/^\s*$/', $in ) ) {
+			$this->debug( $in, __FUNCTION__, 'input consisted solely of whitespace' );
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isShort( $in ) {
+		if ( !is_array( $in ) && sprintf('%d', $in) == $in && $in >= 0 && $in <= 65536 ) {
+			$this->debug( $in, __FUNCTION__, true );
+			return true;
+		} else {
+			$this->debug( $in, __FUNCTION__, false );
+			return false;
+		}
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isLong( $in ) {
+		if ( !is_array( $in ) && sprintf('%d', $in) == $in && $in >= 0 && $in <= 4294967296 ) {
+			$this->debug( $in, __FUNCTION__, true );
+			return true;
+		} else {
+			$this->debug( $in, __FUNCTION__, false );
+			return false;
+		}
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isRational( $in ) {
+		$m = array();
+		if ( !is_array( $in ) && @preg_match( '/^(\d+)\/(\d+[1-9]|[1-9]\d*)$/', $in, $m ) ) { # Avoid division by zero
+			return $this->isLong( $m[1] ) && $this->isLong( $m[2] );
+		} else {
+			$this->debug( $in, __FUNCTION__, 'fed a non-fraction value' );
+			return false;
+		}
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isUndefined( $in ) {
+		$this->debug( $in, __FUNCTION__, true );
+		return true;
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isSlong( $in ) {
+		if ( $this->isLong( abs( $in ) ) ) {
+			$this->debug( $in, __FUNCTION__, true );
+			return true;
+		} else {
+			$this->debug( $in, __FUNCTION__, false );
+			return false;
+		}
+	}
+
+	/**
+	 * @param $in
+	 * @return bool
+	 */
+	private function isSrational( $in ) {
+		$m = array();
+		if ( !is_array( $in ) && preg_match( '/^(-?\d+)\/(\d+[1-9]|[1-9]\d*)$/', $in, $m ) ) { # Avoid division by zero
+			return $this->isSlong( $m[0] ) && $this->isSlong( $m[1] );
+		} else {
+			$this->debug( $in, __FUNCTION__, 'fed a non-fraction value' );
+			return false;
+		}
+	}
+	/**#@-*/
+
+	/**
+	 * Validates if a tag has a legal value according to the Exif spec
+	 *
+	 * @private
+	 * @param $section String: section where tag is located.
+	 * @param $tag String: the tag to check.
+	 * @param $val Mixed: the value of the tag.
+	 * @param $recursive Boolean: true if called recursively for array types.
+	 * @return bool
+	 */
+	private function validate( $section, $tag, $val, $recursive = false ) {
+		$debug = "tag is '$tag'";
+		$etype = $this->mExifTags[$section][$tag];
+		$ecount = 1;
+		if( is_array( $etype ) ) {
+			list( $etype, $ecount ) = $etype;
+			if ( $recursive )
+				$ecount = 1; // checking individual elements
+		}
+		$count = count( $val );
+		if( $ecount != $count ) {
+			$this->debug( $val, __FUNCTION__, "Expected $ecount elements for $tag but got $count" );
+			return false;
+		}
+		if( $count > 1 ) {
+			foreach( $val as $v ) { 
+				if( !$this->validate( $section, $tag, $v, true ) ) {
+					return false; 
+				} 
+			}
+			return true;
+		}
+		// Does not work if not typecast
+		switch( (string)$etype ) {
+			case (string)Exif::BYTE:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isByte( $val );
+			case (string)Exif::ASCII:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isASCII( $val );
+			case (string)Exif::SHORT:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isShort( $val );
+			case (string)Exif::LONG:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isLong( $val );
+			case (string)Exif::RATIONAL:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isRational( $val );
+			case (string)Exif::UNDEFINED:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isUndefined( $val );
+			case (string)Exif::SLONG:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isSlong( $val );
+			case (string)Exif::SRATIONAL:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isSrational( $val );
+			case (string)Exif::SHORT.','.Exif::LONG:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return $this->isShort( $val ) || $this->isLong( $val );
+			case (string)Exif::IGNORE:
+				$this->debug( $val, __FUNCTION__, $debug );
+				return false;
+			default:
+				$this->debug( $val, __FUNCTION__, "The tag '$tag' is unknown" );
+				return false;
+		}
+	}
+
+	/**
+	 * Convenience function for debugging output
+	 *
+	 * @private
+	 *
+	 * @param $in Mixed:
+	 * @param $fname String:
+	 * @param $action Mixed: , default NULL.
+	 */
+	private function debug( $in, $fname, $action = null ) {
+		if ( !$this->log ) {
+			return;
+		}
+		$type = gettype( $in );
+		$class = ucfirst( __CLASS__ );
+		if ( $type === 'array' ) {
+			$in = print_r( $in, true );
+		}
+
+		if ( $action === true ) {
+			wfDebugLog( $this->log, "$class::$fname: accepted: '$in' (type: $type)\n");
+		} elseif ( $action === false ) {
+			wfDebugLog( $this->log, "$class::$fname: rejected: '$in' (type: $type)\n");
+		} elseif ( $action === null ) {
+			wfDebugLog( $this->log, "$class::$fname: input was: '$in' (type: $type)\n");
+		} else {
+			wfDebugLog( $this->log, "$class::$fname: $action (type: $type; content: '$in')\n");
+		}
+	}
+
+	/**
+	 * Convenience function for debugging output
+	 *
+	 * @private
+	 *
+	 * @param $fname String: the name of the function calling this function
+	 * @param $io Boolean: Specify whether we're beginning or ending
+	 */
+	private function debugFile( $fname, $io ) {
+		if ( !$this->log ) {
+			return;
+		}
+		$class = ucfirst( __CLASS__ );
+		if ( $io ) {
+			wfDebugLog( $this->log, "$class::$fname: begin processing: '{$this->basename}'\n" );
+		} else {
+			wfDebugLog( $this->log, "$class::$fname: end processing: '{$this->basename}'\n" );
+		}
+	}
+}
+
diff --git a/includes/media/ExifBitmap.php b/includes/media/ExifBitmap.php
new file mode 100644
index 00000000..05ce161b
--- /dev/null
+++ b/includes/media/ExifBitmap.php
@@ -0,0 +1,210 @@
+<?php
+/**
+ * @file
+ * @ingroup Media
+ */
+
+/**
+ * Stuff specific to JPEG and (built-in) TIFF handler.
+ * All metadata related, since both JPEG and TIFF support Exif.
+ *
+ * @ingroup Media
+ */
+class ExifBitmapHandler extends BitmapHandler {
+
+	const BROKEN_FILE = '-1'; // error extracting metadata
+	const OLD_BROKEN_FILE = '0'; // outdated error extracting metadata.
+
+	function convertMetadataVersion( $metadata, $version = 1 ) {
+		// basically flattens arrays.
+		$version = explode(';', $version, 2);
+		$version = intval($version[0]);
+		if ( $version < 1 || $version >= 2 ) {
+			return $metadata;
+		}
+
+		$avoidHtml = true;
+
+		if ( !is_array( $metadata ) ) {
+			$metadata = unserialize( $metadata );
+		}
+		if ( !isset( $metadata['MEDIAWIKI_EXIF_VERSION'] ) || $metadata['MEDIAWIKI_EXIF_VERSION'] != 2 ) {
+			return $metadata;
+		}
+
+		// Treat Software as a special case because in can contain
+		// an array of (SoftwareName, Version).
+		if (isset( $metadata['Software'] ) 
+			&& is_array( $metadata['Software'] ) 
+			&& is_array( $metadata['Software'][0])
+			&& isset( $metadata['Software'][0][0] )
+			&& isset( $metadata['Software'][0][1])
+		 ) {
+			$metadata['Software'] = $metadata['Software'][0][0] . ' (Version '
+				. $metadata['Software'][0][1] . ')';
+		}
+
+		// ContactInfo also has to be dealt with specially
+		if ( isset( $metadata['Contact'] ) ) {
+			$metadata['Contact'] =
+				FormatMetadata::collapseContactInfo(
+					$metadata['Contact'] );
+		}
+
+		foreach ( $metadata as &$val ) {
+			if ( is_array( $val ) ) {
+				$val = FormatMetadata::flattenArray( $val, 'ul', $avoidHtml );
+			}
+		}
+		$metadata['MEDIAWIKI_EXIF_VERSION'] = 1;
+		return $metadata;
+	}
+
+	function isMetadataValid( $image, $metadata ) {
+		global $wgShowEXIF;
+		if ( !$wgShowEXIF ) {
+			# Metadata disabled and so an empty field is expected
+			return self::METADATA_GOOD;
+		}
+		if ( $metadata === self::OLD_BROKEN_FILE ) {
+			# Old special value indicating that there is no EXIF data in the file.
+			# or that there was an error well extracting the metadata.
+			wfDebug( __METHOD__ . ": back-compat version\n");
+			return self::METADATA_COMPATIBLE;
+		}
+		if ( $metadata === self::BROKEN_FILE ) {
+			return self::METADATA_GOOD;
+		}
+		wfSuppressWarnings();
+		$exif = unserialize( $metadata );
+		wfRestoreWarnings();
+		if ( !isset( $exif['MEDIAWIKI_EXIF_VERSION'] ) ||
+			$exif['MEDIAWIKI_EXIF_VERSION'] != Exif::version() )
+		{
+			if ( isset( $exif['MEDIAWIKI_EXIF_VERSION'] ) &&
+				$exif['MEDIAWIKI_EXIF_VERSION'] == 1 )
+			{
+				//back-compatible but old
+				wfDebug( __METHOD__.": back-compat version\n" );
+				return self::METADATA_COMPATIBLE;
+			}
+			# Wrong (non-compatible) version
+			wfDebug( __METHOD__.": wrong version\n" );
+			return self::METADATA_BAD;
+		}
+		return self::METADATA_GOOD;
+	}
+
+	/**
+	 * @param $image File
+	 * @return array|bool
+	 */
+	function formatMetadata( $image ) {
+		$metadata = $image->getMetadata();
+		if ( $metadata === self::OLD_BROKEN_FILE ||
+			$metadata === self::BROKEN_FILE ||
+			$this->isMetadataValid( $image, $metadata ) === self::METADATA_BAD )
+		{
+			// So we don't try and display metadata from PagedTiffHandler
+			// for example when using InstantCommons.
+			return false;
+		}
+
+		$exif = unserialize( $metadata );
+		if ( !$exif ) {
+			return false;
+		}
+		unset( $exif['MEDIAWIKI_EXIF_VERSION'] );
+		if ( count( $exif ) == 0 ) {
+			return false;
+		}
+		return $this->formatMetadataHelper( $exif );
+	}
+
+	function getMetadataType( $image ) {
+		return 'exif';
+	}
+
+	/**
+	 * Wrapper for base classes ImageHandler::getImageSize() that checks for
+	 * rotation reported from metadata and swaps the sizes to match.
+	 *
+	 * @param File $image
+	 * @param string $path
+	 * @return array
+	 */
+	function getImageSize( $image, $path ) {
+		global $wgEnableAutoRotation;
+		$gis = parent::getImageSize( $image, $path );
+		
+		// Don't just call $image->getMetadata(); File::getPropsFromPath() calls us with a bogus object.
+		// This may mean we read EXIF data twice on initial upload.
+		if ( $wgEnableAutoRotation ) {
+			$meta = $this->getMetadata( $image, $path );
+			$rotation = $this->getRotationForExif( $meta );
+		} else {
+			$rotation = 0;
+		}
+
+		if ($rotation == 90 || $rotation == 270) {
+			$width = $gis[0];
+			$gis[0] = $gis[1];
+			$gis[1] = $width;
+		}
+		return $gis;
+	}
+
+	/**
+	 * On supporting image formats, try to read out the low-level orientation
+	 * of the file and return the angle that the file needs to be rotated to
+	 * be viewed.
+	 *
+	 * This information is only useful when manipulating the original file;
+	 * the width and height we normally work with is logical, and will match
+	 * any produced output views.
+	 *
+	 * @param $file File
+	 * @return int 0, 90, 180 or 270
+	 */
+	public function getRotation( $file ) {
+		global $wgEnableAutoRotation;
+		if ( !$wgEnableAutoRotation ) {
+			return 0;
+		}
+		
+		$data = $file->getMetadata();
+		return $this->getRotationForExif( $data );
+	}
+
+	/**
+	 * Given a chunk of serialized Exif metadata, return the orientation as
+	 * degrees of rotation.
+	 *
+	 * @param string $data
+	 * @return int 0, 90, 180 or 270
+	 * @fixme orientation can include flipping as well; see if this is an issue!
+	 */
+	protected function getRotationForExif( $data ) {
+		if ( !$data ) {
+			return 0;
+		}
+		wfSuppressWarnings();
+		$data = unserialize( $data );
+		wfRestoreWarnings();
+		if ( isset( $data['Orientation'] ) ) {
+			# See http://sylvana.net/jpegcrop/exif_orientation.html
+			switch ( $data['Orientation'] ) {
+				case 8:
+					return 90;
+				case 3:
+					return 180;
+				case 6:
+					return 270;
+				default:
+					return 0;
+			}
+		}
+		return 0;
+	}
+}
+
diff --git a/includes/media/FormatMetadata.php b/includes/media/FormatMetadata.php
new file mode 100644
index 00000000..47fc1adc
--- /dev/null
+++ b/includes/media/FormatMetadata.php
@@ -0,0 +1,1354 @@
+<?php
+/**
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ * http://www.gnu.org/copyleft/gpl.html
+ *
+ * @ingroup Media
+ * @author Ævar Arnfjörð Bjarmason <avarab@gmail.com>
+ * @copyright Copyright © 2005, Ævar Arnfjörð Bjarmason, 2009 Brent Garber, 2010 Brian Wolff
+ * @license http://www.gnu.org/copyleft/gpl.html GNU General Public License
+ * @see http://exif.org/Exif2-2.PDF The Exif 2.2 specification
+ * @file
+ */
+
+
+/**
+ * Format Image metadata values into a human readable form.
+ *
+ * Note lots of these messages use the prefix 'exif' even though
+ * they may not be exif properties. For example 'exif-ImageDescription'
+ * can be the Exif ImageDescription, or it could be the iptc-iim caption
+ * property, or it could be the xmp dc:description property. This
+ * is because these messages should be independent of how the data is
+ * stored, sine the user doesn't care if the description is stored in xmp,
+ * exif, etc only that its a description. (Additionally many of these properties
+ * are merged together following the MWG standard, such that for example,
+ * exif properties override XMP properties that mean the same thing if
+ * there is a conflict).
+ *
+ * It should perhaps use a prefix like 'metadata' instead, but there
+ * is already a large number of messages using the 'exif' prefix.
+ *
+ * @ingroup Media
+ */
+class FormatMetadata {
+
+	/**
+	 * Numbers given by Exif user agents are often magical, that is they
+	 * should be replaced by a detailed explanation depending on their
+	 * value which most of the time are plain integers. This function
+	 * formats Exif (and other metadata) values into human readable form.
+	 *
+	 * @param $tags Array: the Exif data to format ( as returned by
+	 *                    Exif::getFilteredData() or BitmapMetadataHandler )
+	 * @return array
+	 */
+	public static function getFormattedData( $tags ) {
+		global $wgLang;
+
+		$resolutionunit = !isset( $tags['ResolutionUnit'] ) || $tags['ResolutionUnit'] == 2 ? 2 : 3;
+		unset( $tags['ResolutionUnit'] );
+
+		foreach ( $tags as $tag => &$vals ) {
+
+			// This seems ugly to wrap non-array's in an array just to unwrap again,
+			// especially when most of the time it is not an array
+			if ( !is_array( $tags[$tag] ) ) {
+				$vals = Array( $vals );
+			}
+
+			// _type is a special value to say what array type
+			if ( isset( $tags[$tag]['_type'] ) ) {
+				$type = $tags[$tag]['_type'];
+				unset( $vals['_type'] );
+			} else {
+				$type = 'ul'; // default unordered list.
+			}
+
+			//This is done differently as the tag is an array.
+			if ($tag == 'GPSTimeStamp' && count($vals) === 3) {
+				//hour min sec array
+
+				$h = explode('/', $vals[0]);
+				$m = explode('/', $vals[1]);
+				$s = explode('/', $vals[2]);
+
+				// this should already be validated
+				// when loaded from file, but it could
+				// come from a foreign repo, so be
+				// paranoid.
+				if ( !isset($h[1])
+					|| !isset($m[1])
+					|| !isset($s[1])
+					|| $h[1] == 0
+					|| $m[1] == 0
+					|| $s[1] == 0
+				) {
+					continue;
+				}
+				$tags[$tag] = intval( $h[0] / $h[1] )
+					. ':' . str_pad( intval( $m[0] / $m[1] ), 2, '0', STR_PAD_LEFT )
+					. ':' . str_pad( intval( $s[0] / $s[1] ), 2, '0', STR_PAD_LEFT );
+
+				$time = wfTimestamp( TS_MW, '1971:01:01 ' . $tags[$tag] );
+				// the 1971:01:01 is just a placeholder, and not shown to user.
+				if ( $time && intval( $time ) > 0 ) {
+					$tags[$tag] = $wgLang->time( $time );
+				}
+				continue;
+			}
+
+			// The contact info is a multi-valued field
+			// instead of the other props which are single
+			// valued (mostly) so handle as a special case.
+			if ( $tag === 'Contact' ) {
+				$vals = self::collapseContactInfo( $vals );
+				continue;
+			}
+
+			foreach ( $vals as &$val ) {
+
+				switch( $tag ) {
+				case 'Compression':
+					switch( $val ) {
+					case 1: case 2: case 3: case 4:
+					case 5: case 6: case 7: case 8:
+					case 32773: case 32946: case 34712:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'PhotometricInterpretation':
+					switch( $val ) {
+					case 2: case 6:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'Orientation':
+					switch( $val ) {
+					case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'PlanarConfiguration':
+					switch( $val ) {
+					case 1: case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				// TODO: YCbCrSubSampling
+				case 'YCbCrPositioning':
+					switch ( $val ) {
+					case 1:
+					case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'XResolution':
+				case 'YResolution':
+					switch( $resolutionunit ) {
+						case 2:
+							$val = self::msg( 'XYResolution', 'i', self::formatNum( $val ) );
+							break;
+						case 3:
+							$val = self::msg( 'XYResolution', 'c', self::formatNum( $val ) );
+							break;
+						default:
+							/* If not recognized, display as is. */
+							break;
+					}
+					break;
+
+				// TODO: YCbCrCoefficients  #p27 (see annex E)
+				case 'ExifVersion': case 'FlashpixVersion':
+					$val = "$val" / 100;
+					break;
+
+				case 'ColorSpace':
+					switch( $val ) {
+					case 1: case 65535:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'ComponentsConfiguration':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3: case 4: case 5: case 6:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'DateTime':
+				case 'DateTimeOriginal':
+				case 'DateTimeDigitized':
+				case 'DateTimeReleased':
+				case 'DateTimeExpires':
+				case 'GPSDateStamp':
+				case 'dc-date':
+				case 'DateTimeMetadata':
+					if ( $val == '0000:00:00 00:00:00' || $val == '    :  :     :  :  ' ) {
+						$val = wfMsg( 'exif-unknowndate' );
+					} elseif ( preg_match( '/^(?:\d{4}):(?:\d\d):(?:\d\d) (?:\d\d):(?:\d\d):(?:\d\d)$/D', $val ) ) {
+						$time = wfTimestamp( TS_MW, $val );
+						if ( $time && intval( $time ) > 0 ) {
+							$val = $wgLang->timeanddate( $time );
+						}
+					} elseif ( preg_match( '/^(?:\d{4}):(?:\d\d):(?:\d\d)$/D', $val ) ) {
+						// If only the date but not the time is filled in.
+						$time = wfTimestamp( TS_MW, substr( $val, 0, 4 )
+							. substr( $val, 5, 2 )
+							. substr( $val, 8, 2 )
+							. '000000' );
+						if ( $time && intval( $time ) > 0 ) {
+							$val = $wgLang->date( $time );
+						}
+					}
+					// else it will just output $val without formatting it.
+					break;
+
+				case 'ExposureProgram':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 8:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'SubjectDistance':
+					$val = self::msg( $tag, '', self::formatNum( $val ) );
+					break;
+
+				case 'MeteringMode':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: case 255:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'LightSource':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3: case 4: case 9: case 10: case 11:
+					case 12: case 13: case 14: case 15: case 17: case 18: case 19: case 20:
+					case 21: case 22: case 23: case 24: case 255:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'Flash':
+					$flashDecode = array(
+						'fired'    => $val & bindec( '00000001' ),
+						'return'   => ( $val & bindec( '00000110' ) ) >> 1,
+						'mode'     => ( $val & bindec( '00011000' ) ) >> 3,
+						'function' => ( $val & bindec( '00100000' ) ) >> 5,
+						'redeye'   => ( $val & bindec( '01000000' ) ) >> 6,
+//						'reserved' => ($val & bindec( '10000000' )) >> 7,
+					);
+	
+					# We do not need to handle unknown values since all are used.
+					foreach ( $flashDecode as $subTag => $subValue ) {
+						# We do not need any message for zeroed values.
+						if ( $subTag != 'fired' && $subValue == 0 ) {
+							continue;
+						}
+						$fullTag = $tag . '-' . $subTag ;
+						$flashMsgs[] = self::msg( $fullTag, $subValue );
+					}
+					$val = $wgLang->commaList( $flashMsgs );
+					break;
+
+				case 'FocalPlaneResolutionUnit':
+					switch( $val ) {
+					case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'SensingMethod':
+					switch( $val ) {
+					case 1: case 2: case 3: case 4: case 5: case 7: case 8:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'FileSource':
+					switch( $val ) {
+					case 3:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'SceneType':
+					switch( $val ) {
+					case 1:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'CustomRendered':
+					switch( $val ) {
+					case 0: case 1:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'ExposureMode':
+					switch( $val ) {
+					case 0: case 1: case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'WhiteBalance':
+					switch( $val ) {
+					case 0: case 1:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'SceneCaptureType':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GainControl':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3: case 4:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'Contrast':
+					switch( $val ) {
+					case 0: case 1: case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'Saturation':
+					switch( $val ) {
+					case 0: case 1: case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'Sharpness':
+					switch( $val ) {
+					case 0: case 1: case 2:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'SubjectDistanceRange':
+					switch( $val ) {
+					case 0: case 1: case 2: case 3:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				//The GPS...Ref values are kept for compatibility, probably won't be reached.
+				case 'GPSLatitudeRef':
+				case 'GPSDestLatitudeRef':
+					switch( $val ) {
+					case 'N': case 'S':
+						$val = self::msg( 'GPSLatitude', $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSLongitudeRef':
+				case 'GPSDestLongitudeRef':
+					switch( $val ) {
+					case 'E': case 'W':
+						$val = self::msg( 'GPSLongitude', $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSAltitude':
+					if ( $val < 0 ) {
+						$val = self::msg( 'GPSAltitude', 'below-sealevel', self::formatNum( -$val, 3 ) );
+					} else {
+						$val = self::msg( 'GPSAltitude', 'above-sealevel', self::formatNum( $val, 3 ) );
+					}
+					break;
+
+				case 'GPSStatus':
+					switch( $val ) {
+					case 'A': case 'V':
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSMeasureMode':
+					switch( $val ) {
+					case 2: case 3:
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+
+				case 'GPSTrackRef':
+				case 'GPSImgDirectionRef':
+				case 'GPSDestBearingRef':
+					switch( $val ) {
+					case 'T': case 'M':
+						$val = self::msg( 'GPSDirection', $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSLatitude':
+				case 'GPSDestLatitude':
+					$val = self::formatCoords( $val, 'latitude' );
+					break;
+				case 'GPSLongitude':
+				case 'GPSDestLongitude':
+					$val = self::formatCoords( $val, 'longitude' );
+					break;
+
+				case 'GPSSpeedRef':
+					switch( $val ) {
+					case 'K': case 'M': case 'N':
+						$val = self::msg( 'GPSSpeed', $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSDestDistanceRef':
+					switch( $val ) {
+					case 'K': case 'M': case 'N':
+						$val = self::msg( 'GPSDestDistance', $val );
+						break;
+					default:
+						/* If not recognized, display as is. */
+						break;
+					}
+					break;
+
+				case 'GPSDOP':
+					// See http://en.wikipedia.org/wiki/Dilution_of_precision_(GPS)
+					if ( $val <= 2 ) {
+						$val = self::msg( $tag, 'excellent', self::formatNum( $val ) );
+					} elseif ( $val <= 5 ) {
+						$val = self::msg( $tag, 'good', self::formatNum( $val ) );
+					} elseif ( $val <= 10 ) {
+						$val = self::msg( $tag, 'moderate', self::formatNum( $val ) );
+					} elseif ( $val <= 20 ) {
+						$val = self::msg( $tag, 'fair', self::formatNum( $val ) );
+					} else {
+						$val = self::msg( $tag, 'poor', self::formatNum( $val ) );
+					}
+					break;
+
+				// This is not in the Exif standard, just a special
+				// case for our purposes which enables wikis to wikify
+				// the make, model and software name to link to their articles.
+				case 'Make':
+				case 'Model':
+					$val = self::msg( $tag, '', $val );
+					break;
+
+				case 'Software':
+					if ( is_array( $val ) ) {
+						//if its a software, version array.
+						$val = wfMsg( 'exif-software-version-value', $val[0], $val[1] );
+					} else {
+						$val = self::msg( $tag, '', $val );
+					}
+					break;
+
+				case 'ExposureTime':
+					// Show the pretty fraction as well as decimal version
+					$val = wfMsg( 'exif-exposuretime-format',
+						self::formatFraction( $val ), self::formatNum( $val ) );
+					break;
+				case 'ISOSpeedRatings':
+					// If its = 65535 that means its at the
+					// limit of the size of Exif::short and
+					// is really higher.
+					if ( $val == '65535' ) {
+						$val = self::msg( $tag, 'overflow' );
+					} else {
+						$val = self::formatNum( $val );
+					}
+					break;
+				case 'FNumber':
+					$val = wfMsg( 'exif-fnumber-format',
+						self::formatNum( $val ) );
+					break;
+
+				case 'FocalLength': case 'FocalLengthIn35mmFilm':
+					$val = wfMsg( 'exif-focallength-format',
+						self::formatNum( $val ) );
+					break;
+
+				case 'MaxApertureValue':
+					if ( strpos( $val, '/' ) !== false ) {
+						// need to expand this earlier to calculate fNumber
+						list($n, $d) = explode('/', $val);
+						if ( is_numeric( $n ) && is_numeric( $d ) ) {
+							$val = $n / $d;
+						}
+					}
+					if ( is_numeric( $val ) ) {
+						$fNumber = pow( 2, $val / 2 );
+						if ( $fNumber !== false ) {
+							$val = wfMsg( 'exif-maxaperturevalue-value',
+								self::formatNum( $val ),
+								self::formatNum( $fNumber, 2 )
+							);
+						}
+					}
+					break;
+					
+				case 'iimCategory':
+					switch( strtolower( $val ) ) {
+						// See pg 29 of IPTC photo
+						// metadata standard.
+						case 'ace': case 'clj':
+						case 'dis': case 'fin':
+						case 'edu': case 'evn':
+						case 'hth': case 'hum':
+						case 'lab': case 'lif':
+						case 'pol': case 'rel':
+						case 'sci': case 'soi':
+						case 'spo': case 'war':
+						case 'wea':
+							$val = self::msg(
+								'iimcategory',
+								$val
+							);
+					}
+					break;
+				case 'SubjectNewsCode':
+					// Essentially like iimCategory.
+					// 8 (numeric) digit hierarchical
+					// classification. We decode the
+					// first 2 digits, which provide
+					// a broad category.
+					$val = self::convertNewsCode( $val );
+					break;
+				case 'Urgency':
+					// 1-8 with 1 being highest, 5 normal
+					// 0 is reserved, and 9 is 'user-defined'.
+					$urgency = '';
+					if ( $val == 0 || $val == 9 ) {
+						$urgency = 'other';
+					} elseif ( $val < 5 && $val > 1 ) {
+						$urgency = 'high';
+					} elseif ( $val == 5 ) {
+						$urgency = 'normal';
+					} elseif ( $val <= 8 && $val > 5) {
+						$urgency = 'low';
+					}
+
+					if ( $urgency !== '' ) {
+						$val = self::msg( 'urgency',
+							$urgency, $val
+						);
+					}
+					break;
+
+				// Things that have a unit of pixels.
+				case 'OriginalImageHeight':
+				case 'OriginalImageWidth':
+				case 'PixelXDimension':
+				case 'PixelYDimension':
+				case 'ImageWidth':
+				case 'ImageLength':
+					$val = self::formatNum( $val ) . ' ' . wfMsg( 'unit-pixel' );
+					break;
+
+				// Do not transform fields with pure text.
+				// For some languages the formatNum()
+				// conversion results to wrong output like
+				// foo,bar@example,com or foo٫bar@example٫com.
+				// Also some 'numeric' things like Scene codes
+				// are included here as we really don't want
+				// commas inserted.
+				case 'ImageDescription':
+				case 'Artist':
+				case 'Copyright':
+				case 'RelatedSoundFile':
+				case 'ImageUniqueID':
+				case 'SpectralSensitivity':
+				case 'GPSSatellites':
+				case 'GPSVersionID':
+				case 'GPSMapDatum':
+				case 'Keywords':
+				case 'WorldRegionDest':
+				case 'CountryDest':
+				case 'CountryCodeDest':
+				case 'ProvinceOrStateDest':
+				case 'CityDest':
+				case 'SublocationDest':
+				case 'WorldRegionCreated':
+				case 'CountryCreated':
+				case 'CountryCodeCreated':
+				case 'ProvinceOrStateCreated':
+				case 'CityCreated':
+				case 'SublocationCreated':
+				case 'ObjectName':
+				case 'SpecialInstructions':
+				case 'Headline':
+				case 'Credit':
+				case 'Source':
+				case 'EditStatus':
+				case 'FixtureIdentifier':
+				case 'LocationDest':
+				case 'LocationDestCode':
+				case 'Writer':
+				case 'JPEGFileComment':
+				case 'iimSupplementalCategory':
+				case 'OriginalTransmissionRef':
+				case 'Identifier':
+				case 'dc-contributor':
+				case 'dc-coverage':
+				case 'dc-publisher':
+				case 'dc-relation':
+				case 'dc-rights':
+				case 'dc-source':
+				case 'dc-type':
+				case 'Lens':
+				case 'SerialNumber':
+				case 'CameraOwnerName':
+				case 'Label':
+				case 'Nickname':
+				case 'RightsCertificate':
+				case 'CopyrightOwner':
+				case 'UsageTerms':
+				case 'WebStatement':
+				case 'OriginalDocumentID':
+				case 'LicenseUrl':
+				case 'MorePermissionsUrl':
+				case 'AttributionUrl':
+				case 'PreferredAttributionName':
+				case 'PNGFileComment':
+				case 'Disclaimer':
+				case 'ContentWarning':
+				case 'GIFFileComment':
+				case 'SceneCode':
+				case 'IntellectualGenre':
+				case 'Event':
+				case 'OrginisationInImage':
+				case 'PersonInImage':
+
+					$val = htmlspecialchars( $val );
+					break;
+
+				case 'ObjectCycle':
+					switch ( $val ) {
+					case 'a': case 'p': case 'b':
+						$val = self::msg( $tag, $val );
+						break;
+					default:
+						$val = htmlspecialchars( $val );
+						break;
+					}
+					break;
+				case 'Copyrighted':
+					switch( $val ) {
+					case 'True': case 'False':
+						$val = self::msg( $tag, $val );
+						break;
+					}
+					break;
+				case 'Rating':
+					if ( $val == '-1' ) {
+						$val = self::msg( $tag, 'rejected' );
+					} else {
+						$val = self::formatNum( $val );
+					}
+					break;
+
+				case 'LanguageCode':
+					$lang = $wgLang->getLanguageName( strtolower( $val ) );
+					if ($lang) {
+						$val = htmlspecialchars( $lang );
+					} else {
+						$val = htmlspecialchars( $val );
+					}
+					break;
+
+				default:
+					$val = self::formatNum( $val );
+					break;
+				}
+			}
+			// End formatting values, start flattening arrays.
+			$vals = self::flattenArray( $vals, $type );
+
+		}
+		return $tags;
+	}
+
+	/**
+	* A function to collapse multivalued tags into a single value.
+	* This turns an array of (for example) authors into a bulleted list.
+	*
+	* This is public on the basis it might be useful outside of this class.
+	* 
+	* @param $vals Array array of values
+	* @param $type String Type of array (either lang, ul, ol).
+	* lang = language assoc array with keys being the lang code
+	* ul = unordered list, ol = ordered list
+	* type can also come from the '_type' member of $vals.
+	* @param $noHtml Boolean If to avoid returning anything resembling
+	* html. (Ugly hack for backwards compatibility with old mediawiki). 
+	* @return String single value (in wiki-syntax).
+	*/
+	public static function flattenArray( $vals, $type = 'ul', $noHtml = false ) {
+		if ( isset( $vals['_type'] ) ) {
+			$type = $vals['_type'];
+			unset( $vals['_type'] );
+		}
+
+		if ( !is_array( $vals ) ) {
+			 return $vals; // do nothing if not an array;
+		}
+		elseif ( count( $vals ) === 1 && $type !== 'lang' ) {
+			return $vals[0];
+		}
+		elseif ( count( $vals ) === 0 ) {
+			wfDebug( __METHOD__ . ' metadata array with 0 elements!' );
+			return ""; // paranoia. This should never happen
+		}
+		/* @todo FIXME: This should hide some of the list entries if there are
+		 * say more than four. Especially if a field is translated into 20
+		 * languages, we don't want to show them all by default
+		 */
+		else {
+			global $wgContLang;
+			switch( $type ) {
+			case 'lang':
+				// Display default, followed by ContLang,
+				// followed by the rest in no particular
+				// order.
+
+				// Todo: hide some items if really long list.
+
+				$content = '';
+
+				$cLang = $wgContLang->getCode();
+				$defaultItem = false;
+				$defaultLang = false;
+
+				// If default is set, save it for later,
+				// as we don't know if it's equal to
+				// one of the lang codes. (In xmp
+				// you specify the language for a 
+				// default property by having both
+				// a default prop, and one in the language
+				// that are identical)
+				if ( isset( $vals['x-default'] ) ) {
+					$defaultItem = $vals['x-default'];
+					unset( $vals['x-default'] );
+				}
+				// Do contentLanguage.
+				if ( isset( $vals[$cLang] ) ) {
+					$isDefault = false;
+					if ( $vals[$cLang] === $defaultItem ) {
+						$defaultItem = false;
+						$isDefault = true;
+					}
+					$content .= self::langItem(
+						$vals[$cLang], $cLang,
+						 $isDefault, $noHtml );
+
+					unset( $vals[$cLang] );
+				}
+
+				// Now do the rest.
+				foreach ( $vals as $lang => $item ) {
+					if ( $item === $defaultItem ) {
+						$defaultLang = $lang;
+						continue;
+					}
+					$content .= self::langItem( $item,
+						$lang, false, $noHtml );
+				}
+				if ( $defaultItem !== false ) {
+					$content = self::langItem( $defaultItem,
+						$defaultLang, true, $noHtml )
+						 . $content;
+				}
+				if ( $noHtml ) {
+					return $content;
+				}
+				return '<ul class="metadata-langlist">' .
+					$content .
+					'</ul>';
+			case 'ol':
+				if ( $noHtml ) {
+					return "\n#" . implode( "\n#", $vals );
+				}
+				return "<ol><li>" . implode( "</li>\n<li>", $vals ) . '</li></ol>';
+			case 'ul':
+			default:
+				if ( $noHtml ) {
+					return "\n*" . implode( "\n*", $vals );
+				}
+				return "<ul><li>" . implode( "</li>\n<li>", $vals ) . '</li></ul>';
+			}
+		}
+	}
+
+	/** Helper function for creating lists of translations.
+	 *
+	 * @param $value String value (this is not escaped)
+	 * @param $lang String lang code of item or false
+	 * @param $default Boolean if it is default value.
+	 * @param $noHtml Boolean If to avoid html (for back-compat)
+	 * @return language item (Note: despite how this looks,
+	 * 	this is treated as wikitext not html).
+	 */
+	private static function langItem( $value, $lang, $default = false, $noHtml = false ) {
+		global $wgContLang;
+		if ( $lang === false && $default === false) {
+			throw new MWException('$lang and $default cannot both '
+				. 'be false.');
+		}
+
+		if ( $noHtml ) {
+			$wrappedValue = $value;
+		} else {
+			$wrappedValue = '<span class="mw-metadata-lang-value">'
+				. $value . '</span>';
+		}
+
+		if ( $lang === false ) {
+			if ( $noHtml ) {
+				return wfMsg( 'metadata-langitem-default',
+					$wrappedValue ) . "\n\n";
+			} /* else */
+			return '<li class="mw-metadata-lang-default">'
+				. wfMsg( 'metadata-langitem-default',
+					$wrappedValue )
+				. "</li>\n";
+		}
+
+		$lowLang = strtolower( $lang );
+		$langName = $wgContLang->getLanguageName( $lowLang );
+		if ( $langName === '' ) {
+			//try just the base language name. (aka en-US -> en ).
+			list( $langPrefix ) = explode( '-', $lowLang, 2 );
+			$langName = $wgContLang->getLanguageName( $langPrefix );
+			if ( $langName === '' ) {
+				// give up.
+				$langName = $lang;
+			}
+		}
+		// else we have a language specified
+
+		if ( $noHtml ) {
+			return '*' . wfMsg( 'metadata-langitem',
+				$wrappedValue, $langName, $lang );
+		} /* else: */
+
+		$item = '<li class="mw-metadata-lang-code-'
+			. $lang;
+		if ( $default ) {
+			$item .= ' mw-metadata-lang-default';
+		}
+		$item .= '" lang="' . $lang . '">';
+		$item .= wfMsg( 'metadata-langitem',
+			$wrappedValue, $langName, $lang );
+		$item .= "</li>\n";
+		return $item;
+	}
+
+	/**
+	 * Convenience function for getFormattedData()
+	 *
+	 * @private
+	 *
+	 * @param $tag String: the tag name to pass on
+	 * @param $val String: the value of the tag
+	 * @param $arg String: an argument to pass ($1)
+	 * @param $arg2 String: a 2nd argument to pass ($2)
+	 * @return string A wfMsg of "exif-$tag-$val" in lower case
+	 */
+	static function msg( $tag, $val, $arg = null, $arg2 = null ) {
+		global $wgContLang;
+
+		if ($val === '')
+			$val = 'value';
+		return wfMsg( $wgContLang->lc( "exif-$tag-$val" ), $arg, $arg2 );
+	}
+
+	/**
+	 * Format a number, convert numbers from fractions into floating point
+	 * numbers, joins arrays of numbers with commas.
+	 *
+	 * @private
+	 *
+	 * @param $num Mixed: the value to format
+	 * @param $round digits to round to or false.
+	 * @return mixed A floating point number or whatever we were fed
+	 */
+	static function formatNum( $num, $round = false ) {
+		global $wgLang;
+		$m = array();
+		if( is_array($num) ) {
+			$out = array();
+			foreach( $num as $number ) {
+				$out[] = self::formatNum($number);
+			}
+			return $wgLang->commaList( $out );
+		}
+		if ( preg_match( '/^(-?\d+)\/(\d+)$/', $num, $m ) ) {
+			if ( $m[2] != 0 ) {
+				$newNum = $m[1] / $m[2];
+				if ( $round !== false ) {
+					$newNum = round( $newNum, $round );
+				}
+			} else {
+				$newNum = $num;
+			}
+
+			return $wgLang->formatNum( $newNum );
+		} else {
+			if ( is_numeric( $num ) && $round !== false ) {
+				$num = round( $num, $round );
+			}
+			return $wgLang->formatNum( $num );
+		}
+	}
+
+	/**
+	 * Format a rational number, reducing fractions
+	 *
+	 * @private
+	 *
+	 * @param $num Mixed: the value to format
+	 * @return mixed A floating point number or whatever we were fed
+	 */
+	static function formatFraction( $num ) {
+		$m = array();
+		if ( preg_match( '/^(-?\d+)\/(\d+)$/', $num, $m ) ) {
+			$numerator = intval( $m[1] );
+			$denominator = intval( $m[2] );
+			$gcd = self::gcd( abs( $numerator ), $denominator );
+			if( $gcd != 0 ) {
+				// 0 shouldn't happen! ;)
+				return self::formatNum( $numerator / $gcd ) . '/' . self::formatNum( $denominator / $gcd );
+			}
+		}
+		return self::formatNum( $num );
+	}
+
+	/**
+	 * Calculate the greatest common divisor of two integers.
+	 *
+	 * @param $a Integer: Numerator
+	 * @param $b Integer: Denominator
+	 * @return int
+	 * @private
+	 */
+	static function gcd( $a, $b ) {
+		/*
+			// http://en.wikipedia.org/wiki/Euclidean_algorithm
+			// Recursive form would be:
+			if( $b == 0 )
+				return $a;
+			else
+				return gcd( $b, $a % $b );
+		*/
+		while( $b != 0 ) {
+			$remainder = $a % $b;
+
+			// tail recursion...
+			$a = $b;
+			$b = $remainder;
+		}
+		return $a;
+	}
+
+	/** Fetch the human readable version of a news code.
+	 * A news code is an 8 digit code. The first two 
+	 * digits are a general classification, so we just
+	 * translate that.
+	 *
+	 * Note, leading 0's are significant, so this is
+	 * a string, not an int.
+	 *
+	 * @param $val String: The 8 digit news code.
+	 * @return The human readable form
+	 */
+	static private function convertNewsCode( $val ) {
+		if ( !preg_match( '/^\d{8}$/D', $val ) ) {
+			// Not a valid news code.
+			return $val;
+		}
+		$cat = '';
+		switch( substr( $val , 0, 2 ) ) {
+			case '01':
+				$cat = 'ace';
+				break;
+			case '02':
+				$cat = 'clj';
+				break;
+			case '03':
+				$cat = 'dis';
+				break;
+			case '04':
+				$cat = 'fin';
+				break;
+			case '05':
+				$cat = 'edu';
+				break;
+			case '06':
+				$cat = 'evn';
+				break;
+			case '07':
+				$cat = 'hth';
+				break;
+			case '08':
+				$cat = 'hum';
+				break;
+			case '09':
+				$cat = 'lab';
+				break;
+			case '10':
+				$cat = 'lif';
+				break;
+			case '11':
+				$cat = 'pol';
+				break;
+			case '12':
+				$cat = 'rel';
+				break;
+			case '13':
+				$cat = 'sci';
+				break;
+			case '14':
+				$cat = 'soi';
+				break;
+			case '15':
+				$cat = 'spo';
+				break;
+			case '16':
+				$cat = 'war';
+				break;
+			case '17':
+				$cat = 'wea';
+				break;
+		}
+		if ( $cat !== '' ) {
+			$catMsg = self::msg( 'iimcategory', $cat );
+			$val = self::msg( 'subjectnewscode', '', $val, $catMsg );
+		}
+		return $val;
+	}
+
+	/**
+	 * Format a coordinate value, convert numbers from floating point
+	 * into degree minute second representation.
+	 *
+	 * @param $coords Array: degrees, minutes and seconds
+	 * @param $type String: latitude or longitude (for if its a NWS or E)
+	 * @return mixed A floating point number or whatever we were fed
+	 */
+	static function formatCoords( $coord, $type ) {
+		$ref = '';
+		if ( $coord < 0 ) {
+			$nCoord = -$coord;
+			if ( $type === 'latitude' ) {
+				$ref = 'S';
+			}
+			elseif ( $type === 'longitude' ) {
+				$ref = 'W';
+			}
+		}
+		else {
+			$nCoord = $coord;
+			if ( $type === 'latitude' ) {
+				$ref = 'N';
+			}
+			elseif ( $type === 'longitude' ) {
+				$ref = 'E';
+			}
+		}
+
+		$deg = floor( $nCoord );
+		$min = floor( ( $nCoord - $deg ) * 60.0 );
+		$sec = round( ( ( $nCoord - $deg ) - $min / 60 ) * 3600, 2 );
+
+		$deg = self::formatNum( $deg );
+		$min = self::formatNum( $min );
+		$sec = self::formatNum( $sec );
+
+		return wfMsg( 'exif-coordinate-format', $deg, $min, $sec, $ref, $coord );
+	}
+
+	/**
+	 * Format the contact info field into a single value.
+	 *
+	 * @param $vals Array array with fields of the ContactInfo
+	 *    struct defined in the IPTC4XMP spec. Or potentially
+	 *    an array with one element that is a free form text
+	 *    value from the older iptc iim 1:118 prop.
+	 *
+	 * This function might be called from
+	 * JpegHandler::convertMetadataVersion which is why it is
+	 * public.
+	 *
+	 * @return String of html-ish looking wikitext
+	 */
+	public static function collapseContactInfo( $vals ) {
+		if( ! ( isset( $vals['CiAdrExtadr'] )
+			|| isset( $vals['CiAdrCity'] )
+			|| isset( $vals['CiAdrCtry'] )
+			|| isset( $vals['CiEmailWork'] )
+			|| isset( $vals['CiTelWork'] )
+			|| isset( $vals['CiAdrPcode'] )
+			|| isset( $vals['CiAdrRegion'] )
+			|| isset( $vals['CiUrlWork'] )
+		) ) {
+			// We don't have any sub-properties
+			// This could happen if its using old
+			// iptc that just had this as a free-form
+			// text value.
+			// Note: We run this through htmlspecialchars
+			// partially to be consistent, and partially
+			// because people often insert >, etc into
+			// the metadata which should not be interpreted
+			// but we still want to auto-link urls.
+			foreach( $vals as &$val ) {
+				$val = htmlspecialchars( $val );
+			}
+			return self::flattenArray( $vals );
+		} else {
+			// We have a real ContactInfo field.
+			// Its unclear if all these fields have to be
+			// set, so assume they do not.
+			$url = $tel = $street = $city = $country = '';
+			$email = $postal = $region = '';
+
+			// Also note, some of the class names this uses
+			// are similar to those used by hCard. This is
+			// mostly because they're sensible names. This
+			// does not (and does not attempt to) output
+			// stuff in the hCard microformat. However it
+			// might output in the adr microformat.
+
+			if ( isset( $vals['CiAdrExtadr'] ) ) {
+				// Todo: This can potentially be multi-line.
+				// Need to check how that works in XMP.
+				$street = '<span class="extended-address">'
+					. htmlspecialchars( 
+						$vals['CiAdrExtadr'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiAdrCity'] ) ) {
+				$city = '<span class="locality">'
+					. htmlspecialchars( $vals['CiAdrCity'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiAdrCtry'] ) ) {
+				$country = '<span class="country-name">'
+					. htmlspecialchars( $vals['CiAdrCtry'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiEmailWork'] ) ) {
+				$emails = array();
+				// Have to split multiple emails at commas/new lines.
+				$splitEmails = explode( "\n", $vals['CiEmailWork'] );
+				foreach ( $splitEmails as $e1 ) {
+					// Also split on comma
+					foreach ( explode( ',', $e1 ) as $e2 ) {
+						$finalEmail = trim( $e2 );
+						if ( $finalEmail == ',' || $finalEmail == '' ) {
+							continue;
+						}
+						if ( strpos( $finalEmail, '<' ) !== false ) {
+							// Don't do fancy formatting to
+							// "My name" <foo@bar.com> style stuff
+							$emails[] = $finalEmail;
+						} else {
+							$emails[] = '[mailto:'
+							. $finalEmail
+							. ' <span class="email">'
+							. $finalEmail
+							. '</span>]';
+						}
+					}
+				}
+				$email = implode( ', ', $emails );
+			}
+			if ( isset( $vals['CiTelWork'] ) ) {
+				$tel = '<span class="tel">'
+					. htmlspecialchars( $vals['CiTelWork'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiAdrPcode'] ) ) {
+				$postal = '<span class="postal-code">'
+					. htmlspecialchars( 
+						$vals['CiAdrPcode'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiAdrRegion'] ) ) {
+				// Note this is province/state.
+				$region = '<span class="region">'
+					. htmlspecialchars(
+						$vals['CiAdrRegion'] )
+					. '</span>';
+			}
+			if ( isset( $vals['CiUrlWork'] ) ) {
+				$url = '<span class="url">'
+					. htmlspecialchars( $vals['CiUrlWork'] )
+					. '</span>';
+			}
+			return wfMsg( 'exif-contact-value', $email, $url,
+				$street, $city, $region, $postal, $country,
+				$tel );
+		}
+	}
+}
+
+/** For compatability with old FormatExif class
+ * which some extensions use.
+ *
+ * @deprecated since 1.18
+ *
+**/
+class FormatExif {
+	var $meta;
+	function FormatExif ( $meta ) {
+		wfDeprecated(__METHOD__);
+		$this->meta = $meta;
+	}
+
+	function getFormattedData ( ) {
+		return FormatMetadata::getFormattedData( $this->meta );
+	}
+}
diff --git a/includes/media/GIF.php b/includes/media/GIF.php
index c4ede331..325ceb9a 100644
--- a/includes/media/GIF.php
+++ b/includes/media/GIF.php
@@ -12,56 +12,104 @@
  * @ingroup Media
  */
 class GIFHandler extends BitmapHandler {
+
+	const BROKEN_FILE = '0'; // value to store in img_metadata if error extracting metadata.
 	
 	function getMetadata( $image, $filename ) {
-		if ( !isset( $image->parsedGIFMetadata ) ) {
-			try {
-				$image->parsedGIFMetadata = GIFMetadataExtractor::getMetadata( $filename );
-			} catch( Exception $e ) {
-				// Broken file?
-				wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
-				return '0';
-			}
+		try {
+			$parsedGIFMetadata = BitmapMetadataHandler::GIF( $filename );
+		} catch( Exception $e ) {
+			// Broken file?
+			wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
+			return self::BROKEN_FILE;
 		}
 
-		return serialize( $image->parsedGIFMetadata );
-
+		return serialize($parsedGIFMetadata);
 	}
-	
+
+	/**
+	 * @param $image File
+	 * @return array|bool
+	 */
 	function formatMetadata( $image ) {
-		return false;
+		$meta = $image->getMetadata();
+
+		if ( !$meta ) {
+			return false;
+		}
+		$meta = unserialize( $meta );
+		 if ( !isset( $meta['metadata'] ) || count( $meta['metadata'] ) <= 1 ) {
+			return false;
+		}
+
+		if ( isset( $meta['metadata']['_MW_GIF_VERSION'] ) ) {
+			unset( $meta['metadata']['_MW_GIF_VERSION'] );
+		}
+		return $this->formatMetadataHelper( $meta['metadata'] );
 	}
-	
+
+	/**
+	 * @param $image File
+	 * @param  $width
+	 * @param  $height
+	 * @return
+	 */
 	function getImageArea( $image, $width, $height ) {
 		$ser = $image->getMetadata();
-		if ($ser) {
-			$metadata = unserialize($ser);
+		if ( $ser ) {
+			$metadata = unserialize( $ser );
 			return $width * $height * $metadata['frameCount'];
 		} else {
 			return $width * $height;
 		}
 	}
 
+	/**
+	 * @param $image File
+	 * @return bool
+	 */
 	function isAnimatedImage( $image ) {
 		$ser = $image->getMetadata();
-		if ($ser) {
+		if ( $ser ) {
 			$metadata = unserialize($ser);
-			if( $metadata['frameCount'] > 1 ) return true;
+			if( $metadata['frameCount'] > 1 ) {
+				return true;
+			}
 		}
 		return false;
 	}
-	
+
 	function getMetadataType( $image ) {
 		return 'parsed-gif';
 	}
-	
+
 	function isMetadataValid( $image, $metadata ) {
+		if ( $metadata === self::BROKEN_FILE ) {
+			// Do not repetitivly regenerate metadata on broken file.
+			return self::METADATA_GOOD;
+		}
+
 		wfSuppressWarnings();
 		$data = unserialize( $metadata );
 		wfRestoreWarnings();
-		return (boolean) $data;
+
+		if ( !$data || !is_array( $data ) ) {
+			wfDebug(__METHOD__ . ' invalid GIF metadata' );
+			return self::METADATA_BAD;
+		}
+
+		if ( !isset( $data['metadata']['_MW_GIF_VERSION'] )
+			|| $data['metadata']['_MW_GIF_VERSION'] != GIFMetadataExtractor::VERSION ) {
+			wfDebug(__METHOD__ . ' old but compatible GIF metadata' );
+			return self::METADATA_COMPATIBLE;
+		}
+		return self::METADATA_GOOD;
 	}
 
+	/**
+	 * @param $image File
+	 * @return string
+	 */
 	function getLongDesc( $image ) {
 		global $wgLang;
 
@@ -71,20 +119,25 @@ class GIFHandler extends BitmapHandler {
 		$metadata = unserialize($image->getMetadata());
 		wfRestoreWarnings();
 		
-		if (!$metadata || $metadata['frameCount'] <=  1)
+		if (!$metadata || $metadata['frameCount'] <=  1) {
 			return $original;
-		
+		}
+
+		/* Preserve original image info string, but strip the last char ')' so we can add even more */
 		$info = array();
 		$info[] = $original;
 		
-		if ($metadata['looped'])
+		if ( $metadata['looped'] ) {
 			$info[] = wfMsgExt( 'file-info-gif-looped', 'parseinline' );
+		}
 		
-		if ($metadata['frameCount'] > 1)
+		if ( $metadata['frameCount'] > 1 ) {
 			$info[] = wfMsgExt( 'file-info-gif-frames', 'parseinline', $metadata['frameCount'] );
+		}
 		
-		if ($metadata['duration'])
+		if ( $metadata['duration'] ) {
 			$info[] = $wgLang->formatTimePeriod( $metadata['duration'] );
+		}
 		
 		return $wgLang->commaList( $info );
 	}
diff --git a/includes/media/GIFMetadataExtractor.php b/includes/media/GIFMetadataExtractor.php
index bc1a4804..5dbeb8f8 100644
--- a/includes/media/GIFMetadataExtractor.php
+++ b/includes/media/GIFMetadataExtractor.php
@@ -21,164 +21,294 @@ class GIFMetadataExtractor {
 	static $gif_extension_sep;
 	static $gif_term;
 
+	const VERSION = 1;
+
+	// Each sub-block is less than or equal to 255 bytes.
+	// Most of the time its 255 bytes, except for in XMP
+	// blocks, where it's usually between 32-127 bytes each.
+	const MAX_SUBBLOCKS = 262144; // 5mb divided by 20.
+
+	/**
+	 * @throws Exception
+	 * @param $filename string
+	 * @return array
+	 */
 	static function getMetadata( $filename ) {
 		self::$gif_frame_sep = pack( "C", ord("," ) );
 		self::$gif_extension_sep = pack( "C", ord("!" ) );
 		self::$gif_term = pack( "C", ord(";" ) );
-		
+
 		$frameCount = 0;
 		$duration = 0.0;
 		$isLooped = false;
+		$xmp = "";
+		$comment = array();
 		
-		if (!$filename)
+		if ( !$filename ) {
 			throw new Exception( "No file name specified" );
-		elseif ( !file_exists($filename) || is_dir($filename) )
+		} elseif ( !file_exists( $filename ) || is_dir( $filename ) ) {
 			throw new Exception( "File $filename does not exist" );
-		
-		$fh = fopen( $filename, 'r' );
-		
-		if (!$fh)
+		}
+
+		$fh = fopen( $filename, 'rb' );
+
+		if ( !$fh ) {
 			throw new Exception( "Unable to open file $filename" );
-		
+		}
+
 		// Check for the GIF header
 		$buf = fread( $fh, 6 );
 		if ( !($buf == 'GIF87a' || $buf == 'GIF89a') ) {
 			throw new Exception( "Not a valid GIF file; header: $buf" );
 		}
-		
+
 		// Skip over width and height.
 		fread( $fh, 4 );
-		
+
 		// Read BPP
 		$buf = fread( $fh, 1 );
 		$bpp = self::decodeBPP( $buf );
-		
+
 		// Skip over background and aspect ratio
 		fread( $fh, 2 );
-		
+
 		// Skip over the GCT
 		self::readGCT( $fh, $bpp );
-		
+
 		while( !feof( $fh ) ) {
 			$buf = fread( $fh, 1 );
-			
+
 			if ($buf == self::$gif_frame_sep) {
 				// Found a frame
 				$frameCount++;
-				
+
 				## Skip bounding box
 				fread( $fh, 8 );
-				
+
 				## Read BPP
 				$buf = fread( $fh, 1 );
 				$bpp = self::decodeBPP( $buf );
-				
+
 				## Read GCT
 				self::readGCT( $fh, $bpp );
 				fread( $fh, 1 );
 				self::skipBlock( $fh );	
 			} elseif ( $buf == self::$gif_extension_sep ) {
 				$buf = fread( $fh, 1 );
+				if ( strlen( $buf ) < 1 ) throw new Exception( "Ran out of input" );
 				$extension_code = unpack( 'C', $buf );
 				$extension_code = $extension_code[1];
-				
+
 				if ($extension_code == 0xF9) {
 					// Graphics Control Extension.
 					fread( $fh, 1 ); // Block size
-					
+
 					fread( $fh, 1 ); // Transparency, disposal method, user input
-					
+
 					$buf = fread( $fh, 2 ); // Delay, in hundredths of seconds.
+					if ( strlen( $buf ) < 2 ) throw new Exception( "Ran out of input" );
 					$delay = unpack( 'v', $buf );
 					$delay = $delay[1];
 					$duration += $delay * 0.01;
-					
+
 					fread( $fh, 1 ); // Transparent colour index
-					
+
 					$term = fread( $fh, 1 ); // Should be a terminator
+					if ( strlen( $term ) < 1 ) throw new Exception( "Ran out of input" );
 					$term = unpack( 'C', $term );
 					$term = $term[1];
-					if ($term != 0 )
+					if ($term != 0 ) {
 						throw new Exception( "Malformed Graphics Control Extension block" );
+					}
+				} elseif ($extension_code == 0xFE) {
+					// Comment block(s).
+					$data = self::readBlock( $fh );
+					if ( $data === "" ) {
+						throw new Exception( 'Read error, zero-length comment block' );
+					}
+
+					// The standard says this should be ASCII, however its unclear if
+					// thats true in practise. Check to see if its valid utf-8, if so
+					// assume its that, otherwise assume its windows-1252 (iso-8859-1)
+					$dataCopy = $data;
+					// quickIsNFCVerify has the side effect of replacing any invalid characters
+					UtfNormal::quickIsNFCVerify( $dataCopy );
+
+					if ( $dataCopy !== $data ) {
+						wfSuppressWarnings();
+						$data = iconv( 'windows-1252', 'UTF-8', $data );
+						wfRestoreWarnings();
+					}
+
+					$commentCount = count( $comment );
+					if ( $commentCount === 0
+						|| $comment[$commentCount-1] !== $data )
+					{
+						// Some applications repeat the same comment on each
+						// frame of an animated GIF image, so if this comment
+						// is identical to the last, only extract once.
+						$comment[] = $data;
+					}
 				} elseif ($extension_code == 0xFF) {
 					// Application extension (Netscape info about the animated gif)
+					// or XMP (or theoretically any other type of extension block)
 					$blockLength = fread( $fh, 1 );
+					if ( strlen( $blockLength ) < 1 ) throw new Exception( "Ran out of input" );
 					$blockLength = unpack( 'C', $blockLength );
 					$blockLength = $blockLength[1];
 					$data = fread( $fh, $blockLength );
-					
-					// NETSCAPE2.0 (application name)
-					if ($blockLength != 11 || $data != 'NETSCAPE2.0') {
+
+					if ($blockLength != 11 ) {
+						wfDebug( __METHOD__ . ' GIF application block with wrong length' );
 						fseek( $fh, -($blockLength + 1), SEEK_CUR );
 						self::skipBlock( $fh );
 						continue;
 					}
+
+					// NETSCAPE2.0 (application name for animated gif)
+					if ( $data == 'NETSCAPE2.0' ) {
 					
-					$data = fread( $fh, 2 ); // Block length and introduction, should be 03 01
-					
-					if ($data != "\x03\x01") {
-						throw new Exception( "Expected \x03\x01, got $data" );
-					}
-					
-					// Unsigned little-endian integer, loop count or zero for "forever"
-					$loopData = fread( $fh, 2 );
-					$loopData = unpack( 'v', $loopData );
-					$loopCount = $loopData[1];
-					
-					if ($loopCount != 1) {
-						$isLooped = true;
+						$data = fread( $fh, 2 ); // Block length and introduction, should be 03 01
+
+						if ($data != "\x03\x01") {
+							throw new Exception( "Expected \x03\x01, got $data" );
+						}
+						
+						// Unsigned little-endian integer, loop count or zero for "forever"
+						$loopData = fread( $fh, 2 );
+						if ( strlen( $loopData ) < 2 ) throw new Exception( "Ran out of input" );
+						$loopData = unpack( 'v', $loopData );
+						$loopCount = $loopData[1];
+						
+						if ($loopCount != 1) {
+							$isLooped = true;
+						}
+						
+						// Read out terminator byte
+						fread( $fh, 1 );
+					} elseif ( $data == 'XMP DataXMP' ) {
+						// application name for XMP data.
+						// see pg 18 of XMP spec part 3.
+
+						$xmp = self::readBlock( $fh, true );
+
+						if ( substr( $xmp, -257, 3 ) !== "\x01\xFF\xFE"
+							|| substr( $xmp, -4 ) !== "\x03\x02\x01\x00" )
+						{
+							// this is just a sanity check.
+							throw new Exception( "XMP does not have magic trailer!" );
+						}
+
+						// strip out trailer.
+						$xmp = substr( $xmp, 0, -257 );
+
+					} else {
+						// unrecognized extension block
+						fseek( $fh, -($blockLength + 1), SEEK_CUR );
+						self::skipBlock( $fh );
+						continue;
 					}
-					
-					// Read out terminator byte
-					fread( $fh, 1 );
 				} else {
 					self::skipBlock( $fh );
 				}
 			} elseif ( $buf == self::$gif_term ) {
 				break;
 			} else {
+				if ( strlen( $buf ) < 1 ) throw new Exception( "Ran out of input" );
 				$byte = unpack( 'C', $buf );
 				$byte = $byte[1];
 				throw new Exception( "At position: ".ftell($fh). ", Unknown byte ".$byte );
 			}
 		}
-		
+
 		return array(
 			'frameCount' => $frameCount,
 			'looped' => $isLooped,
-			'duration' => $duration
+			'duration' => $duration,
+			'xmp' => $xmp,
+			'comment' => $comment,
 		);
-		
 	}
-	
+
+	/**
+	 * @param $fh
+	 * @param $bpp
+	 * @return void
+	 */
 	static function readGCT( $fh, $bpp ) {
-		if ($bpp > 0) {
-			for( $i=1; $i<=pow(2,$bpp); ++$i ) {
+		if ( $bpp > 0 ) {
+			for( $i=1; $i<=pow( 2, $bpp ); ++$i ) {
 				fread( $fh, 3 );
 			}
 		}
 	}
-	
+
+	/**
+	 * @param $data
+	 * @return int
+	 */
 	static function decodeBPP( $data ) {
+		if ( strlen( $data ) < 1 ) throw new Exception( "Ran out of input" );
 		$buf = unpack( 'C', $data );
 		$buf = $buf[1];
 		$bpp = ( $buf & 7 ) + 1;
 		$buf >>= 7;
-		
+
 		$have_map = $buf & 1;
-		
+
 		return $have_map ? $bpp : 0;
 	}
-	
+
+	/**
+	 * @param $fh
+	 * @return
+	 */
 	static function skipBlock( $fh ) {
 		while ( !feof( $fh ) ) {
 			$buf = fread( $fh, 1 );
+			if ( strlen( $buf ) < 1 ) throw new Exception( "Ran out of input" );
 			$block_len = unpack( 'C', $buf );
 			$block_len = $block_len[1];
-			if ($block_len == 0)
+			if ($block_len == 0) {
 				return;
+			}
 			fread( $fh, $block_len );
 		}
 	}
+	/**
+	 * Read a block. In the GIF format, a block is made up of
+	 * several sub-blocks. Each sub block starts with one byte
+	 * saying how long the sub-block is, followed by the sub-block.
+	 * The entire block is terminated by a sub-block of length
+	 * 0.
+	 * @param $fh FileHandle
+	 * @param $includeLengths Boolean Include the length bytes of the
+	 *  sub-blocks in the returned value. Normally this is false,
+	 *  except XMP is weird and does a hack where you need to keep
+	 *  these length bytes.
+	 * @return The data.
+	 */
+	static function readBlock( $fh, $includeLengths = false ) {
+		$data = '';
+		$subLength = fread( $fh, 1 );
+		$blocks = 0;
+
+		while( $subLength !== "\0" ) {
+			$blocks++;
+			if ( $blocks > self::MAX_SUBBLOCKS ) {
+				throw new Exception( "MAX_SUBBLOCKS exceeded (over $blocks sub-blocks)" );
+			}
+			if ( feof( $fh ) ) {
+				throw new Exception( "Read error: Unexpected EOF." );
+			}
+			if ( $includeLengths ) {
+				$data .= $subLength;
+			}
+
+			$data .= fread( $fh, ord( $subLength ) );
+			$subLength = fread( $fh, 1 );
+		}
+		return $data;
+	}
 
 }
diff --git a/includes/media/Generic.php b/includes/media/Generic.php
index fa4e731a..48735ebf 100644
--- a/includes/media/Generic.php
+++ b/includes/media/Generic.php
@@ -13,7 +13,9 @@
  */
 abstract class MediaHandler {
 	const TRANSFORM_LATER = 1;
-
+	const METADATA_GOOD = true;
+	const METADATA_BAD = false;
+	const METADATA_COMPATIBLE = 2; // for old but backwards compatible.
 	/**
 	 * Instance cache
 	 */
@@ -21,6 +23,10 @@ abstract class MediaHandler {
 
 	/**
 	 * Get a MediaHandler for a given MIME type from the instance cache
+	 *
+	 * @param $type string
+	 *
+	 * @return MediaHandler
 	 */
 	static function getHandler( $type ) {
 		global $wgMediaHandlers;
@@ -44,20 +50,27 @@ abstract class MediaHandler {
 	 */
 	abstract function getParamMap();
 
-	/*
+	/**
 	 * Validate a thumbnail parameter at parse time.
 	 * Return true to accept the parameter, and false to reject it.
 	 * If you return false, the parser will do something quiet and forgiving.
+	 *
+	 * @param $name
+	 * @param $value
 	 */
 	abstract function validateParam( $name, $value );
 
 	/**
 	 * Merge a parameter array into a string appropriate for inclusion in filenames
+	 *
+	 * @param $params array
 	 */
 	abstract function makeParamString( $params );
 
 	/**
 	 * Parse a param string made with makeParamString back into an array
+	 *
+	 * @param $str string
 	 */
 	abstract function parseParamString( $str );
 
@@ -65,6 +78,8 @@ abstract class MediaHandler {
 	 * Changes the parameter array as necessary, ready for transformation.
 	 * Should be idempotent.
 	 * Returns false if the parameters are unacceptable and the transform should fail
+	 * @param $image
+	 * @param $params
 	 */
 	abstract function normaliseParams( $image, &$params );
 
@@ -89,15 +104,66 @@ abstract class MediaHandler {
 	function getMetadata( $image, $path ) { return ''; }
 
 	/**
+	* Get metadata version.
+	*
+	* This is not used for validating metadata, this is used for the api when returning
+	* metadata, since api content formats should stay the same over time, and so things
+	* using ForiegnApiRepo can keep backwards compatibility
+	*
+	* All core media handlers share a common version number, and extensions can
+	* use the GetMetadataVersion hook to append to the array (they should append a unique
+	* string so not to get confusing). If there was a media handler named 'foo' with metadata
+	* version 3 it might add to the end of the array the element 'foo=3'. if the core metadata
+	* version is 2, the end version string would look like '2;foo=3'.
+	*
+	* @return string version string
+	*/
+	static function getMetadataVersion () {
+		$version = Array( '2' ); // core metadata version
+		wfRunHooks('GetMetadataVersion', Array(&$version));
+		return implode( ';', $version);
+	 }
+
+	/**
+	* Convert metadata version.
+	*
+	* By default just returns $metadata, but can be used to allow
+	* media handlers to convert between metadata versions.
+	*
+	* @param $metadata Mixed String or Array metadata array (serialized if string)
+	* @param $version Integer target version
+	* @return Array serialized metadata in specified version, or $metadata on fail.
+	*/
+	function convertMetadataVersion( $metadata, $version = 1 ) {
+		if ( !is_array( $metadata ) ) {
+
+			//unserialize to keep return parameter consistent.
+			wfSuppressWarnings();
+			$ret = unserialize( $metadata );
+			wfRestoreWarnings();
+			return $ret;
+		}
+		return $metadata;
+	}
+
+	/**
 	 * Get a string describing the type of metadata, for display purposes.
+	 *
+	 * @return string
 	 */
 	function getMetadataType( $image ) { return false; }
 
 	/**
 	 * Check if the metadata string is valid for this handler.
-	 * If it returns false, Image will reload the metadata from the file and update the database
+	 * If it returns MediaHandler::METADATA_BAD (or false), Image
+	 * will reload the metadata from the file and update the database.
+	 * MediaHandler::METADATA_GOOD for if the metadata is a-ok,
+	 * MediaHanlder::METADATA_COMPATIBLE if metadata is old but backwards
+	 * compatible (which may or may not trigger a metadata reload).
 	 */
-	function isMetadataValid( $image, $metadata ) { return true; }
+	function isMetadataValid( $image, $metadata ) {
+		return self::METADATA_GOOD;
+	}
 
 
 	/**
@@ -142,6 +208,18 @@ abstract class MediaHandler {
 	 * @return array thumbnail extension and MIME type
 	 */
 	function getThumbType( $ext, $mime, $params = null ) {
+		$magic = MimeMagic::singleton();
+		if ( !$ext || $magic->isMatchingExtension( $ext, $mime ) === false ) {
+			// The extension is not valid for this mime type and we do
+			// recognize the mime type
+			$extensions = $magic->getExtensionsForType( $mime );
+			if ( $extensions ) {
+				return array( strtok( $extensions, ' ' ), $mime );
+			}
+		}
+
+		// The extension is correct (true) or the mime type is unknown to
+		// MediaWiki (null)
 		return array( $ext, $mime );
 	}
 
@@ -176,6 +254,8 @@ abstract class MediaHandler {
 	 * Currently "width" and "height" are understood, but this might be
 	 * expanded in the future.
 	 * Returns false if unknown or if the document is not multi-page.
+	 *
+	 * @param $image File
 	 */
 	function getPageDimensions( $image, $page ) {
 		$gis = $this->getImageSize( $image, $image->getPath() );
@@ -213,7 +293,7 @@ abstract class MediaHandler {
 	 */
 
 	/**
-	 * FIXME: I don't really like this interface, it's not very flexible
+	 * @todo FIXME: I don't really like this interface, it's not very flexible
 	 * I think the media handler should generate HTML instead. It can do
 	 * all the formatting according to some standard. That makes it possible
 	 * to do things like visual indication of grouped and chained streams
@@ -223,22 +303,104 @@ abstract class MediaHandler {
 		return false;
 	}
 
+	/** sorts the visible/invisible field.
+	 * Split off from ImageHandler::formatMetadata, as used by more than
+	 * one type of handler.
+	 *
+	 * This is used by the media handlers that use the FormatMetadata class
+	 *
+	 * @param $metadataArray Array metadata array
+	 * @return array for use displaying metadata.
+	 */
+	function formatMetadataHelper( $metadataArray ) {
+		 $result = array(
+			'visible' => array(),
+			'collapsed' => array()
+		);
+
+		$formatted = FormatMetadata::getFormattedData( $metadataArray );
+		// Sort fields into visible and collapsed
+		$visibleFields = $this->visibleMetadataFields();
+		foreach ( $formatted as $name => $value ) {
+			$tag = strtolower( $name );
+			self::addMeta( $result,
+				in_array( $tag, $visibleFields ) ? 'visible' : 'collapsed',
+				'exif',
+				$tag,
+				$value
+			);
+		}
+		return $result;
+	}
+
+	/**
+	 * Get a list of metadata items which should be displayed when
+	 * the metadata table is collapsed.
+	 *
+	 * @return array of strings
+	 * @access protected
+	 */
+	function visibleMetadataFields() {
+		$fields = array();
+		$lines = explode( "\n", wfMsgForContent( 'metadata-fields' ) );
+		foreach( $lines as $line ) {
+			$matches = array();
+			if( preg_match( '/^\\*\s*(.*?)\s*$/', $line, $matches ) ) {
+				$fields[] = $matches[1];
+			}
+		}
+		$fields = array_map( 'strtolower', $fields );
+		return $fields;
+	}
+
+
 	/**
-	 * @todo Fixme: document this!
-	 * 'value' thingy goes into a wikitext table; it used to be escaped but
-	 * that was incompatible with previous practice of customized display
+	 * This is used to generate an array element for each metadata value
+	 * That array is then used to generate the table of metadata values
+	 * on the image page
+	 *
+	 * @param &$array Array An array containing elements for each type of visibility
+	 * and each of those elements being an array of metadata items. This function adds
+	 * a value to that array.
+	 * @param $visbility string ('visible' or 'collapsed') if this value is hidden
+	 * by default.
+	 * @param $type String type of metadata tag (currently always 'exif')
+	 * @param $id String the name of the metadata tag (like 'artist' for example).
+	 * its name in the table displayed is the message "$type-$id" (Ex exif-artist ).
+	 * @param $value String thingy goes into a wikitext table; it used to be escaped but
+	 * that was incompatible with previous practise of customized display
 	 * with wikitext formatting via messages such as 'exif-model-value'.
 	 * So the escaping is taken back out, but generally this seems a confusing
 	 * interface.
+	 * @param $param String value to pass to the message for the name of the field
+	 * as $1. Currently this parameter doesn't seem to ever be used.
+	 *
+	 * Note, everything here is passed through the parser later on (!)
 	 */
 	protected static function addMeta( &$array, $visibility, $type, $id, $value, $param = false ) {
+		$msgName = "$type-$id";
+		if ( wfEmptyMsg( $msgName ) ) {
+			// This is for future compatibility when using instant commons.
+			// So as to not display as ugly a name if a new metadata
+			// property is defined that we don't know about
+			// (not a major issue since such a property would be collapsed
+			// by default).
+			wfDebug( __METHOD__ . ' Unknown metadata name: ' . $id . "\n" );
+			$name = wfEscapeWikiText( $id );
+		} else {
+			$name = wfMsg( $msgName, $param );
+		}
 		$array[$visibility][] = array(
 			'id' => "$type-$id",
-			'name' => wfMsg( "$type-$id", $param ),
+			'name' => $name,
 			'value' => $value
 		);
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getShortDesc( $file ) {
 		global $wgLang;
 		$nbytes = wfMsgExt( 'nbytes', array( 'parsemag', 'escape' ),
@@ -246,14 +408,21 @@ abstract class MediaHandler {
 		return "$nbytes";
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getLongDesc( $file ) {
-		global $wgUser;
-		$sk = $wgUser->getSkin();
+		global $wgLang;
 		return wfMsgExt( 'file-info', 'parseinline',
-			$sk->formatSize( $file->getSize() ),
+			$wgLang->formatSize( $file->getSize() ),
 			$file->getMimeType() );
 	}
-	
+
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	static function getGeneralShortDesc( $file ) {
 		global $wgLang;
 		$nbytes = wfMsgExt( 'nbytes', array( 'parsemag', 'escape' ),
@@ -261,11 +430,14 @@ abstract class MediaHandler {
 		return "$nbytes";
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	static function getGeneralLongDesc( $file ) {
-		global $wgUser;
-		$sk = $wgUser->getSkin();
+		global $wgLang;
 		return wfMsgExt( 'file-info', 'parseinline',
-			$sk->formatSize( $file->getSize() ),
+			$wgLang->formatSize( $file->getSize() ),
 			$file->getMimeType() );
 	}
 
@@ -281,10 +453,10 @@ abstract class MediaHandler {
 	/**
 	 * File validation hook called on upload.
 	 *
-	 * If the file at the given local path is not valid, or its MIME type does not 
+	 * If the file at the given local path is not valid, or its MIME type does not
 	 * match the handler class, a Status object should be returned containing
 	 * relevant errors.
-	 * 
+	 *
 	 * @param $fileName The local path to the file.
 	 * @return Status object
 	 */
@@ -321,12 +493,13 @@ abstract class MediaHandler {
  * @ingroup Media
  */
 abstract class ImageHandler extends MediaHandler {
+
+	/**
+	 * @param $file File
+	 * @return bool
+	 */
 	function canRender( $file ) {
-		if ( $file->getWidth() && $file->getHeight() ) {
-			return true;
-		} else {
-			return false;
-		}
+		return ( $file->getWidth() && $file->getHeight() );
 	}
 
 	function getParamMap() {
@@ -371,6 +544,11 @@ abstract class ImageHandler extends MediaHandler {
 		return array( 'width' => $params['width'] );
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $params
+	 * @return bool
+	 */
 	function normaliseParams( $image, &$params ) {
 		$mimeType = $image->getMimeType();
 
@@ -392,13 +570,44 @@ abstract class ImageHandler extends MediaHandler {
 
 		$srcWidth = $image->getWidth( $params['page'] );
 		$srcHeight = $image->getHeight( $params['page'] );
+		
 		if ( isset( $params['height'] ) && $params['height'] != -1 ) {
+			# Height & width were both set
 			if ( $params['width'] * $srcHeight > $params['height'] * $srcWidth ) {
+				# Height is the relative smaller dimension, so scale width accordingly
 				$params['width'] = wfFitBoxWidth( $srcWidth, $srcHeight, $params['height'] );
+				
+				if ( $params['width'] == 0 ) {
+					# Very small image, so we need to rely on client side scaling :(
+					$params['width'] = 1;
+				}
+				
+				$params['physicalWidth'] = $params['width'];
+			} else {
+				# Height was crap, unset it so that it will be calculated later
+				unset( $params['height'] );
 			}
 		}
-		$params['height'] = File::scaleHeight( $srcWidth, $srcHeight, $params['width'] );
-		if ( !$this->validateThumbParams( $params['width'], $params['height'], $srcWidth, $srcHeight, $mimeType ) ) {
+		
+		if ( !isset( $params['physicalWidth'] ) ) {
+			# Passed all validations, so set the physicalWidth
+			$params['physicalWidth'] = $params['width'];
+		}
+		
+		# Because thumbs are only referred to by width, the height always needs
+		# to be scaled by the width to keep the thumbnail sizes consistent,
+		# even if it was set inside the if block above
+		$params['physicalHeight'] = File::scaleHeight( $srcWidth, $srcHeight, 
+			$params['physicalWidth'] );
+
+		# Set the height if it was not validated in the if block higher up 
+		if ( !isset( $params['height'] ) || $params['height'] == -1 ) {
+			$params['height'] = $params['physicalHeight'];
+		}
+
+		
+		if ( !$this->validateThumbParams( $params['physicalWidth'], 
+				$params['physicalHeight'], $srcWidth, $srcHeight, $mimeType ) ) {
 			return false;
 		}
 		return true;
@@ -435,9 +644,19 @@ abstract class ImageHandler extends MediaHandler {
 		}
 
 		$height = File::scaleHeight( $srcWidth, $srcHeight, $width );
+		if ( $height == 0 ) {
+			# Force height to be at least 1 pixel
+			$height = 1;
+		}
 		return true;
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $script
+	 * @param  $params
+	 * @return bool|ThumbnailImage
+	 */
 	function getScriptedTransform( $image, $script, $params ) {
 		if ( !$this->normaliseParams( $image, $params ) ) {
 			return false;
@@ -461,6 +680,10 @@ abstract class ImageHandler extends MediaHandler {
 		return false;
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getShortDesc( $file ) {
 		global $wgLang;
 		$nbytes = wfMsgExt( 'nbytes', array( 'parsemag', 'escape' ),
@@ -470,15 +693,34 @@ abstract class ImageHandler extends MediaHandler {
 		return "$widthheight ($nbytes)";
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getLongDesc( $file ) {
 		global $wgLang;
-		return wfMsgExt('file-info-size', 'parseinline',
-			$wgLang->formatNum( $file->getWidth() ),
-			$wgLang->formatNum( $file->getHeight() ),
-			$wgLang->formatSize( $file->getSize() ),
-			$file->getMimeType() );
+		$pages = $file->pageCount();
+		if ( $pages === false || $pages <= 1 ) {
+			$msg = wfMsgExt('file-info-size', 'parseinline',
+				$wgLang->formatNum( $file->getWidth() ),
+				$wgLang->formatNum( $file->getHeight() ),
+				$wgLang->formatSize( $file->getSize() ),
+				$file->getMimeType() );
+		} else {
+			$msg = wfMsgExt('file-info-size-pages', 'parseinline',
+				$wgLang->formatNum( $file->getWidth() ),
+				$wgLang->formatNum( $file->getHeight() ),
+				$wgLang->formatSize( $file->getSize() ),
+				$file->getMimeType(),
+				$wgLang->formatNum( $pages ) );
+		}
+		return $msg;
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getDimensionsString( $file ) {
 		global $wgLang;
 		$pages = $file->pageCount();
diff --git a/includes/media/IPTC.php b/includes/media/IPTC.php
new file mode 100644
index 00000000..1d19791c
--- /dev/null
+++ b/includes/media/IPTC.php
@@ -0,0 +1,576 @@
+<?php
+/**
+*Class for some IPTC functions.
+
+*/
+class IPTC {
+
+	/**
+	* This takes the results of iptcparse() and puts it into a
+	* form that can be handled by mediawiki. Generally called from
+	* BitmapMetadataHandler::doApp13.
+	*
+	* @see http://www.iptc.org/std/IIM/4.1/specification/IIMV4.1.pdf
+	*
+	* @param $rawData String app13 block from jpeg containing iptc/iim data
+	* @return Array iptc metadata array
+	*/
+	static function parse( $rawData ) {
+		$parsed = iptcparse( $rawData );
+		$data = Array();
+		if (!is_array($parsed)) {
+				return $data;
+		}
+
+		$c = '';
+		//charset info contained in tag 1:90.
+		if (isset($parsed['1#090']) && isset($parsed['1#090'][0])) {
+			$c = self::getCharset($parsed['1#090'][0]);
+			if ($c === false) {
+				//Unknown charset. refuse to parse.
+				//note: There is a different between
+				//unknown and no charset specified.
+				return array();
+			}
+			unset( $parsed['1#090'] );
+		}
+
+		foreach ( $parsed as $tag => $val ) {
+			if ( isset( $val[0] ) && trim($val[0]) == '' ) {
+				wfDebugLog('iptc', "IPTC tag $tag had only whitespace as its value.");
+				continue;
+			}
+			switch( $tag ) {
+				case '2#120': /*IPTC caption. mapped with exif ImageDescription*/
+					$data['ImageDescription'] = self::convIPTC( $val, $c );
+					break;
+				case '2#116': /* copyright. Mapped with exif copyright */
+					$data['Copyright'] = self::convIPTC( $val, $c );
+					break;
+				case '2#080': /* byline. Mapped with exif Artist */
+					/* merge with byline title (2:85)
+					 * like how exif does it with
+					 * Title, person. Not sure if this is best
+					 * approach since we no longer have the two fields
+					 * separate. each byline title entry corresponds to a
+					 * specific byline.                          */
+
+					$bylines = self::convIPTC( $val, $c );
+					if ( isset( $parsed['2#085'] ) ) {
+						$titles = self::convIPTC( $parsed['2#085'], $c );
+					} else {
+						$titles = array();
+					}
+
+					for ( $i = 0; $i < count( $titles ); $i++ ) {
+						if ( isset( $bylines[$i] ) ) {
+							// theoretically this should always be set
+							// but doesn't hurt to be careful.
+							$bylines[$i] = $titles[$i] . ', ' . $bylines[$i];
+						}
+					}
+					$data['Artist'] = $bylines;
+					break;
+				case '2#025': /* keywords */
+					$data['Keywords'] = self::convIPTC( $val, $c );
+					break;
+				case '2#101': /* Country (shown)*/
+					$data['CountryDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#095': /* state/province (shown) */
+					$data['ProvinceOrStateDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#090': /* city (Shown) */
+					$data['CityDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#092': /* sublocation (shown) */
+					$data['SublocationDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#005': /* object name/title */
+					$data['ObjectName'] = self::convIPTC( $val, $c );
+					break;
+				case '2#040': /* special instructions */
+					$data['SpecialInstructions'] = self::convIPTC( $val, $c );
+					break;
+				case '2#105': /* headline*/
+					$data['Headline'] = self::convIPTC( $val, $c );
+					break;
+				case '2#110': /* credit */
+					/*"Identifies the provider of the objectdata,
+					 * not necessarily the owner/creator". */
+					$data['Credit'] = self::convIPTC( $val, $c );
+					break;
+				case '2#115': /* source */
+					/* "Identifies the original owner of the intellectual content of the
+					 *objectdata. This could be an agency, a member of an agency or
+					 *an individual." */
+					$data['Source'] = self::convIPTC( $val, $c );
+					break;
+
+				case '2#007': /* edit status (lead, correction, etc) */
+					$data['EditStatus'] = self::convIPTC( $val, $c );
+					break;
+				case '2#015': /* category. deprecated. max 3 letters in theory, often more */
+					$data['iimCategory'] = self::convIPTC( $val, $c );
+					break;
+				case '2#020': /* category. deprecated. */
+					$data['iimSupplementalCategory'] = self::convIPTC( $val, $c );
+					break;
+				case '2#010': /*urgency (1-8. 1 most, 5 normal, 8 low priority)*/
+					$data['Urgency'] = self::convIPTC( $val, $c );
+					break;
+				case '2#022':
+					/* "Identifies objectdata that recurs often and predictably...
+					 * Example: Euroweather" */
+					$data['FixtureIdentifier'] = self::convIPTC( $val, $c );
+					break;
+				case '2#026':
+					/* Content location code (iso 3166 + some custom things)
+					 * ex: TUR (for turkey), XUN (for UN), XSP (outer space)
+					 * See wikipedia article on iso 3166 and appendix D of iim std. */
+					$data['LocationDestCode'] = self::convIPTC( $val, $c );
+					break;
+				case '2#027':
+					/* Content location name. Full printable name
+					 * of location of photo. */
+					$data['LocationDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#065':
+					/* Originating Program.
+					 * Combine with Program version (2:70) if present.
+					 */
+					$software = self::convIPTC( $val, $c );
+
+					if ( count( $software ) !== 1 ) {
+						//according to iim standard this cannot have multiple values
+						//so if there is more than one, something weird is happening,
+						//and we skip it.
+						wfDebugLog( 'iptc', 'IPTC: Wrong count on 2:65 Software field' );
+						break;
+					}
+
+					if ( isset( $parsed['2#070'] ) ) {
+						//if a version is set for the software.
+						$softwareVersion = self::convIPTC( $parsed['2#070'], $c );
+						unset($parsed['2#070']);
+						$data['Software'] = array( array( $software[0], $softwareVersion[0] ) );
+					} else {
+						$data['Software'] = $software;
+					}
+					break;
+				case '2#075':
+					/* Object cycle.
+					 * a for morning (am), p for evening, b for both */
+					$data['ObjectCycle'] = self::convIPTC( $val, $c );
+					break;
+				case '2#100':
+					/* Country/Primary location code.
+					 * "Indicates the code of the country/primary location where the
+					 * intellectual property of the objectdata was created"
+					 * unclear how this differs from 2#026
+					 */
+					$data['CountryCodeDest'] = self::convIPTC( $val, $c );
+					break;
+				case '2#103':
+					/* original transmission ref.
+					 * "A code representing the location of original transmission ac-
+					 * cording to practises of the provider."
+					*/
+					$data['OriginalTransmissionRef'] = self::convIPTC( $val, $c );
+					break;
+				case '2#118': /*contact*/
+					$data['Contact'] = self::convIPTC( $val, $c );
+					break;
+				case '2#122':
+					/* Writer/Editor
+					 * "Identification of the name of the person involved in the writing,
+					 * editing or correcting the objectdata or caption/abstract."
+					 */
+					$data['Writer'] = self::convIPTC( $val, $c );
+					break;
+				case '2#135': /* lang code */
+					$data['LanguageCode'] = self::convIPTC( $val, $c );
+					break;
+
+				// Start date stuff.
+				// It doesn't accept incomplete dates even though they are valid
+				// according to spec.
+				// Should potentially store timezone as well.
+				case '2#055':
+					//Date created (not date digitized).
+					//Maps to exif DateTimeOriginal
+					if ( isset( $parsed['2#060'] ) ) {
+						$time = $parsed['2#060'];
+					} else {
+						$time = Array();
+					}
+					$timestamp =  self::timeHelper( $val, $time, $c );
+					if ($timestamp) {
+						$data['DateTimeOriginal'] = $timestamp;
+					}
+					break;
+
+				case '2#062':
+					//Date converted to digital representation.
+					//Maps to exif DateTimeDigitized
+					if ( isset( $parsed['2#063'] ) ) {
+						$time = $parsed['2#063'];
+					} else {
+						$time = Array();
+					}
+					$timestamp =  self::timeHelper( $val, $time, $c );
+					if ($timestamp) {
+						$data['DateTimeDigitized'] = $timestamp;
+					}
+					break;
+
+				case '2#030':
+					//Date released.
+					if ( isset( $parsed['2#035'] ) ) {
+						$time = $parsed['2#035'];
+					} else {
+						$time = Array();
+					}
+					$timestamp =  self::timeHelper( $val, $time, $c );
+					if ($timestamp) {
+						$data['DateTimeReleased'] = $timestamp;
+					}
+					break;
+
+				case '2#037':
+					//Date expires.
+					if ( isset( $parsed['2#038'] ) ) {
+						$time = $parsed['2#038'];
+					} else {
+						$time = Array();
+					}
+					$timestamp =  self::timeHelper( $val, $time, $c );
+					if ($timestamp) {
+						$data['DateTimeExpires'] = $timestamp;
+					}
+					break;
+
+				case '2#000': /* iim version */
+					// unlike other tags, this is a 2-byte binary number.
+					//technically this is required if there is iptc data
+					//but in practise it isn't always there.
+					if ( strlen( $val[0] ) == 2 ) {
+						//if is just to be paranoid.
+						$versionValue = ord( substr( $val[0], 0, 1 ) ) * 256;
+						$versionValue += ord( substr( $val[0], 1, 1 ) );
+						$data['iimVersion'] = $versionValue;
+					}
+					break;
+
+				case '2#004':
+					// IntellectualGenere.
+					// first 4 characters are an id code
+					// That we're not really interested in.
+
+					// This prop is weird, since it's
+					// allowed to have multiple values
+					// in iim 4.1, but not in the XMP
+					// stuff. We're going to just
+					// extract the first value.
+					$con = self::ConvIPTC( $val, $c );
+					if ( strlen( $con[0] ) < 5 ) {
+						wfDebugLog( 'iptc', 'IPTC: '
+							. '2:04 too short. '
+							. 'Ignoring.' );
+							break;
+					}
+					$extracted = substr( $con[0], 4 );
+					$data['IntellectualGenre'] = $extracted;
+					break;
+
+				case '2#012':
+					// Subject News code - this is a compound field
+					// at the moment we only extract the subject news
+					// code, which is an 8 digit (ascii) number
+					// describing the subject matter of the content.
+					$codes = self::convIPTC( $val, $c );
+					foreach ( $codes as $ic ) {
+						$fields = explode(':', $ic, 3 );
+
+						if ( count( $fields ) < 2 ||
+							$fields[0] !== 'IPTC' )
+						{
+							wfDebugLog( 'IPTC', 'IPTC: '
+								. 'Invalid 2:12 - ' . $ic );
+							break;
+						}
+						$data['SubjectNewsCode'] = $fields[1];
+					}
+					break;
+
+				// purposely does not do 2:125, 2:130, 2:131,
+				// 2:47, 2:50, 2:45, 2:42, 2:8, 2:3
+				// 2:200, 2:201, 2:202
+				// or the audio stuff (2:150 to 2:154)
+
+				case '2#070':
+				case '2#060':
+				case '2#063':
+				case '2#085':
+				case '2#038':
+				case '2#035':
+					//ignore. Handled elsewhere.
+					break;
+
+				default:
+					wfDebugLog( 'iptc', "Unsupported iptc tag: $tag. Value: " . implode( ',', $val ));
+					break;
+			}
+
+		}
+		return $data;
+	}
+
+	/**
+	* Convert an iptc date and time tags into the exif format
+	*
+	* @todo Potentially this should also capture the timezone offset.
+	* @param Array $date The date tag
+	* @param Array $time The time tag
+	* @param $c
+	* @return String Date in exif format.
+	*/
+	private static function timeHelper( $date, $time, $c ) {
+		if ( count( $date ) === 1 ) {
+			//the standard says this should always be 1
+			//just double checking.
+			list($date) = self::convIPTC( $date, $c );
+		} else {
+			return null;
+		}
+
+		if ( count( $time ) === 1 ) {
+			list($time) = self::convIPTC( $time, $c );
+			$dateOnly = false;
+		} else {
+			$time = '000000+0000'; //placeholder
+			$dateOnly = true;
+		}
+
+		if ( ! ( preg_match('/\d\d\d\d\d\d[-+]\d\d\d\d/', $time)
+			&& preg_match('/\d\d\d\d\d\d\d\d/', $date)
+			&& substr($date, 0, 4) !== '0000'
+			&& substr($date, 4, 2) !== '00'
+			&& substr($date, 6, 2) !== '00'
+		 ) ) {
+			//something wrong.
+			// Note, this rejects some valid dates according to iptc spec
+			// for example: the date 00000400 means the photo was taken in
+			// April, but the year and day is unknown. We don't process these
+			// types of incomplete dates atm.
+			wfDebugLog( 'iptc', "IPTC: invalid time ( $time ) or date ( $date )");
+			return null;
+		}
+
+		$unixTS = wfTimestamp( TS_UNIX, $date . substr( $time, 0, 6 ));
+		if ( $unixTS === false ) {
+			wfDebugLog( 'iptc', "IPTC: can't convert date to TS_UNIX: $date $time." );
+			return null;
+		}
+
+		$tz = ( intval( substr( $time, 7, 2 ) ) *60*60 )
+			+ ( intval( substr( $time, 9, 2 ) ) * 60 );
+
+		if ( substr( $time, 6, 1 ) === '-' ) {
+			$tz = - $tz;
+		}
+
+		$finalTimestamp = wfTimestamp( TS_EXIF, $unixTS + $tz );
+		if ( $finalTimestamp === false ) {
+			wfDebugLog( 'iptc', "IPTC: can't make final timestamp. Date: " . ( $unixTS + $tz ) );
+			return null;
+		}
+		if ( $dateOnly ) {
+			//return the date only
+			return substr( $finalTimestamp, 0, 10 );
+		} else {
+			return $finalTimestamp;
+		}
+	}
+
+	/**
+	* Helper function to convert charset for iptc values.
+	* @param $data Mixed String or Array: The iptc string
+	* @param $charset String: The charset
+	 *
+	 * @return string
+	*/
+	private static function convIPTC ( $data, $charset ) {
+		if ( is_array( $data ) ) {
+			foreach ($data as &$val) {
+				$val = self::convIPTCHelper( $val, $charset );
+			}
+		} else {
+			$data = self::convIPTCHelper( $data, $charset );
+		}
+
+		return $data;
+	}
+	/**
+	* Helper function of a helper function to convert charset for iptc values.
+	* @param $data Mixed String or Array: The iptc string
+	* @param $charset String: The charset
+	*
+	* @return string
+	*/
+	private static function convIPTCHelper ( $data, $charset ) {
+		if ( $charset ) {
+			wfSuppressWarnings();
+			$data = iconv($charset, "UTF-8//IGNORE", $data);
+			wfRestoreWarnings();
+			if ($data === false) {
+				$data = "";
+				wfDebugLog('iptc', __METHOD__ . " Error converting iptc data charset $charset to utf-8");
+			}
+		} else {
+			//treat as utf-8 if is valid utf-8. otherwise pretend its windows-1252
+			// most of the time if there is no 1:90 tag, it is either ascii, latin1, or utf-8
+			$oldData = $data;
+			UtfNormal::quickIsNFCVerify( $data ); //make $data valid utf-8
+			if ($data === $oldData) {
+				return $data; //if validation didn't change $data
+			} else {
+				return self::convIPTCHelper( $oldData, 'Windows-1252' );
+			}
+		}
+		return trim( $data );
+	}
+
+	/**
+	* take the value of 1:90 tag and returns a charset
+	* @param String $tag 1:90 tag.
+	* @return string charset name or "?"
+	* Warning, this function does not (and is not intended to) detect
+	* all iso 2022 escape codes. In practise, the code for utf-8 is the
+	* only code that seems to have wide use. It does detect that code.
+	*/
+	static function getCharset($tag) {
+
+		//According to iim standard, charset is defined by the tag 1:90.
+		//in which there are iso 2022 escape sequences to specify the character set.
+		//the iim standard seems to encourage that all necessary escape sequences are
+		//in the 1:90 tag, but says it doesn't have to be.
+
+		//This is in need of more testing probably. This is definitely not complete.
+		//however reading the docs of some other iptc software, it appears that most iptc software
+		//only recognizes utf-8. If 1:90 tag is not present content is
+		// usually ascii or iso-8859-1 (and sometimes utf-8), but no guarantee.
+
+		//This also won't work if there are more than one escape sequence in the 1:90 tag
+		//or if something is put in the G2, or G3 charsets, etc. It will only reliably recognize utf-8.
+
+		// This is just going through the charsets mentioned in appendix C of the iim standard.
+
+		//  \x1b = ESC.
+		switch ( $tag ) {
+			case "\x1b%G": //utf-8
+			//Also call things that are compatible with utf-8, utf-8 (e.g. ascii)
+			case "\x1b(B": // ascii
+			case "\x1b(@": // iso-646-IRV (ascii in latest version, $ different in older version)
+				$c = 'UTF-8';
+				break;
+			case "\x1b(A": //like ascii, but british.
+				$c = 'ISO646-GB';
+				break;
+			case "\x1b(C": //some obscure sweedish/finland encoding
+				$c = 'ISO-IR-8-1';
+				break;
+			case "\x1b(D":
+				$c = 'ISO-IR-8-2';
+				break;
+			case "\x1b(E": //some obscure danish/norway encoding
+				$c = 'ISO-IR-9-1';
+				break;
+			case "\x1b(F":
+				$c = 'ISO-IR-9-2';
+				break;
+			case "\x1b(G":
+				$c = 'SEN_850200_B'; // aka iso 646-SE; ascii-like
+				break;
+			case "\x1b(I":
+				$c = "ISO646-IT";
+				break;
+			case "\x1b(L":
+				$c = "ISO646-PT";
+				break;
+			case "\x1b(Z":
+				$c = "ISO646-ES";
+				break;
+			case "\x1b([":
+				$c = "GREEK7-OLD";
+				break;
+			case "\x1b(K":
+				$c = "ISO646-DE";
+				break;
+			case "\x1b(N":  //crylic
+				$c = "ISO_5427";
+				break;
+			case "\x1b(`": //iso646-NO
+				$c = "NS_4551-1";
+				break;
+			case "\x1b(f": //iso646-FR
+				$c = "NF_Z_62-010";
+				break;
+			case "\x1b(g":
+				$c = "PT2"; //iso646-PT2
+				break;
+			case "\x1b(h":
+				$c = "ES2";
+				break;
+			case "\x1b(i": //iso646-HU
+				$c = "MSZ_7795.3";
+				break;
+			case "\x1b(w":
+				$c = "CSA_Z243.4-1985-1";
+				break;
+			case "\x1b(x":
+				$c = "CSA_Z243.4-1985-2";
+				break;
+			case "\x1b\$(B":
+			case "\x1b\$B":
+			case "\x1b&@\x1b\$B":
+			case "\x1b&@\x1b\$(B":
+				$c = "JIS_C6226-1983";
+				break;
+			case "\x1b-A": // iso-8859-1. at least for the high code characters.
+			case "\x1b(@\x1b-A":
+			case "\x1b(B\x1b-A":
+				$c = 'ISO-8859-1';
+				break;
+			case "\x1b-B": // iso-8859-2. at least for the high code characters.
+				$c = 'ISO-8859-2';
+				break;
+			case "\x1b-C": // iso-8859-3. at least for the high code characters.
+				$c = 'ISO-8859-3';
+				break;
+			case "\x1b-D": // iso-8859-4. at least for the high code characters.
+				$c = 'ISO-8859-4';
+				break;
+			case "\x1b-E": // iso-8859-5. at least for the high code characters.
+				$c = 'ISO-8859-5';
+				break;
+			case "\x1b-F": // iso-8859-6. at least for the high code characters.
+				$c = 'ISO-8859-6';
+				break;
+			case "\x1b-G": // iso-8859-7. at least for the high code characters.
+				$c = 'ISO-8859-7';
+				break;
+			case "\x1b-H": // iso-8859-8. at least for the high code characters.
+				$c = 'ISO-8859-8';
+				break;
+			case "\x1b-I": // CSN_369103. at least for the high code characters.
+				$c = 'CSN_369103';
+				break;
+			default:
+				wfDebugLog('iptc', __METHOD__ . 'Unknown charset in iptc 1:90: ' . bin2hex( $tag ) );
+				//at this point just give up and refuse to parse iptc?
+				$c = false;
+		}
+		return $c;
+	}
+}
diff --git a/includes/media/Jpeg.php b/includes/media/Jpeg.php
new file mode 100644
index 00000000..7033409b
--- /dev/null
+++ b/includes/media/Jpeg.php
@@ -0,0 +1,46 @@
+<?php
+/**
+ * @file
+ * @ingroup Media
+ */
+
+/**
+ * JPEG specific handler.
+ * Inherits most stuff from BitmapHandler, just here to do the metadata handler differently.
+ *
+ * Metadata stuff common to Jpeg and built-in Tiff (not PagedTiffHandler) is
+ * in ExifBitmapHandler.
+ *
+ * @ingroup Media
+ */
+class JpegHandler extends ExifBitmapHandler {
+
+	function getMetadata ( $image, $filename ) {
+		try {
+			$meta = BitmapMetadataHandler::Jpeg( $filename );
+			if ( !is_array( $meta ) ) {
+				// This should never happen, but doesn't hurt to be paranoid.
+				throw new MWException('Metadata array is not an array');
+			}
+			$meta['MEDIAWIKI_EXIF_VERSION'] = Exif::version();
+			return serialize( $meta );
+		}
+		catch ( MWException $e ) {
+			// BitmapMetadataHandler throws an exception in certain exceptional cases like if file does not exist.
+			wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
+
+			/* This used to use 0 (ExifBitmapHandler::OLD_BROKEN_FILE) for the cases
+			 * 	* No metadata in the file
+			 * 	* Something is broken in the file.
+			 * However, if the metadata support gets expanded then you can't tell if the 0 is from
+			 * a broken file, or just no props found. A broken file is likely to stay broken, but
+			 * a file which had no props could have props once the metadata support is improved.
+			 * Thus switch to using -1 to denote only a broken file, and use an array with only
+			 * MEDIAWIKI_EXIF_VERSION to denote no props.
+			 */
+			return ExifBitmapHandler::BROKEN_FILE;
+		}
+	}
+
+}
+
diff --git a/includes/media/JpegMetadataExtractor.php b/includes/media/JpegMetadataExtractor.php
new file mode 100644
index 00000000..4769bf8e
--- /dev/null
+++ b/includes/media/JpegMetadataExtractor.php
@@ -0,0 +1,252 @@
+<?php
+/**
+* Class for reading jpegs and extracting metadata.
+* see also BitmapMetadataHandler.
+*
+* Based somewhat on GIFMetadataExtrator.
+*/
+class JpegMetadataExtractor {
+
+	const MAX_JPEG_SEGMENTS = 200;
+	// the max segment is a sanity check.
+	// A jpeg file should never even remotely have
+	// that many segments. Your average file has about 10.
+
+	/** Function to extract metadata segments of interest from jpeg files
+	* based on GIFMetadataExtractor.
+	*
+	* we can almost use getimagesize to do this
+	* but gis doesn't support having multiple app1 segments
+	* and those can't extract xmp on files containing both exif and xmp data
+	*
+	* @param String $filename name of jpeg file
+	* @return Array of interesting segments.
+	* @throws MWException if given invalid file.
+	*/
+	static function segmentSplitter ( $filename ) {
+		$showXMP = function_exists( 'xml_parser_create_ns' );
+
+		$segmentCount = 0;
+
+		$segments = array(
+			'XMP_ext' => array(),
+			'COM' => array(),
+		);
+
+		if ( !$filename ) {
+			throw new MWException( "No filename specified for " . __METHOD__ );
+		}
+		if ( !file_exists( $filename ) || is_dir( $filename ) ) {
+			throw new MWException( "Invalid file $filename passed to " . __METHOD__ );
+		}
+
+		$fh = fopen( $filename, "rb" );
+
+		if ( !$fh ) {
+			throw new MWException( "Could not open file $filename" );
+		}
+
+		$buffer = fread( $fh, 2 );
+		if ( $buffer !== "\xFF\xD8" ) {
+			throw new MWException( "Not a jpeg, no SOI" );
+		}
+		while ( !feof( $fh ) ) {
+			$buffer = fread( $fh, 1 );
+			$segmentCount++;
+			if ( $segmentCount > self::MAX_JPEG_SEGMENTS ) {
+				// this is just a sanity check
+				throw new MWException( 'Too many jpeg segments. Aborting' );
+			}
+			if ( $buffer !== "\xFF" ) {
+				throw new MWException( "Error reading jpeg file marker. Expected 0xFF but got " . bin2hex( $buffer ) );
+			}
+
+			$buffer = fread( $fh, 1 );
+			while( $buffer === "\xFF" && !feof( $fh ) ) {
+				// Skip through any 0xFF padding bytes.
+				$buffer = fread( $fh, 1 );
+			}
+			if ( $buffer === "\xFE" ) {
+
+				// COM section -- file comment
+				// First see if valid utf-8,
+				// if not try to convert it to windows-1252.
+				$com = $oldCom = trim( self::jpegExtractMarker( $fh ) );
+				UtfNormal::quickIsNFCVerify( $com );
+				// turns $com to valid utf-8.
+				// thus if no change, its utf-8, otherwise its something else.
+				if ( $com !== $oldCom ) {
+					wfSuppressWarnings();
+					$com = $oldCom = iconv( 'windows-1252', 'UTF-8//IGNORE', $oldCom );
+					wfRestoreWarnings();
+				}
+				// Try it again, if its still not a valid string, then probably
+				// binary junk or some really weird encoding, so don't extract.
+				UtfNormal::quickIsNFCVerify( $com );
+				if ( $com === $oldCom ) {
+					$segments["COM"][] = $oldCom;
+				} else {
+					wfDebug( __METHOD__ . ' Ignoring JPEG comment as is garbage.' );
+				}
+
+			} elseif ( $buffer === "\xE1" ) {
+				// APP1 section (Exif, XMP, and XMP extended)
+				// only extract if XMP is enabled.
+				$temp = self::jpegExtractMarker( $fh );
+				// check what type of app segment this is.
+				if ( substr( $temp, 0, 29 ) === "http://ns.adobe.com/xap/1.0/\x00" && $showXMP ) {
+					$segments["XMP"] = substr( $temp, 29 );
+				} elseif ( substr( $temp, 0, 35 ) === "http://ns.adobe.com/xmp/extension/\x00" && $showXMP ) {
+					$segments["XMP_ext"][] = substr( $temp, 35 );
+				} elseif ( substr( $temp, 0, 29 ) === "XMP\x00://ns.adobe.com/xap/1.0/\x00" && $showXMP ) {
+					// Some images (especially flickr images) seem to have this.
+					// I really have no idea what the deal is with them, but
+					// whatever...
+					$segments["XMP"] = substr( $temp, 29 );
+					wfDebug( __METHOD__ . ' Found XMP section with wrong app identifier '
+						. "Using anyways.\n" ); 
+				} elseif ( substr( $temp, 0, 6 ) === "Exif\0\0" ) {
+					// Just need to find out what the byte order is.
+					// because php's exif plugin sucks...
+					// This is a II for little Endian, MM for big. Not a unicode BOM.
+					$byteOrderMarker = substr( $temp, 6, 2 );
+					if ( $byteOrderMarker === 'MM' ) {
+						$segments['byteOrder'] = 'BE';
+					} elseif ( $byteOrderMarker === 'II' ) {
+						$segments['byteOrder'] = 'LE';
+					} else {
+						wfDebug( __METHOD__ . ' Invalid byte ordering?!' );
+					}
+				}
+			} elseif ( $buffer === "\xED" ) {
+				// APP13 - PSIR. IPTC and some photoshop stuff
+				$temp = self::jpegExtractMarker( $fh );
+				if ( substr( $temp, 0, 14 ) === "Photoshop 3.0\x00" ) {
+					$segments["PSIR"] = $temp;
+				}
+			} elseif ( $buffer === "\xD9" || $buffer === "\xDA" ) {
+				// EOI - end of image or SOS - start of scan. either way we're past any interesting segments
+				return $segments;
+			} else {
+				// segment we don't care about, so skip
+				$size = wfUnpack( "nint", fread( $fh, 2 ), 2 );
+				if ( $size['int'] <= 2 ) throw new MWException( "invalid marker size in jpeg" );
+				fseek( $fh, $size['int'] - 2, SEEK_CUR );
+			}
+
+		}
+		// shouldn't get here.
+		throw new MWException( "Reached end of jpeg file unexpectedly" );
+	}
+
+	/**
+	* Helper function for jpegSegmentSplitter
+	* @param &$fh FileHandle for jpeg file
+	* @return data content of segment.
+	*/
+	private static function jpegExtractMarker( &$fh ) {
+		$size = wfUnpack( "nint", fread( $fh, 2 ), 2 );
+		if ( $size['int'] <= 2 ) throw new MWException( "invalid marker size in jpeg" );
+		$segment = fread( $fh, $size['int'] - 2 );
+		if ( strlen( $segment ) !== $size['int'] - 2 ) throw new MWException( "Segment shorter than expected" );
+		return $segment;
+	}
+
+	/**
+	* This reads the photoshop image resource.
+	* Currently it only compares the iptc/iim hash
+	* with the stored hash, which is used to determine the precedence
+	* of the iptc data. In future it may extract some other info, like
+	* url of copyright license.
+	*
+	* This should generally be called by BitmapMetadataHandler::doApp13()
+	*
+	* @param String $app13 photoshop psir app13 block from jpg.
+	* @return String if the iptc hash is good or not.
+	*/
+	public static function doPSIR ( $app13 ) {
+		if ( !$app13 ) {
+			return;
+		}
+		// First compare hash with real thing
+		// 0x404 contains IPTC, 0x425 has hash
+		// This is used to determine if the iptc is newer than
+		// the xmp data, as xmp programs update the hash,
+		// where non-xmp programs don't.
+
+		$offset = 14; // skip past PHOTOSHOP 3.0 identifier. should already be checked.
+		$appLen = strlen( $app13 );
+		$realHash = "";
+		$recordedHash = "";
+
+		// the +12 is the length of an empty item.
+		while ( $offset + 12 <= $appLen ) {
+			$valid = true;
+			if ( substr( $app13, $offset, 4 ) !== '8BIM' ) {
+				// its supposed to be 8BIM
+				// but apparently sometimes isn't esp. in
+				// really old jpg's
+				$valid = false;
+			}
+			$offset += 4;
+			$id = substr( $app13, $offset, 2 );
+			// id is a 2 byte id number which identifies
+			// the piece of info this record contains.
+
+			$offset += 2;
+
+			// some record types can contain a name, which
+			// is a pascal string 0-padded to be an even
+			// number of bytes. Most times (and any time
+			// we care) this is empty, making it two null bytes.
+
+			$lenName = ord( substr( $app13, $offset, 1 ) ) + 1;
+			// we never use the name so skip it. +1 for length byte
+			if ( $lenName % 2 == 1 ) {
+				$lenName++;
+			} // pad to even.
+			$offset += $lenName;
+
+			// now length of data (unsigned long big endian)
+			$lenData = wfUnpack( 'Nlen', substr( $app13, $offset, 4 ), 4 );
+			// PHP can take issue with very large unsigned ints and make them negative.
+			// Which should never ever happen, as this has to be inside a segment
+			// which is limited to a 16 bit number.
+			if ( $lenData['len'] < 0 ) throw new MWException( "Too big PSIR (" . $lenData['len'] . ')' );
+
+			$offset += 4; // 4bytes length field;
+
+			// this should not happen, but check.
+			if ( $lenData['len'] + $offset > $appLen ) {
+				wfDebug( __METHOD__ . " PSIR data too long.\n" );
+				return 'iptc-no-hash';
+			}
+
+			if ( $valid ) {
+				switch ( $id ) {
+					case "\x04\x04":
+						// IPTC block
+						$realHash = md5( substr( $app13, $offset, $lenData['len'] ), true );
+						break;
+					case "\x04\x25":
+						$recordedHash = substr( $app13, $offset, $lenData['len'] );
+						break;
+				}
+			}
+
+			// if odd, add 1 to length to account for
+			// null pad byte.
+			if ( $lenData['len'] % 2 == 1 ) $lenData['len']++;
+			$offset += $lenData['len'];
+
+		}
+
+		if ( !$realHash || !$recordedHash ) {
+			return 'iptc-no-hash';
+		} elseif ( $realHash === $recordedHash ) {
+			return 'iptc-good-hash';
+		} else { /*$realHash !== $recordedHash */
+			return 'iptc-bad-hash';
+		}
+	}
+}
diff --git a/includes/media/MediaTransformOutput.php b/includes/media/MediaTransformOutput.php
index c441f06c..f170bb9d 100644
--- a/includes/media/MediaTransformOutput.php
+++ b/includes/media/MediaTransformOutput.php
@@ -12,7 +12,12 @@
  * @ingroup Media
  */
 abstract class MediaTransformOutput {
-	var $file, $width, $height, $url, $page, $path;
+	/**
+	 * @var File
+	 */
+	var $file;
+
+	var $width, $height, $url, $page, $path;
 
 	/**
 	 * Get the width of the output box
@@ -45,7 +50,7 @@ abstract class MediaTransformOutput {
 	/**
 	 * Fetch HTML for this transform output
 	 *
-	 * @param $options Associative array of options. Boolean options
+	 * @param $options array Associative array of options. Boolean options
 	 *     should be indicated with a value of true for true, and false or
 	 *     absent for false.
 	 *
@@ -73,6 +78,11 @@ abstract class MediaTransformOutput {
 
 	/**
 	 * Wrap some XHTML text in an anchor tag with the given attributes
+	 *
+	 * @param $linkAttribs array
+	 * @param $contents string
+	 *
+	 * @return string
 	 */
 	protected function linkWrap( $linkAttribs, $contents ) {
 		if ( $linkAttribs ) {
@@ -82,6 +92,11 @@ abstract class MediaTransformOutput {
 		}
 	}
 
+	/**
+	 * @param $title string
+	 * @param $params array
+	 * @return array
+	 */
 	function getDescLinkAttribs( $title = null, $params = '' ) {
 		$query = $this->page ? ( 'page=' . urlencode( $this->page ) ) : '';
 		if( $params ) {
@@ -98,7 +113,6 @@ abstract class MediaTransformOutput {
 	}
 }
 
-
 /**
  * Media transform output for images
  *
@@ -131,7 +145,7 @@ class ThumbnailImage extends MediaTransformOutput {
 	 * Return HTML <img ... /> tag for the thumbnail, will include
 	 * width and height attributes and a blank alt text (as required).
 	 *
-	 * @param $options Associative array of options. Boolean options
+	 * @param $options array Associative array of options. Boolean options
 	 *     should be indicated with a value of true for true, and false or
 	 *     absent for false.
 	 *
@@ -212,8 +226,8 @@ class MediaTransformError extends MediaTransformOutput {
 		$htmlArgs = array_map( 'htmlspecialchars', $args );
 		$htmlArgs = array_map( 'nl2br', $htmlArgs );
 
-		$this->htmlMsg = wfMsgReplaceArgs( htmlspecialchars( wfMsgGetKey( $msg, true ) ), $htmlArgs );
-		$this->textMsg = wfMsgReal( $msg, $args );
+		$this->htmlMsg = wfMessage( $msg )->rawParams( $htmlArgs )->escaped();
+		$this->textMsg = wfMessage( $msg )->rawParams( $htmlArgs )->text();
 		$this->width = intval( $width );
 		$this->height = intval( $height );
 		$this->url = false;
diff --git a/includes/media/PNG.php b/includes/media/PNG.php
index 5197282c..8fe9ecb4 100644
--- a/includes/media/PNG.php
+++ b/includes/media/PNG.php
@@ -12,26 +12,51 @@
  * @ingroup Media
  */
 class PNGHandler extends BitmapHandler {
-	
+
+	const BROKEN_FILE = '0';
+
+	/**
+	 * @param File $image
+	 * @param string $filename
+	 * @return string
+	 */
 	function getMetadata( $image, $filename ) {
-		if ( !isset($image->parsedPNGMetadata) ) {
-			try {
-				$image->parsedPNGMetadata = PNGMetadataExtractor::getMetadata( $filename );
-			} catch( Exception $e ) {
-				// Broken file?
-				wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
-				return '0';
-			}
+		try {
+			$metadata = BitmapMetadataHandler::PNG( $filename );
+		} catch( Exception $e ) {
+			// Broken file?
+			wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
+			return self::BROKEN_FILE;
 		}
 
-		return serialize($image->parsedPNGMetadata);
-
+		return serialize($metadata);
 	}
-	
+
+	/**
+	 * @param $image File
+	 * @return array|bool
+	 */
 	function formatMetadata( $image ) {
-		return false;
+		$meta = $image->getMetadata();
+
+		if ( !$meta ) {
+			return false;
+		}
+		$meta = unserialize( $meta );
+		if ( !isset( $meta['metadata'] ) || count( $meta['metadata'] ) <= 1 ) {
+			return false;
+		}
+
+		if ( isset( $meta['metadata']['_MW_PNG_VERSION'] ) ) {
+			unset( $meta['metadata']['_MW_PNG_VERSION'] );
+		}
+		return $this->formatMetadataHelper( $meta['metadata'] );
 	}
-	
+
+	/**
+	 * @param $image File
+	 * @return bool
+	 */
 	function isAnimatedImage( $image ) {
 		$ser = $image->getMetadata();
 		if ($ser) {
@@ -46,11 +71,33 @@ class PNGHandler extends BitmapHandler {
 	}
 	
 	function isMetadataValid( $image, $metadata ) {
+
+		if ( $metadata === self::BROKEN_FILE ) {
+			// Do not repetitivly regenerate metadata on broken file.
+			return self::METADATA_GOOD;
+		}
+
 		wfSuppressWarnings();
 		$data = unserialize( $metadata );
 		wfRestoreWarnings();
-		return (boolean) $data;
+
+		if ( !$data || !is_array( $data ) ) {
+			wfDebug(__METHOD__ . ' invalid png metadata' );
+			return self::METADATA_BAD;
+		}
+
+		if ( !isset( $data['metadata']['_MW_PNG_VERSION'] )
+			|| $data['metadata']['_MW_PNG_VERSION'] != PNGMetadataExtractor::VERSION ) {
+			wfDebug(__METHOD__ . ' old but compatible png metadata' );
+			return self::METADATA_COMPATIBLE;
+		}
+		return self::METADATA_GOOD;
 	}
+
+	/**
+	 * @param $image File
+	 * @return string
+	 */
 	function getLongDesc( $image ) {
 		global $wgLang;
 		$original = parent::getLongDesc( $image );
@@ -65,16 +112,19 @@ class PNGHandler extends BitmapHandler {
 		$info = array();
 		$info[] = $original;
 		
-		if ($metadata['loopCount'] == 0)
+		if ( $metadata['loopCount'] == 0 ) {
 			$info[] = wfMsgExt( 'file-info-png-looped', 'parseinline' );
-		elseif ($metadata['loopCount'] > 1)
+		} elseif ( $metadata['loopCount'] > 1 ) {
 			$info[] = wfMsgExt( 'file-info-png-repeat', 'parseinline', $metadata['loopCount'] );
+		}
 		
-		if ($metadata['frameCount'] > 0)
+		if ( $metadata['frameCount'] > 0 ) {
 			$info[] = wfMsgExt( 'file-info-png-frames', 'parseinline', $metadata['frameCount'] );
+		}
 		
-		if ($metadata['duration'])
+		if ( $metadata['duration'] ) {
 			$info[] = $wgLang->formatTimePeriod( $metadata['duration'] );
+		}
 		
 		return $wgLang->commaList( $info );
 	}
diff --git a/includes/media/PNGMetadataExtractor.php b/includes/media/PNGMetadataExtractor.php
index 6a931e6c..d3c44d4f 100644
--- a/includes/media/PNGMetadataExtractor.php
+++ b/includes/media/PNGMetadataExtractor.php
@@ -1,6 +1,6 @@
 <?php
 /**
- * PNG frame counter.
+ * PNG frame counter and metadata extractor.
  * Slightly derived from GIFMetadataExtractor.php
  * Deliberately not using MWExceptions to avoid external dependencies, encouraging
  * redistribution.
@@ -17,26 +17,61 @@
 class PNGMetadataExtractor {
 	static $png_sig;
 	static $CRC_size;
+	static $text_chunks;
+
+	const VERSION = 1;
+	const MAX_CHUNK_SIZE = 3145728; // 3 megabytes
 
 	static function getMetadata( $filename ) {
 		self::$png_sig = pack( "C8", 137, 80, 78, 71, 13, 10, 26, 10 );
 		self::$CRC_size = 4;
-		
+		/* based on list at http://owl.phy.queensu.ca/~phil/exiftool/TagNames/PNG.html#TextualData
+		 * and http://www.w3.org/TR/PNG/#11keywords
+		 */
+		self::$text_chunks = array(
+			'xml:com.adobe.xmp' => 'xmp',
+			# Artist is unofficial. Author is the recommended
+			# keyword in the PNG spec. However some people output
+			# Artist so support both.
+			'artist'      => 'Artist',
+			'model'       => 'Model',
+			'make'        => 'Make',
+			'author'      => 'Artist',
+			'comment'     => 'PNGFileComment',
+			'description' => 'ImageDescription',
+			'title'       => 'ObjectName',
+			'copyright'   => 'Copyright',
+			# Source as in original device used to make image
+			# not as in who gave you the image
+			'source'      => 'Model',
+			'software'    => 'Software',
+			'disclaimer'  => 'Disclaimer',
+			'warning'     => 'ContentWarning',
+			'url'         => 'Identifier', # Not sure if this is best mapping. Maybe WebStatement.
+			'label'       => 'Label',
+			'creation time' => 'DateTimeDigitized',
+			/* Other potentially useful things - Document */
+		);
+
 		$frameCount = 0;
 		$loopCount = 1;
+		$text = array();
 		$duration = 0.0;
+		$bitDepth = 0;
+		$colorType = 'unknown';
 
-		if (!$filename)
+		if ( !$filename ) {
 			throw new Exception( __METHOD__ . ": No file name specified" );
-		elseif ( !file_exists($filename) || is_dir($filename) )
+		} elseif ( !file_exists( $filename ) || is_dir( $filename ) ) {
 			throw new Exception( __METHOD__ . ": File $filename does not exist" );
-		
-		$fh = fopen( $filename, 'r' );
-		
-		if (!$fh) {
+		}
+
+		$fh = fopen( $filename, 'rb' );
+
+		if ( !$fh ) {
 			throw new Exception( __METHOD__ . ": Unable to open file $filename" );
 		}
-		
+
 		// Check for the PNG header
 		$buf = fread( $fh, 8 );
 		if ( $buf != self::$png_sig ) {
@@ -44,22 +79,54 @@ class PNGMetadataExtractor {
 		}
 
 		// Read chunks
-		while( !feof( $fh ) ) {
+		while ( !feof( $fh ) ) {
 			$buf = fread( $fh, 4 );
-			if( !$buf ) {
+			if ( !$buf || strlen( $buf ) < 4 ) {
 				throw new Exception( __METHOD__ . ": Read error" );
 			}
-			$chunk_size = unpack( "N", $buf);
+			$chunk_size = unpack( "N", $buf );
 			$chunk_size = $chunk_size[1];
 
+			if ( $chunk_size < 0 ) {
+				throw new Exception( __METHOD__ . ": Chunk size too big for unpack" );
+			}
+
 			$chunk_type = fread( $fh, 4 );
-			if( !$chunk_type ) {
+			if ( !$chunk_type || strlen( $chunk_type ) < 4 ) {
 				throw new Exception( __METHOD__ . ": Read error" );
 			}
 
-			if ( $chunk_type == "acTL" ) {
+			if ( $chunk_type == "IHDR" ) {
+				$buf = self::read( $fh, $chunk_size );
+				if ( !$buf || strlen( $buf ) < $chunk_size ) {
+					throw new Exception( __METHOD__ . ": Read error" );
+				}
+				$bitDepth = ord( substr( $buf, 8, 1 ) );
+				// Detect the color type in British English as per the spec
+				// http://www.w3.org/TR/PNG/#11IHDR
+				switch ( ord( substr( $buf, 9, 1 ) ) ) {
+					case 0:
+						$colorType = 'greyscale';
+						break;
+					case 2: 
+						$colorType = 'truecolour';
+						break;
+					case 3:
+						$colorType = 'index-coloured';
+						break;
+					case 4:
+						$colorType = 'greyscale-alpha';
+						break;
+					case 6:
+						$colorType = 'truecolour-alpha';
+						break;
+					default:
+						$colorType = 'unknown';
+						break;
+				}
+			} elseif ( $chunk_type == "acTL" ) {
 				$buf = fread( $fh, $chunk_size );
-				if( !$buf ) {
+				if( !$buf || strlen( $buf ) < $chunk_size || $chunk_size < 4 ) {
 					throw new Exception( __METHOD__ . ": Read error" );
 				}
 
@@ -67,20 +134,216 @@ class PNGMetadataExtractor {
 				$frameCount = $actl['frames'];
 				$loopCount = $actl['plays'];
 			} elseif ( $chunk_type == "fcTL" ) {
-				$buf = fread( $fh, $chunk_size );
-				if( !$buf ) {
+				$buf = self::read( $fh, $chunk_size );
+				if ( !$buf || strlen( $buf ) < $chunk_size ) {
+					throw new Exception( __METHOD__ . ": Read error" );
+				}
+				$buf = substr( $buf, 20 );
+				if ( strlen( $buf ) < 4 ) {
 					throw new Exception( __METHOD__ . ": Read error" );
 				}
-				$buf = substr( $buf, 20 );	
 
 				$fctldur = unpack( "ndelay_num/ndelay_den", $buf );
-				if( $fctldur['delay_den'] == 0 ) $fctldur['delay_den'] = 100;
-				if( $fctldur['delay_num'] ) {
+				if ( $fctldur['delay_den'] == 0 ) {
+					$fctldur['delay_den'] = 100;
+				}
+				if ( $fctldur['delay_num'] ) {
 					$duration += $fctldur['delay_num'] / $fctldur['delay_den'];
 				}
-			} elseif ( ( $chunk_type == "IDAT" || $chunk_type == "IEND" ) && $frameCount == 0 ) {
-				// Not a valid animated image. No point in continuing.
-				break;
+			} elseif ( $chunk_type == "iTXt" ) {
+				// Extracts iTXt chunks, uncompressing if necessary.
+				$buf = self::read( $fh, $chunk_size );
+				$items = array();
+				if ( preg_match(
+					'/^([^\x00]{1,79})\x00(\x00|\x01)\x00([^\x00]*)(.)[^\x00]*\x00(.*)$/Ds',
+					$buf, $items )
+				) {
+					/* $items[1] = text chunk name, $items[2] = compressed flag,
+					 * $items[3] = lang code (or ""), $items[4]= compression type.
+					 * $items[5] = content
+					 */
+
+					// Theoretically should be case-sensitive, but in practise...
+					$items[1] = strtolower( $items[1] );
+					if ( !isset( self::$text_chunks[$items[1]] ) ) {
+						// Only extract textual chunks on our list.
+						fseek( $fh, self::$CRC_size, SEEK_CUR );
+						continue;
+					}
+
+					$items[3] = strtolower( $items[3] );
+					if ( $items[3] == '' ) {
+						// if no lang specified use x-default like in xmp.
+						$items[3] = 'x-default';
+					}
+
+					// if compressed
+					if ( $items[2] == "\x01" ) {
+						if ( function_exists( 'gzuncompress' ) && $items[4] === "\x00" ) {
+							wfSuppressWarnings();
+							$items[5] = gzuncompress( $items[5] );
+							wfRestoreWarnings();
+
+							if ( $items[5] === false ) {
+								// decompression failed
+								wfDebug( __METHOD__ . ' Error decompressing iTxt chunk - ' . $items[1] );
+								fseek( $fh, self::$CRC_size, SEEK_CUR );
+								continue;
+							}
+
+						} else {
+							wfDebug( __METHOD__ . ' Skipping compressed png iTXt chunk due to lack of zlib,'
+								. ' or potentially invalid compression method' );
+							fseek( $fh, self::$CRC_size, SEEK_CUR );
+							continue;
+						}
+					}
+					$finalKeyword = self::$text_chunks[ $items[1] ];
+					$text[ $finalKeyword ][ $items[3] ] = $items[5];
+					$text[ $finalKeyword ]['_type'] = 'lang';
+
+				} else {
+					// Error reading iTXt chunk
+					throw new Exception( __METHOD__ . ": Read error on iTXt chunk" );
+				}
+
+			} elseif ( $chunk_type == 'tEXt' ) {
+				$buf = self::read( $fh, $chunk_size );
+
+				// In case there is no \x00 which will make explode fail.
+				if ( strpos( $buf, "\x00" ) === false ) {
+					throw new Exception( __METHOD__ . ": Read error on tEXt chunk" );
+				}
+
+				list( $keyword, $content ) = explode( "\x00", $buf, 2 );
+				if ( $keyword === '' || $content === '' ) {
+					throw new Exception( __METHOD__ . ": Read error on tEXt chunk" );
+				}
+
+				// Theoretically should be case-sensitive, but in practise...
+				$keyword = strtolower( $keyword );
+				if ( !isset( self::$text_chunks[ $keyword ] ) ) {
+					// Don't recognize chunk, so skip.
+					fseek( $fh, self::$CRC_size, SEEK_CUR );
+					continue;
+				}
+				wfSuppressWarnings();
+				$content = iconv( 'ISO-8859-1', 'UTF-8', $content );
+				wfRestoreWarnings();
+
+				if ( $content === false ) {
+					throw new Exception( __METHOD__ . ": Read error (error with iconv)" );
+				}
+
+				$finalKeyword = self::$text_chunks[ $keyword ];
+				$text[ $finalKeyword ][ 'x-default' ] = $content;
+				$text[ $finalKeyword ]['_type'] = 'lang';
+
+			} elseif ( $chunk_type == 'zTXt' ) {
+				if ( function_exists( 'gzuncompress' ) ) {
+					$buf = self::read( $fh, $chunk_size );
+
+					// In case there is no \x00 which will make explode fail.
+					if ( strpos( $buf, "\x00" ) === false ) {
+						throw new Exception( __METHOD__ . ": Read error on zTXt chunk" );
+					}
+
+					list( $keyword, $postKeyword ) = explode( "\x00", $buf, 2 );
+					if ( $keyword === '' || $postKeyword === '' ) {
+						throw new Exception( __METHOD__ . ": Read error on zTXt chunk" );
+					}
+					// Theoretically should be case-sensitive, but in practise...
+					$keyword = strtolower( $keyword );
+
+					if ( !isset( self::$text_chunks[ $keyword ] ) ) {
+						// Don't recognize chunk, so skip.
+						fseek( $fh, self::$CRC_size, SEEK_CUR );
+						continue;
+					}
+					$compression = substr( $postKeyword, 0, 1 );
+					$content = substr( $postKeyword, 1 );
+					if ( $compression !== "\x00" ) {
+						wfDebug( __METHOD__ . " Unrecognized compression method in zTXt ($keyword). Skipping." );
+						fseek( $fh, self::$CRC_size, SEEK_CUR );
+						continue;
+					}
+
+					wfSuppressWarnings();
+					$content = gzuncompress( $content );
+					wfRestoreWarnings();
+
+					if ( $content === false ) {
+						// decompression failed
+						wfDebug( __METHOD__ . ' Error decompressing zTXt chunk - ' . $keyword );
+						fseek( $fh, self::$CRC_size, SEEK_CUR );
+						continue;
+					}
+
+					wfSuppressWarnings();
+					$content = iconv( 'ISO-8859-1', 'UTF-8', $content );
+					wfRestoreWarnings();
+
+					if ( $content === false ) {
+						throw new Exception( __METHOD__ . ": Read error (error with iconv)" );
+					}
+
+					$finalKeyword = self::$text_chunks[ $keyword ];
+					$text[ $finalKeyword ][ 'x-default' ] = $content;
+					$text[ $finalKeyword ]['_type'] = 'lang';
+
+				} else {
+					wfDebug( __METHOD__ . " Cannot decompress zTXt chunk due to lack of zlib. Skipping." );
+					fseek( $fh, $chunk_size, SEEK_CUR );
+				}
+			} elseif ( $chunk_type == 'tIME' ) {
+				// last mod timestamp.
+				if ( $chunk_size !== 7 ) {
+					throw new Exception( __METHOD__ . ": tIME wrong size" );
+				}
+				$buf = self::read( $fh, $chunk_size );
+				if ( !$buf || strlen( $buf ) < $chunk_size ) {
+					throw new Exception( __METHOD__ . ": Read error" );
+				}
+
+				// Note: spec says this should be UTC.
+				$t = unpack( "ny/Cm/Cd/Ch/Cmin/Cs", $buf );
+				$strTime = sprintf( "%04d%02d%02d%02d%02d%02d",
+					$t['y'], $t['m'], $t['d'], $t['h'],
+					$t['min'], $t['s'] );
+
+				$exifTime = wfTimestamp( TS_EXIF, $strTime );
+
+				if ( $exifTime ) {
+					$text['DateTime'] = $exifTime;
+				}
+
+			} elseif ( $chunk_type == 'pHYs' ) {
+				// how big pixels are (dots per meter).
+				if ( $chunk_size !== 9 ) {
+					throw new Exception( __METHOD__ . ": pHYs wrong size" );
+				}
+
+				$buf = self::read( $fh, $chunk_size );
+				if ( !$buf || strlen( $buf ) < $chunk_size ) {
+					throw new Exception( __METHOD__ . ": Read error" );
+				}
+
+				$dim = unpack( "Nwidth/Nheight/Cunit", $buf );
+				if ( $dim['unit'] == 1 ) {
+					// Need to check for negative because php
+					// doesn't deal with super-large unsigned 32-bit ints well
+					if ( $dim['width'] > 0 && $dim['height'] > 0 ) {
+						// unit is meters
+						// (as opposed to 0 = undefined )
+						$text['XResolution'] = $dim['width']
+							. '/100';
+						$text['YResolution'] = $dim['height']
+							. '/100';
+						$text['ResolutionUnit'] = 3;
+						// 3 = dots per cm (from Exif).
+					}
+				}
+
 			} elseif ( $chunk_type == "IEND" ) {
 				break;
 			} else {
@@ -90,15 +353,59 @@ class PNGMetadataExtractor {
 		}
 		fclose( $fh );
 
-		if( $loopCount > 1 ) {
+		if ( $loopCount > 1 ) {
 			$duration *= $loopCount;
 		}
 
+		if ( isset( $text['DateTimeDigitized'] ) ) {
+			// Convert date format from rfc2822 to exif.
+			foreach ( $text['DateTimeDigitized'] as $name => &$value ) {
+				if ( $name === '_type' ) {
+					continue;
+				}
+
+				// @todo FIXME: Currently timezones are ignored.
+				// possibly should be wfTimestamp's
+				// responsibility. (at least for numeric TZ)
+				$formatted = wfTimestamp( TS_EXIF, $value );
+				if ( $formatted ) {
+					// Only change if we could convert the
+					// date.
+					// The png standard says it should be
+					// in rfc2822 format, but not required.
+					// In general for the exif stuff we
+					// prettify the date if we can, but we
+					// display as-is if we cannot or if
+					// it is invalid.
+					// So do the same here.
+
+					$value = $formatted;
+				}
+			}
+		}
 		return array(
 			'frameCount' => $frameCount,
 			'loopCount' => $loopCount,
-			'duration' => $duration
+			'duration' => $duration,
+			'text' => $text,
+			'bitDepth' => $bitDepth,
+			'colorType' => $colorType,
 		);
-		
+
+	}
+	/**
+	 * Read a chunk, checking to make sure its not too big.
+	 *
+	 * @param $fh resource The file handle
+	 * @param $size Integer size in bytes.
+	 * @throws Exception if too big.
+	 * @return String The chunk.
+	 */
+	static private function read( $fh, $size ) {
+		if ( $size > self::MAX_CHUNK_SIZE ) {
+			throw new Exception( __METHOD__ . ': Chunk size of ' . $size .
+				' too big. Max size is: ' . self::MAX_CHUNK_SIZE );
+		}
+		return fread( $fh, $size );
 	}
 }
diff --git a/includes/media/SVG.php b/includes/media/SVG.php
index a78be952..ceffd7c3 100644
--- a/includes/media/SVG.php
+++ b/includes/media/SVG.php
@@ -32,6 +32,10 @@ class SvgHandler extends ImageHandler {
 		return true;
 	}
 
+	/**
+	 * @param $file File
+	 * @return bool
+	 */
 	function isAnimatedImage( $file ) {
 		# TODO: detect animated SVGs
 		$metadata = $file->getMetadata();
@@ -44,14 +48,17 @@ class SvgHandler extends ImageHandler {
 		return false;
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $params
+	 * @return bool
+	 */
 	function normaliseParams( $image, &$params ) {
 		global $wgSVGMaxSize;
 		if ( !parent::normaliseParams( $image, $params ) ) {
 			return false;
 		}
 		# Don't make an image bigger than wgMaxSVGSize on the smaller side
-		$params['physicalWidth'] = $params['width'];
-		$params['physicalHeight'] = $params['height'];
 		if ( $params['physicalWidth'] <= $params['physicalHeight'] ) {
 			if ( $params['physicalWidth'] > $wgSVGMaxSize ) {
 				$srcWidth = $image->getWidth( $params['page'] );
@@ -70,6 +77,14 @@ class SvgHandler extends ImageHandler {
 		return true;
 	}
 
+	/**
+	 * @param $image File
+	 * @param  $dstPath
+	 * @param  $dstUrl
+	 * @param  $params
+	 * @param int $flags
+	 * @return bool|MediaTransformError|ThumbnailImage|TransformParameterError
+	 */
 	function doTransform( $image, $dstPath, $dstUrl, $params, $flags = 0 ) {
 		if ( !$this->normaliseParams( $image, $params ) ) {
 			return new TransformParameterError( $params );
@@ -97,7 +112,7 @@ class SvgHandler extends ImageHandler {
 		}
 	}
 
-	/*
+	/**
 	* Transform an SVG file to PNG
 	* This function can be called outside of thumbnail contexts
 	* @param string $srcPath
@@ -111,19 +126,32 @@ class SvgHandler extends ImageHandler {
 		$err = false;
 		$retval = '';
 		if ( isset( $wgSVGConverters[$wgSVGConverter] ) ) {
-			$cmd = str_replace(
-				array( '$path/', '$width', '$height', '$input', '$output' ),
-				array( $wgSVGConverterPath ? wfEscapeShellArg( "$wgSVGConverterPath/" ) : "",
-					   intval( $width ),
-					   intval( $height ),
-					   wfEscapeShellArg( $srcPath ),
-					   wfEscapeShellArg( $dstPath ) ),
-				$wgSVGConverters[$wgSVGConverter]
-			) . " 2>&1";
-			wfProfileIn( 'rsvg' );
-			wfDebug( __METHOD__.": $cmd\n" );
-			$err = wfShellExec( $cmd, $retval );
-			wfProfileOut( 'rsvg' );
+			if ( is_array( $wgSVGConverters[$wgSVGConverter] ) ) {
+				// This is a PHP callable
+				$func = $wgSVGConverters[$wgSVGConverter][0];
+				$args = array_merge( array( $srcPath, $dstPath, $width, $height ), 
+					array_slice( $wgSVGConverters[$wgSVGConverter], 1 ) );
+				if ( !is_callable( $func ) ) {
+					throw new MWException( "$func is not callable" );
+				}
+				$err = call_user_func_array( $func, $args );
+				$retval = (bool)$err;
+			} else {
+				// External command
+				$cmd = str_replace(
+					array( '$path/', '$width', '$height', '$input', '$output' ),
+					array( $wgSVGConverterPath ? wfEscapeShellArg( "$wgSVGConverterPath/" ) : "",
+						   intval( $width ),
+						   intval( $height ),
+						   wfEscapeShellArg( $srcPath ),
+						   wfEscapeShellArg( $dstPath ) ),
+					$wgSVGConverters[$wgSVGConverter]
+				) . " 2>&1";
+				wfProfileIn( 'rsvg' );
+				wfDebug( __METHOD__.": $cmd\n" );
+				$err = wfShellExec( $cmd, $retval );
+				wfProfileOut( 'rsvg' );
+			}
 		}
 		$removed = $this->removeBadFile( $dstPath, $retval );
 		if ( $retval != 0 || $removed ) {
@@ -133,7 +161,27 @@ class SvgHandler extends ImageHandler {
 		}
 		return true;
 	}
+	
+	public static function rasterizeImagickExt( $srcPath, $dstPath, $width, $height ) {
+		$im = new Imagick( $srcPath );
+		$im->setImageFormat( 'png' );
+		$im->setBackgroundColor( 'transparent' );
+		$im->setImageDepth( 8 );
+		
+		if ( !$im->thumbnailImage( intval( $width ), intval( $height ), /* fit */ false ) ) {
+			return 'Could not resize image';
+		}
+		if ( !$im->writeImage( $dstPath ) ) {
+			return "Could not write to $dstPath";
+		}
+	}
 
+	/**
+	 * @param $file File
+	 * @param  $path
+	 * @param bool $metadata
+	 * @return array
+	 */
 	function getImageSize( $file, $path, $metadata = false ) {
 		if ( $metadata === false ) {
 			$metadata = $file->getMetaData();
@@ -150,6 +198,10 @@ class SvgHandler extends ImageHandler {
 		return array( 'png', 'image/png' );
 	}
 
+	/**
+	 * @param $file File
+	 * @return string
+	 */
 	function getLongDesc( $file ) {
 		global $wgLang;
 		return wfMsgExt( 'svg-long-desc', 'parseinline',
@@ -171,7 +223,9 @@ class SvgHandler extends ImageHandler {
 	}
 
 	function unpackMetadata( $metadata ) {
-		$unser = @unserialize( $metadata );
+		wfSuppressWarnings();
+		$unser = unserialize( $metadata );
+		wfRestoreWarnings();
 		if ( isset( $unser['version'] ) && $unser['version'] == self::SVG_METADATA_VERSION ) {
 			return $unser;
 		} else {
@@ -192,6 +246,10 @@ class SvgHandler extends ImageHandler {
 		return $fields;
 	}
 
+	/**
+	 * @param $file File
+	 * @return array|bool
+	 */
 	function formatMetadata( $file ) {
 		$result = array(
 			'visible' => array(),
diff --git a/includes/media/SVGMetadataExtractor.php b/includes/media/SVGMetadataExtractor.php
index 66ae1edf..22ef8e61 100644
--- a/includes/media/SVGMetadataExtractor.php
+++ b/includes/media/SVGMetadataExtractor.php
@@ -55,7 +55,7 @@ class SVGReader {
 		$size = filesize( $source );
 		if ( $size === false ) {
 			throw new MWException( "Error getting filesize of SVG." );
-		} 
+		}
 
 		if ( $size > $wgSVGMetadataCutoff ) {
 			$this->debug( "SVG is $size bytes, which is bigger than $wgSVGMetadataCutoff. Truncating." );
@@ -84,14 +84,14 @@ class SVGReader {
 		wfRestoreWarnings();
 	}
 
-	/*
+	/**
 	 * @return Array with the known metadata
 	 */
 	public function getMetadata() {
 		return $this->metadata;
 	}
 
-	/*
+	/**
 	 * Read the SVG
 	 */
 	public function read() {
@@ -139,10 +139,12 @@ class SVGReader {
 			$keepReading = $this->reader->next();
 		}
 
+		$this->reader->close();
+
 		return true;
 	}
 
-	/*
+	/**
 	 * Read a textelement from an element
 	 *
 	 * @param String $name of the element that we are reading from
@@ -155,7 +157,7 @@ class SVGReader {
 		}
 		$keepReading = $this->reader->read();
 		while( $keepReading ) {
-			if( $this->reader->localName == $name && $this->namespaceURI == self::NS_SVG && $this->reader->nodeType == XmlReader::END_ELEMENT ) {
+			if( $this->reader->localName == $name && $this->reader->namespaceURI == self::NS_SVG && $this->reader->nodeType == XmlReader::END_ELEMENT ) {
 				break;
 			} elseif( $this->reader->nodeType == XmlReader::TEXT ){
 				$this->metadata[$metafield] = trim( $this->reader->value );
@@ -175,20 +177,27 @@ class SVGReader {
 			return;
 		}
 		// TODO: find and store type of xml snippet. metadata['metadataType'] = "rdf"
-		$this->metadata[$metafield] = trim( $this->reader->readInnerXML() );
+		if( method_exists( $this->reader, 'readInnerXML' ) ) {
+			$this->metadata[$metafield] = trim( $this->reader->readInnerXML() );
+		} else {
+			throw new MWException( "The PHP XMLReader extension does not come with readInnerXML() method. Your libxml is probably out of date (need 2.6.20 or later)." );
+		}
 		$this->reader->next();
 	}
 
-	/*
+	/**
 	 * Filter all children, looking for animate elements
 	 *
 	 * @param String $name of the element that we are reading from
 	 */
 	private function animateFilter( $name ) {
-		$this->debug ( "animate filter" );
+		$this->debug ( "animate filter for tag $name" );
 		if( $this->reader->nodeType != XmlReader::ELEMENT ) {
 			return;
 		}
+		if ( $this->reader->isEmptyElement ) {
+			return;
+		}
 		$exitDepth =  $this->reader->depth;
 		$keepReading = $this->reader->read();
 		while( $keepReading ) {
@@ -230,7 +239,7 @@ class SVGReader {
 		wfDebug( "SVGReader WARN: $data\n" );
 	}
 
-	/*
+	/**
 	 * Parse the attributes of an SVG element
 	 *
 	 * The parser has to be in the start element of <svg>
diff --git a/includes/media/Tiff.php b/includes/media/Tiff.php
index 8773201f..0f317e1a 100644
--- a/includes/media/Tiff.php
+++ b/includes/media/Tiff.php
@@ -11,27 +11,74 @@
  *
  * @ingroup Media
  */
-class TiffHandler extends BitmapHandler {
+class TiffHandler extends ExifBitmapHandler {
 
 	/**
 	 * Conversion to PNG for inline display can be disabled here...
 	 * Note scaling should work with ImageMagick, but may not with GD scaling.
+	 *
+	 * Files pulled from an another MediaWiki instance via ForeignAPIRepo /
+	 * InstantCommons will have thumbnails managed from the remote instance,
+	 * so we can skip this check.
+	 *
+	 * @param $file
+	 *
+	 * @return bool
 	 */
 	function canRender( $file ) {
 		global $wgTiffThumbnailType;
-		return (bool)$wgTiffThumbnailType;
+		return (bool)$wgTiffThumbnailType
+			|| ($file->getRepo() instanceof ForeignAPIRepo);
 	}
 
 	/**
 	 * Browsers don't support TIFF inline generally...
 	 * For inline display, we need to convert to PNG.
+	 *
+	 * @param $file
+	 *
+	 * @return bool
 	 */
 	function mustRender( $file ) {
 		return true;
 	}
 
+	/**
+	 * @param $ext
+	 * @param $mime
+	 * @param $params
+	 * @return bool
+	 */
 	function getThumbType( $ext, $mime, $params = null ) {
 		global $wgTiffThumbnailType;
 		return $wgTiffThumbnailType;
 	}
+
+	/**
+	 * @param $image
+	 * @param $filename
+	 * @return string
+	 */
+	function getMetadata( $image, $filename ) {
+		global $wgShowEXIF;
+		if ( $wgShowEXIF ) {
+			try {
+				$meta = BitmapMetadataHandler::Tiff( $filename );
+				if ( !is_array( $meta ) ) {
+					// This should never happen, but doesn't hurt to be paranoid.
+					throw new MWException('Metadata array is not an array');
+				}
+				$meta['MEDIAWIKI_EXIF_VERSION'] = Exif::version();
+				return serialize( $meta );
+			}
+			catch ( MWException $e ) {
+				// BitmapMetadataHandler throws an exception in certain exceptional
+				// cases like if file does not exist.
+				wfDebug( __METHOD__ . ': ' . $e->getMessage() . "\n" );
+				return ExifBitmapHandler::BROKEN_FILE;
+			}
+		} else {
+			return '';
+		}
+	}
 }
diff --git a/includes/media/XMP.php b/includes/media/XMP.php
new file mode 100644
index 00000000..1e578582
--- /dev/null
+++ b/includes/media/XMP.php
@@ -0,0 +1,1174 @@
+<?php
+/**
+* Class for reading xmp data containing properties relevant to
+* images, and spitting out an array that FormatExif accepts.
+*
+* Note, this is not meant to recognize every possible thing you can
+* encode in XMP. It should recognize all the properties we want.
+* For example it doesn't have support for structures with multiple
+* nesting levels, as none of the properties we're supporting use that
+* feature. If it comes across properties it doesn't recognize, it should
+* ignore them.
+*
+* The public methods one would call in this class are
+* - parse( $content )
+*	Reads in xmp content.
+*	Can potentially be called multiple times with partial data each time.
+* - parseExtended( $content )
+*	Reads XMPExtended blocks (jpeg files only).
+* - getResults
+*	Outputs a results array.
+*
+* Note XMP kind of looks like rdf. They are not the same thing - XMP is
+* encoded as a specific subset of rdf. This class can read XMP. It cannot
+* read rdf.
+*
+*/
+class XMPReader {
+
+	private $curItem = array();        // array to hold the current element (and previous element, and so on)
+	private $ancestorStruct = false;   // the structure name when processing nested structures.
+	private $charContent = false;      // temporary holder for character data that appears in xmp doc.
+	private $mode = array();           // stores the state the xmpreader is in (see MODE_FOO constants)
+	private $results = array();        // array to hold results
+	private $processingArray = false;  // if we're doing a seq or bag.
+	private $itemLang = false;         // used for lang alts only
+
+	private $xmlParser;
+	private $charset = false;
+	private $extendedXMPOffset = 0;
+
+	protected $items;
+
+	/**
+	* These are various mode constants.
+	* they are used to figure out what to do
+	* with an element when its encountered.
+	*
+	* For example, MODE_IGNORE is used when processing
+	* a property we're not interested in. So if a new
+	* element pops up when we're in that mode, we ignore it.
+	*/
+	const MODE_INITIAL = 0;
+	const MODE_IGNORE  = 1;
+	const MODE_LI      = 2;
+	const MODE_LI_LANG = 3;
+	const MODE_QDESC   = 4;
+
+	// The following MODE constants are also used in the
+	// $items array to denote what type of property the item is.
+	const MODE_SIMPLE    = 10;
+	const MODE_STRUCT    = 11; // structure (associative array)
+	const MODE_SEQ       = 12; // ordered list
+	const MODE_BAG       = 13; // unordered list
+	const MODE_LANG      = 14;
+	const MODE_ALT       = 15; // non-language alt. Currently not implemented, and not needed atm.
+	const MODE_BAGSTRUCT = 16; // A BAG of Structs.
+
+	const NS_RDF = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#';
+	const NS_XML = 'http://www.w3.org/XML/1998/namespace';
+
+
+	/**
+	* Constructor.
+	*
+	* Primary job is to initialize the XMLParser
+	*/
+	function __construct() {
+
+		if ( !function_exists( 'xml_parser_create_ns' ) ) {
+			// this should already be checked by this point
+			throw new MWException( 'XMP support requires XML Parser' );
+		}
+
+		$this->items = XMPInfo::getItems();
+
+		$this->resetXMLParser();
+
+	}
+	/**
+	* Main use is if a single item has multiple xmp documents describing it.
+	* For example in jpeg's with extendedXMP
+	*/
+	private function resetXMLParser() {
+
+		if ($this->xmlParser) {
+			//is this needed?
+			xml_parser_free( $this->xmlParser );
+		}
+
+		$this->xmlParser = xml_parser_create_ns( 'UTF-8', ' ' );
+		xml_parser_set_option( $this->xmlParser, XML_OPTION_CASE_FOLDING, 0 );
+		xml_parser_set_option( $this->xmlParser, XML_OPTION_SKIP_WHITE, 1 );
+
+		xml_set_element_handler( $this->xmlParser,
+			array( $this, 'startElement' ),
+			array( $this, 'endElement' ) );
+
+		xml_set_character_data_handler( $this->xmlParser, array( $this, 'char' ) );
+	}
+
+	/** Destroy the xml parser
+	*
+	* Not sure if this is actually needed.
+	*/
+	function __destruct() {
+		// not sure if this is needed.
+		xml_parser_free( $this->xmlParser );
+	}
+
+	/** Get the result array. Do some post-processing before returning
+	* the array, and transform any metadata that is special-cased.
+	*
+	* @return Array array of results as an array of arrays suitable for
+	*	FormatMetadata::getFormattedData().
+	*/
+	public function getResults() {
+		// xmp-special is for metadata that affects how stuff
+		// is extracted. For example xmpNote:HasExtendedXMP.
+
+		// It is also used to handle photoshop:AuthorsPosition
+		// which is weird and really part of another property,
+		// see 2:85 in IPTC. See also pg 21 of IPTC4XMP standard.
+		// The location fields also use it.
+
+		$data = $this->results;
+
+		wfRunHooks('XMPGetResults', Array(&$data));
+
+		if ( isset( $data['xmp-special']['AuthorsPosition'] )
+			&& is_string( $data['xmp-special']['AuthorsPosition'] )
+			&& isset( $data['xmp-general']['Artist'][0] )
+		) {
+			// Note, if there is more than one creator,
+			// this only applies to first. This also will
+			// only apply to the dc:Creator prop, not the
+			// exif:Artist prop.
+
+			$data['xmp-general']['Artist'][0] =
+				$data['xmp-special']['AuthorsPosition'] . ', '
+				. $data['xmp-general']['Artist'][0];
+		}
+
+		// Go through the LocationShown and LocationCreated
+		// changing it to the non-hierarchal form used by
+		// the other location fields.
+
+		if ( isset( $data['xmp-special']['LocationShown'][0] )
+			&& is_array( $data['xmp-special']['LocationShown'][0] )
+		) {
+			// the is_array is just paranoia. It should always
+			// be an array.
+			foreach( $data['xmp-special']['LocationShown'] as $loc ) {
+				if ( !is_array( $loc ) ) {
+					// To avoid copying over the _type meta-fields.
+					continue;
+				}
+				foreach( $loc as $field => $val ) {
+					$data['xmp-general'][$field . 'Dest'][] = $val;
+				}
+			}
+		}
+		if ( isset( $data['xmp-special']['LocationCreated'][0] )
+			&& is_array( $data['xmp-special']['LocationCreated'][0] )
+		) {
+			// the is_array is just paranoia. It should always
+			// be an array.
+			foreach( $data['xmp-special']['LocationCreated'] as $loc ) {
+				if ( !is_array( $loc ) ) {
+					// To avoid copying over the _type meta-fields.
+					continue;
+				}
+				foreach(  $loc as $field => $val ) {
+					$data['xmp-general'][$field . 'Created'][] = $val;
+				}
+			}
+		}
+
+
+		// We don't want to return the special values, since they're
+		// special and not info to be stored about the file.
+		unset( $data['xmp-special'] );
+
+		// Convert GPSAltitude to negative if below sea level.
+		if ( isset( $data['xmp-exif']['GPSAltitudeRef'] ) ) {
+			if ( $data['xmp-exif']['GPSAltitudeRef'] == '1'
+				&& isset( $data['xmp-exif']['GPSAltitude'] )
+			) {
+				$data['xmp-exif']['GPSAltitude'] *= -1;
+			}
+			unset( $data['xmp-exif']['GPSAltitudeRef'] );
+		}
+
+		return $data;
+	}
+
+	/**
+	* Main function to call to parse XMP. Use getResults to
+	* get results.
+	*
+	* Also catches any errors during processing, writes them to
+	* debug log, blanks result array and returns false.
+	*
+	* @param String: $content XMP data
+	* @param Boolean: $allOfIt If this is all the data (true) or if its split up (false). Default true
+	* @param Boolean: $reset - does xml parser need to be reset. Default false
+	* @return Boolean success.
+	*/
+	public function parse( $content, $allOfIt = true, $reset = false ) {
+		if ( $reset ) {
+			$this->resetXMLParser();
+		}
+		try {
+
+			// detect encoding by looking for BOM which is supposed to be in processing instruction.
+			// see page 12 of http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart3.pdf
+			if ( !$this->charset ) {
+				$bom = array();
+				if ( preg_match( '/\xEF\xBB\xBF|\xFE\xFF|\x00\x00\xFE\xFF|\xFF\xFE\x00\x00|\xFF\xFE/',
+					 $content, $bom )
+				) {
+					switch ( $bom[0] ) {
+						case "\xFE\xFF":
+							$this->charset = 'UTF-16BE';
+							break;
+						case "\xFF\xFE":
+							$this->charset = 'UTF-16LE';
+							break;
+						case "\x00\x00\xFE\xFF":
+							$this->charset = 'UTF-32BE';
+							break;
+						case "\xFF\xFE\x00\x00":
+							$this->charset = 'UTF-32LE';
+							break;
+						case "\xEF\xBB\xBF":
+							$this->charset = 'UTF-8';
+							break;
+						default:
+							//this should be impossible to get to
+							throw new MWException("Invalid BOM");
+							break;
+
+					}
+
+				} else {
+					// standard specifically says, if no bom assume utf-8
+					$this->charset = 'UTF-8';
+				}
+			}
+			if ( $this->charset !== 'UTF-8' ) {
+				//don't convert if already utf-8
+				wfSuppressWarnings();
+				$content = iconv( $this->charset, 'UTF-8//IGNORE', $content );
+				wfRestoreWarnings();
+			}
+
+			$ok = xml_parse( $this->xmlParser, $content, $allOfIt );
+			if ( !$ok ) {
+				$error = xml_error_string( xml_get_error_code( $this->xmlParser ) );
+				$where = 'line: ' . xml_get_current_line_number( $this->xmlParser )
+					. ' column: ' . xml_get_current_column_number( $this->xmlParser )
+					. ' byte offset: ' . xml_get_current_byte_index( $this->xmlParser );
+
+				wfDebugLog( 'XMP', "XMPReader::parse : Error reading XMP content: $error ($where)" );
+				$this->results = array(); // blank if error.
+				return false;
+			}
+		} catch ( MWException $e ) {
+			wfDebugLog( 'XMP', 'XMP parse error: ' . $e );
+			$this->results = array();
+			return false;
+		}
+		return true;
+	}
+
+	/** Entry point for XMPExtended blocks in jpeg files
+	 *
+	 * @todo In serious need of testing
+	 * @see http://www.adobe.ge/devnet/xmp/pdfs/XMPSpecificationPart3.pdf XMP spec part 3 page 20
+	 * @param String $content XMPExtended block minus the namespace signature
+	 * @return Boolean If it succeeded.
+	 */
+	public function parseExtended( $content ) {
+		// @todo FIXME: This is untested. Hard to find example files
+		// or programs that make such files..
+		$guid = substr( $content, 0, 32 );
+		if ( !isset( $this->results['xmp-special']['HasExtendedXMP'] )
+			|| $this->results['xmp-special']['HasExtendedXMP'] !== $guid ) {
+			wfDebugLog('XMP', __METHOD__ . " Ignoring XMPExtended block due to wrong guid (guid= '$guid' )");
+			return false;
+		}
+		$len  = unpack( 'Nlength/Noffset', substr( $content, 32, 8 ) );
+
+		if (!$len || $len['length'] < 4 || $len['offset'] < 0 || $len['offset'] > $len['length'] ) {
+			wfDebugLog('XMP', __METHOD__ . 'Error reading extended XMP block, invalid length or offset.');
+			return false;
+		}
+
+
+		// we're not very robust here. we should accept it in the wrong order. To quote
+		// the xmp standard:
+		// "A JPEG writer should write the ExtendedXMP marker segments in order, immediately following the
+		// StandardXMP. However, the JPEG standard does not require preservation of marker segment order. A
+		// robust JPEG reader should tolerate the marker segments in any order."
+		//
+		// otoh the probability that an image will have more than 128k of metadata is rather low...
+		// so the probability that it will have > 128k, and be in the wrong order is very low...
+
+		if ( $len['offset'] !== $this->extendedXMPOffset ) {
+			wfDebugLog('XMP', __METHOD__ . 'Ignoring XMPExtended block due to wrong order. (Offset was '
+				. $len['offset'] . ' but expected ' . $this->extendedXMPOffset . ')');
+			return false;
+		}
+
+		if ( $len['offset'] === 0 ) {
+			// if we're starting the extended block, we've probably already
+			// done the XMPStandard block, so reset.
+			$this->resetXMLParser();
+		}
+
+		$this->extendedXMPOffset += $len['length'];
+
+		$actualContent = substr( $content, 40 );
+
+		if ( $this->extendedXMPOffset === strlen( $actualContent ) ) {
+			$atEnd = true;
+		} else {
+			$atEnd = false;
+		}
+
+		wfDebugLog('XMP', __METHOD__ . 'Parsing a XMPExtended block');
+		return $this->parse( $actualContent, $atEnd );
+	}
+
+	/**
+	* Character data handler
+	* Called whenever character data is found in the xmp document.
+	*
+	* does nothing if we're in MODE_IGNORE or if the data is whitespace
+	* throws an error if we're not in MODE_SIMPLE (as we're not allowed to have character
+	* data in the other modes).
+	*
+	* As an example, this happens when we encounter XMP like:
+	* <exif:DigitalZoomRatio>0/10</exif:DigitalZoomRatio>
+	* and are processing the 0/10 bit.
+	*
+	* @param $parser XMLParser reference to the xml parser
+	* @param $data String Character data
+	* @throws MWException on invalid data
+	*/
+	function char( $parser, $data ) {
+
+		$data = trim( $data );
+		if ( trim( $data ) === "" ) {
+			return;
+		}
+
+		if ( !isset( $this->mode[0] ) ) {
+			throw new MWException( 'Unexpected character data before first rdf:Description element' );
+		}
+
+		if ( $this->mode[0] === self::MODE_IGNORE ) return;
+
+		if ( $this->mode[0] !== self::MODE_SIMPLE
+			&& $this->mode[0] !== self::MODE_QDESC
+		) {
+			throw new MWException( 'character data where not expected. (mode ' . $this->mode[0] . ')' );
+		}
+
+		// to check, how does this handle w.s.
+		if ( $this->charContent === false ) {
+			$this->charContent = $data;
+		} else {
+			$this->charContent .= $data;
+		}
+
+	}
+
+	/** When we hit a closing element in MODE_IGNORE
+	* Check to see if this is the element we started to ignore,
+	* in which case we get out of MODE_IGNORE
+	*
+	* @param $elm String Namespace of element followed by a space and then tag name of element.
+	*/
+	private function endElementModeIgnore ( $elm ) {
+
+		if ( $this->curItem[0] === $elm ) {
+			array_shift( $this->curItem );
+			array_shift( $this->mode );
+		}
+		return;
+
+	}
+
+	/**
+	* Hit a closing element when in MODE_SIMPLE.
+	* This generally means that we finished processing a
+	* property value, and now have to save the result to the
+	* results array
+	*
+	* For example, when processing:
+	* <exif:DigitalZoomRatio>0/10</exif:DigitalZoomRatio>
+	* this deals with when we hit </exif:DigitalZoomRatio>.
+	*
+	* Or it could be if we hit the end element of a property
+	* of a compound data structure (like a member of an array).
+	*
+	* @param $elm String namespace, space, and tag name.
+	*/
+	private function endElementModeSimple ( $elm ) {
+		if ( $this->charContent !== false ) {
+			if ( $this->processingArray ) {
+				// if we're processing an array, use the original element
+				// name instead of rdf:li.
+				list( $ns, $tag ) = explode( ' ', $this->curItem[0], 2 );
+			} else {
+				list( $ns, $tag ) = explode( ' ', $elm, 2 );
+			}
+			$this->saveValue( $ns, $tag, $this->charContent );
+
+			$this->charContent = false; // reset
+		}
+		array_shift( $this->curItem );
+		array_shift( $this->mode );
+
+	}
+
+	/**
+	* Hit a closing element in MODE_STRUCT, MODE_SEQ, MODE_BAG
+	* generally means we've finished processing a nested structure.
+	* resets some internal variables to indicate that.
+	*
+	* Note this means we hit the </closing element> not the </rdf:Seq>.
+	*
+	* For example, when processing:
+	* <exif:ISOSpeedRatings> <rdf:Seq> <rdf:li>64</rdf:li>
+	*   </rdf:Seq> </exif:ISOSpeedRatings>
+	*
+	* This method is called when we hit the </exif:ISOSpeedRatings> tag.
+	*
+	* @param $elm String namespace . space . tag name.
+	*/
+	private function endElementNested( $elm ) {
+
+		/* cur item must be the same as $elm, unless if in MODE_STRUCT
+		   in which case it could also be rdf:Description */
+		if ( $this->curItem[0] !== $elm
+			&& !( $elm === self::NS_RDF . ' Description'
+				&& $this->mode[0] === self::MODE_STRUCT )
+		 ) {
+			throw new MWException( "nesting mismatch. got a </$elm> but expected a </" . $this->curItem[0] . '>' );
+		}
+
+		// Validate structures.
+		list( $ns, $tag ) = explode( ' ', $elm, 2 );
+		if ( isset( $this->items[$ns][$tag]['validate'] ) ) {
+
+			$info =& $this->items[$ns][$tag];
+			$finalName = isset( $info['map_name'] )
+				? $info['map_name'] : $tag;
+
+			$validate = is_array( $info['validate'] ) ? $info['validate']
+				: array( 'XMPValidate', $info['validate'] );
+
+			if ( !isset( $this->results['xmp-' . $info['map_group']][$finalName] ) ) {
+				// This can happen if all the members of the struct failed validation.
+				wfDebugLog( 'XMP', __METHOD__ . " <$ns:$tag> has no valid members." );
+
+			} elseif ( is_callable( $validate ) ) {
+				$val =& $this->results['xmp-' . $info['map_group']][$finalName];
+				call_user_func_array( $validate, array( $info, &$val, false ) );
+				if ( is_null( $val ) ) {
+					// the idea being the validation function will unset the variable if
+					// its invalid.
+					wfDebugLog( 'XMP', __METHOD__ . " <$ns:$tag> failed validation." );
+					unset( $this->results['xmp-' . $info['map_group']][$finalName] );
+				}
+			} else {
+				wfDebugLog( 'XMP', __METHOD__ . " Validation function for $finalName ("
+					. $validate[0] . '::' . $validate[1] . '()) is not callable.' );
+			}
+		}
+
+		array_shift( $this->curItem );
+		array_shift( $this->mode );
+		$this->ancestorStruct = false;
+		$this->processingArray = false;
+		$this->itemLang = false;
+	}
+
+	/**
+	* Hit a closing element in MODE_LI (either rdf:Seq, or rdf:Bag )
+	* Add information about what type of element this is.
+	*
+	* Note we still have to hit the outer </property>
+	*
+	* For example, when processing:
+	* <exif:ISOSpeedRatings> <rdf:Seq> <rdf:li>64</rdf:li>
+	*   </rdf:Seq> </exif:ISOSpeedRatings>
+	*
+	* This method is called when we hit the </rdf:Seq>.
+	* (For comparison, we call endElementModeSimple when we
+	* hit the </rdf:li>)
+	*
+	* @param $elm String namespace . ' ' . element name
+	*/
+	private function endElementModeLi( $elm ) {
+
+		list( $ns, $tag ) = explode( ' ', $this->curItem[0], 2 );
+		$info = $this->items[$ns][$tag];
+		$finalName = isset( $info['map_name'] )
+			? $info['map_name'] : $tag;
+
+		array_shift( $this->mode );
+
+		if ( !isset( $this->results['xmp-' . $info['map_group']][$finalName] ) ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Empty compund element $finalName." );
+			return;
+		}
+
+		if ( $elm === self::NS_RDF . ' Seq' ) {
+			$this->results['xmp-' . $info['map_group']][$finalName]['_type'] = 'ol';
+		} elseif ( $elm === self::NS_RDF . ' Bag' ) {
+			$this->results['xmp-' . $info['map_group']][$finalName]['_type'] = 'ul';
+		} elseif ( $elm === self::NS_RDF . ' Alt' ) {
+			// extra if needed as you could theoretically have a non-language alt.
+			if ( $info['mode'] === self::MODE_LANG ) {
+				$this->results['xmp-' . $info['map_group']][$finalName]['_type'] = 'lang';
+			}
+
+		} else {
+			throw new MWException( __METHOD__ . " expected </rdf:seq> or </rdf:bag> but instead got $elm." );
+		}
+	}
+
+	/**
+	* End element while in MODE_QDESC
+	* mostly when ending an element when we have a simple value
+	* that has qualifiers.
+	*
+	* Qualifiers aren't all that common, and we don't do anything
+	* with them.
+	*
+	* @param $elm String namespace and element
+	*/
+	private function endElementModeQDesc( $elm ) {
+
+		if ( $elm === self::NS_RDF . ' value' ) {
+			list( $ns, $tag ) = explode( ' ', $this->curItem[0], 2 );
+			$this->saveValue( $ns, $tag, $this->charContent );
+			return;
+		} else {
+			array_shift( $this->mode );
+			array_shift( $this->curItem );
+		}
+
+
+	}
+
+	/**
+	* Handler for hitting a closing element.
+	*
+	* generally just calls a helper function depending on what
+	* mode we're in.
+	*
+	* Ignores the outer wrapping elements that are optional in
+	* xmp and have no meaning.
+	*
+	* @param $parser XMLParser
+	* @param $elm String namespace . ' ' . element name
+	*/
+	function endElement( $parser, $elm ) {
+		if ( $elm === ( self::NS_RDF . ' RDF' )
+			|| $elm === 'adobe:ns:meta/ xmpmeta'
+			|| $elm === 'adobe:ns:meta/ xapmeta' )
+		{
+			// ignore these.
+			return;
+		}
+
+		if ( $elm === self::NS_RDF . ' type' ) {
+			// these aren't really supported properly yet.
+			// However, it appears they almost never used.
+			wfDebugLog( 'XMP', __METHOD__ . ' encountered <rdf:type>' );
+		}
+
+		if ( strpos( $elm, ' ' ) === false ) {
+			// This probably shouldn't happen.
+			// However, there is a bug in an adobe product
+			// that forgets the namespace on some things.
+			// (Luckily they are unimportant things).
+			wfDebugLog( 'XMP', __METHOD__ . " Encountered </$elm> which has no namespace. Skipping." );
+			return;
+		}
+
+		if ( count( $this->mode[0] ) === 0 ) {
+			// This should never ever happen and means
+			// there is a pretty major bug in this class.
+			throw new MWException( 'Encountered end element with no mode' );
+		}
+
+		if ( count( $this->curItem ) == 0 && $this->mode[0] !== self::MODE_INITIAL ) {
+			// just to be paranoid. Should always have a curItem, except for initially
+			// (aka during MODE_INITAL).
+			throw new MWException( "Hit end element </$elm> but no curItem" );
+		}
+
+		switch( $this->mode[0] ) {
+			case self::MODE_IGNORE:
+				$this->endElementModeIgnore( $elm );
+				break;
+			case self::MODE_SIMPLE:
+				$this->endElementModeSimple( $elm );
+				break;
+			case self::MODE_STRUCT:
+			case self::MODE_SEQ:
+			case self::MODE_BAG:
+			case self::MODE_LANG:
+			case self::MODE_BAGSTRUCT:
+				$this->endElementNested( $elm );
+				break;
+			case self::MODE_INITIAL:
+				if ( $elm === self::NS_RDF . ' Description' ) {
+					array_shift( $this->mode );
+				} else {
+					throw new MWException( 'Element ended unexpectedly while in MODE_INITIAL' );
+				}
+				break;
+			case self::MODE_LI:
+			case self::MODE_LI_LANG:
+				$this->endElementModeLi( $elm );
+				break;
+			case self::MODE_QDESC:
+				$this->endElementModeQDesc( $elm );
+				break;
+			default:
+				wfDebugLog( 'XMP', __METHOD__ . " no mode (elm = $elm)" );
+				break;
+		}
+	}
+
+	/**
+	* Hit an opening element while in MODE_IGNORE
+	*
+	* XMP is extensible, so ignore any tag we don't understand.
+	*
+	* Mostly ignores, unless we encounter the element that we are ignoring.
+	* in which case we add it to the item stack, so we can ignore things
+	* that are nested, correctly.
+	*
+	* @param $elm String namespace . ' ' . tag name
+	*/
+	private function startElementModeIgnore( $elm ) {
+		if ( $elm === $this->curItem[0] ) {
+			array_unshift( $this->curItem, $elm );
+			array_unshift( $this->mode, self::MODE_IGNORE );
+		}
+	}
+
+	/**
+	*  Start element in MODE_BAG (unordered array)
+	* this should always be <rdf:Bag>
+	*
+	* @param $elm String namespace . ' ' . tag
+	* @throws MWException if we have an element that's not <rdf:Bag>
+	*/
+	private function startElementModeBag( $elm ) {
+		if ( $elm === self::NS_RDF . ' Bag' ) {
+			array_unshift( $this->mode, self::MODE_LI );
+		} else {
+			throw new MWException( "Expected <rdf:Bag> but got $elm." );
+		}
+
+	}
+
+	/**
+	* Start element in MODE_SEQ (ordered array)
+	* this should always be <rdf:Seq>
+	*
+	* @param $elm String namespace . ' ' . tag
+	* @throws MWException if we have an element that's not <rdf:Seq>
+	*/
+	private function startElementModeSeq( $elm ) {
+		if ( $elm === self::NS_RDF . ' Seq' ) {
+			array_unshift( $this->mode, self::MODE_LI );
+		} elseif ( $elm === self::NS_RDF . ' Bag' ) {
+			# bug 27105
+			wfDebugLog( 'XMP', __METHOD__ . ' Expected an rdf:Seq, but got an rdf:Bag. Pretending'
+				. ' it is a Seq, since some buggy software is known to screw this up.' );
+			array_unshift( $this->mode, self::MODE_LI );
+		} else {
+			throw new MWException( "Expected <rdf:Seq> but got $elm." );
+		}
+
+	}
+
+	/**
+	* Start element in MODE_LANG (language alternative)
+	* this should always be <rdf:Alt>
+	*
+	* This tag tends to be used for metadata like describe this
+	* picture, which can be translated into multiple languages.
+	*
+	* XMP supports non-linguistic alternative selections,
+	* which are really only used for thumbnails, which
+	* we don't care about.
+	*
+	* @param $elm String namespace . ' ' . tag
+	* @throws MWException if we have an element that's not <rdf:Alt>
+	*/
+	private function startElementModeLang( $elm ) {
+		if ( $elm === self::NS_RDF . ' Alt' ) {
+			array_unshift( $this->mode, self::MODE_LI_LANG );
+		} else {
+			throw new MWException( "Expected <rdf:Seq> but got $elm." );
+		}
+
+	}
+
+	/**
+	* Handle an opening element when in MODE_SIMPLE
+	*
+	* This should not happen often. This is for if a simple element
+	* already opened has a child element. Could happen for a
+	* qualified element.
+	*
+	* For example:
+	* <exif:DigitalZoomRatio><rdf:Description><rdf:value>0/10</rdf:value>
+	*   <foo:someQualifier>Bar</foo:someQualifier> </rdf:Description>
+	*   </exif:DigitalZoomRatio>
+	*
+	* This method is called when processing the <rdf:Description> element
+	*
+	* @param $elm String namespace and tag names separated by space.
+	* @param $attribs Array Attributes of the element.
+	*/
+	private function startElementModeSimple( $elm, $attribs ) {
+		if ( $elm === self::NS_RDF . ' Description' ) {
+			// If this value has qualifiers
+			array_unshift( $this->mode, self::MODE_QDESC );
+			array_unshift( $this->curItem, $this->curItem[0] );
+
+			if ( isset( $attribs[self::NS_RDF . ' value'] ) ) {
+				list( $ns, $tag ) = explode( ' ', $this->curItem[0], 2 );
+				$this->saveValue( $ns, $tag, $attribs[self::NS_RDF . ' value'] );
+			}
+		} elseif ( $elm === self::NS_RDF . ' value' ) {
+			// This should not be here.
+			throw new MWException( __METHOD__ . ' Encountered <rdf:value> where it was unexpected.' );
+
+		} else {
+			// something else we don't recognize, like a qualifier maybe.
+			wfDebugLog( 'XMP', __METHOD__ . " Encountered element <$elm> where only expecting character data as value of " . $this->curItem[0] );
+			array_unshift( $this->mode, self::MODE_IGNORE );
+			array_unshift( $this->curItem, $elm );
+
+		}
+
+	}
+
+	/**
+	* Start an element when in MODE_QDESC.
+	* This generally happens when a simple element has an inner
+	* rdf:Description to hold qualifier elements.
+	*
+	* For example in:
+	* <exif:DigitalZoomRatio><rdf:Description><rdf:value>0/10</rdf:value>
+	*   <foo:someQualifier>Bar</foo:someQualifier> </rdf:Description>
+	*   </exif:DigitalZoomRatio>
+	* Called when processing the <rdf:value> or <foo:someQualifier>.
+	*
+	* @param $elm String namespace and tag name separated by a space.
+	*
+	*/
+	private function startElementModeQDesc( $elm ) {
+		if ( $elm === self::NS_RDF . ' value' ) {
+			return; // do nothing
+		} else {
+			// otherwise its a qualifier, which we ignore
+			array_unshift( $this->mode, self::MODE_IGNORE );
+			array_unshift( $this->curItem, $elm );
+		}
+	}
+
+	/**
+	* Starting an element when in MODE_INITIAL
+	* This usually happens when we hit an element inside
+	* the outer rdf:Description
+	*
+	* This is generally where most properties start.
+	*
+	* @param $ns String Namespace
+	* @param $tag String tag name (without namespace prefix)
+	* @param $attribs Array array of attributes
+	*/
+	private function startElementModeInitial( $ns, $tag, $attribs ) {
+		if ( $ns !== self::NS_RDF ) {
+
+			if ( isset( $this->items[$ns][$tag] ) ) {
+				if ( isset( $this->items[$ns][$tag]['structPart'] ) ) {
+					// If this element is supposed to appear only as
+					// a child of a structure, but appears here (not as
+					// a child of a struct), then something weird is
+					// happening, so ignore this element and its children.
+
+					wfDebugLog( 'XMP', "Encountered <$ns:$tag> outside"
+						. " of its expected parent. Ignoring." );
+
+					array_unshift( $this->mode, self::MODE_IGNORE );
+					array_unshift( $this->curItem, $ns . ' ' . $tag );
+					return;
+				}
+				$mode = $this->items[$ns][$tag]['mode'];
+				array_unshift( $this->mode, $mode );
+				array_unshift( $this->curItem, $ns . ' ' . $tag );
+				if ( $mode === self::MODE_STRUCT ) {
+					$this->ancestorStruct = isset( $this->items[$ns][$tag]['map_name'] )
+						? $this->items[$ns][$tag]['map_name'] : $tag;
+				}
+				if ( $this->charContent !== false ) {
+					// Something weird.
+					// Should not happen in valid XMP.
+					throw new MWException( 'tag nested in non-whitespace characters.' );
+				}
+			} else {
+				// This element is not on our list of allowed elements so ignore.
+				wfDebugLog( 'XMP', __METHOD__ . " Ignoring unrecognized element <$ns:$tag>." );
+				array_unshift( $this->mode, self::MODE_IGNORE );
+				array_unshift( $this->curItem, $ns . ' ' . $tag );
+				return;
+			}
+
+		}
+		// process attributes
+		$this->doAttribs( $attribs );
+	}
+
+	/**
+	* Hit an opening element when in a Struct (MODE_STRUCT)
+	* This is generally for fields of a compound property.
+	*
+	* Example of a struct (abbreviated; flash has more properties):
+	*
+	* <exif:Flash> <rdf:Description> <exif:Fired>True</exif:Fired>
+	*  <exif:Mode>1</exif:Mode></rdf:Description></exif:Flash>
+	*
+	* or:
+	*
+	* <exif:Flash rdf:parseType='Resource'> <exif:Fired>True</exif:Fired>
+	*  <exif:Mode>1</exif:Mode></exif:Flash>
+	*
+	* @param $ns String namespace
+	* @param $tag String tag name (no ns)
+	* @param $attribs Array array of attribs w/ values.
+	*/
+	private function startElementModeStruct( $ns, $tag, $attribs ) {
+		if ( $ns !== self::NS_RDF ) {
+
+			if ( isset( $this->items[$ns][$tag] ) ) {
+				if ( isset( $this->items[$ns][$this->ancestorStruct]['children'] )
+					&& !isset( $this->items[$ns][$this->ancestorStruct]['children'][$tag] ) )
+				{
+					// This assumes that we don't have inter-namespace nesting
+					// which we don't in all the properties we're interested in.
+					throw new MWException( " <$tag> appeared nested in <" . $this->ancestorStruct
+						. "> where it is not allowed." );
+				}
+				array_unshift( $this->mode, $this->items[$ns][$tag]['mode'] );
+				array_unshift( $this->curItem, $ns . ' ' . $tag );
+				if ( $this->charContent !== false ) {
+					// Something weird.
+					// Should not happen in valid XMP.
+					throw new MWException( "tag <$tag> nested in non-whitespace characters (" . $this->charContent . ")." );
+				}
+			} else {
+				array_unshift( $this->mode, self::MODE_IGNORE );
+				array_unshift( $this->curItem, $elm );
+				return;
+			}
+
+		}
+
+		if ( $ns === self::NS_RDF && $tag === 'Description' ) {
+			$this->doAttribs( $attribs );
+			array_unshift( $this->mode, self::MODE_STRUCT );
+			array_unshift( $this->curItem, $this->curItem[0] );
+		}
+	}
+
+	/**
+	* opening element in MODE_LI
+	* process elements of arrays.
+	*
+	* Example:
+	* <exif:ISOSpeedRatings> <rdf:Seq> <rdf:li>64</rdf:li>
+	*   </rdf:Seq> </exif:ISOSpeedRatings>
+	* This method is called when we hit the <rdf:li> element.
+	*
+	* @param $elm String: namespace . ' ' . tagname
+	* @param $attribs Array: Attributes. (needed for BAGSTRUCTS)
+	* @throws MWException if gets a tag other than <rdf:li>
+	*/
+	private function startElementModeLi( $elm, $attribs ) {
+		if ( ( $elm ) !== self::NS_RDF . ' li' ) {
+			throw new MWException( "<rdf:li> expected but got $elm." );
+		}
+
+		if ( !isset( $this->mode[1] ) ) {
+			// This should never ever ever happen. Checking for it
+			// to be paranoid.
+			throw new MWException( 'In mode Li, but no 2xPrevious mode!' );
+		}
+
+		if ( $this->mode[1] === self::MODE_BAGSTRUCT ) {
+			// This list item contains a compound (STRUCT) value.
+			array_unshift( $this->mode, self::MODE_STRUCT );
+			array_unshift( $this->curItem, $elm );
+			$this->processingArray = true;
+
+			if ( !isset( $this->curItem[1] ) ) {
+				// be paranoid.
+				throw new MWException( 'Can not find parent of BAGSTRUCT.' );
+			}
+			list( $curNS, $curTag ) = explode( ' ', $this->curItem[1] );
+			$this->ancestorStruct = isset( $this->items[$curNS][$curTag]['map_name'] )
+				? $this->items[$curNS][$curTag]['map_name'] : $curTag;
+
+			$this->doAttribs( $attribs );
+
+		} else {
+			// Normal BAG or SEQ containing simple values.
+			array_unshift( $this->mode, self::MODE_SIMPLE );
+			// need to add curItem[0] on again since one is for the specific item
+			// and one is for the entire group.
+			array_unshift( $this->curItem, $this->curItem[0] );
+			$this->processingArray = true;
+		}
+
+	}
+
+	/**
+	* Opening element in MODE_LI_LANG.
+	* process elements of language alternatives
+	*
+	* Example:
+	* <dc:title> <rdf:Alt> <rdf:li xml:lang="x-default">My house
+	*  </rdf:li> </rdf:Alt> </dc:title>
+	*
+	* This method is called when we hit the <rdf:li> element.
+	*
+	* @param $elm String namespace . ' ' . tag
+	* @param $attribs array array of elements (most importantly xml:lang)
+	* @throws MWException if gets a tag other than <rdf:li> or if no xml:lang
+	*/
+	private function startElementModeLiLang( $elm, $attribs ) {
+		if ( $elm !== self::NS_RDF . ' li' ) {
+			throw new MWException( __METHOD__ . " <rdf:li> expected but got $elm." );
+		}
+		if ( !isset( $attribs[ self::NS_XML . ' lang'] )
+			|| !preg_match( '/^[-A-Za-z0-9]{2,}$/D', $attribs[ self::NS_XML . ' lang' ] ) )
+		{
+			throw new MWException( __METHOD__
+				. " <rdf:li> did not contain, or has invalid xml:lang attribute in lang alternative" );
+		}
+
+		// Lang is case-insensitive.
+		$this->itemLang = strtolower( $attribs[ self::NS_XML . ' lang' ] );
+
+		// need to add curItem[0] on again since one is for the specific item
+		// and one is for the entire group.
+		array_unshift( $this->curItem, $this->curItem[0] );
+		array_unshift( $this->mode, self::MODE_SIMPLE );
+		$this->processingArray = true;
+	}
+
+	/**
+	* Hits an opening element.
+	* Generally just calls a helper based on what MODE we're in.
+	* Also does some initial set up for the wrapper element
+	*
+	* @param $parser XMLParser
+	* @param $elm String namespace <space> element
+	* @param $attribs Array attribute name => value
+	*/
+	function startElement( $parser, $elm, $attribs ) {
+
+		if ( $elm === self::NS_RDF . ' RDF'
+			|| $elm === 'adobe:ns:meta/ xmpmeta'
+			|| $elm === 'adobe:ns:meta/ xapmeta')
+		{
+			/* ignore. */
+			return;
+		} elseif ( $elm === self::NS_RDF . ' Description' ) {
+			if ( count( $this->mode ) === 0 ) {
+				// outer rdf:desc
+				array_unshift( $this->mode, self::MODE_INITIAL );
+			}
+		} elseif ( $elm === self::NS_RDF . ' type' ) {
+			// This doesn't support rdf:type properly.
+			// In practise I have yet to see a file that
+			// uses this element, however it is mentioned
+			// on page 25 of part 1 of the xmp standard.
+			//
+			// also it seems as if exiv2 and exiftool do not support
+			// this either (That or I misunderstand the standard)
+			wfDebugLog( 'XMP', __METHOD__ . ' Encountered <rdf:type> which isn\'t currently supported' );
+		}
+
+		if ( strpos( $elm, ' ' ) === false ) {
+			// This probably shouldn't happen.
+			wfDebugLog( 'XMP', __METHOD__ . " Encountered <$elm> which has no namespace. Skipping." );
+			return;
+		}
+
+		list( $ns, $tag ) = explode( ' ', $elm, 2 );
+
+		if ( count( $this->mode ) === 0 ) {
+			// This should not happen.
+			throw new MWException('Error extracting XMP, '
+				. "encountered <$elm> with no mode" );
+		}
+
+		switch( $this->mode[0] ) {
+			case self::MODE_IGNORE:
+				$this->startElementModeIgnore( $elm );
+				break;
+			case self::MODE_SIMPLE:
+				$this->startElementModeSimple( $elm, $attribs );
+				break;
+			case self::MODE_INITIAL:
+				$this->startElementModeInitial( $ns, $tag, $attribs );
+				break;
+			case self::MODE_STRUCT:
+				$this->startElementModeStruct( $ns, $tag, $attribs );
+				break;
+			case self::MODE_BAG:
+			case self::MODE_BAGSTRUCT:
+				$this->startElementModeBag( $elm );
+				break;
+			case self::MODE_SEQ:
+				$this->startElementModeSeq( $elm );
+				break;
+			case self::MODE_LANG:
+				$this->startElementModeLang( $elm );
+				break;
+			case self::MODE_LI_LANG:
+				$this->startElementModeLiLang( $elm, $attribs );
+				break;
+			case self::MODE_LI:
+				$this->startElementModeLi( $elm, $attribs );
+				break;
+			case self::MODE_QDESC:
+				$this->startElementModeQDesc( $elm );
+				break;
+			default:
+				throw new MWException( 'StartElement in unknown mode: ' . $this->mode[0] );
+				break;
+		}
+	}
+
+	/**
+	* Process attributes.
+	* Simple values can be stored as either a tag or attribute
+	*
+	* Often the initial <rdf:Description> tag just has all the simple
+	* properties as attributes.
+	*
+	* Example:
+	* <rdf:Description rdf:about="" xmlns:exif="http://ns.adobe.com/exif/1.0/" exif:DigitalZoomRatio="0/10">
+	*
+	* @param $attribs Array attribute=>value array.
+	*/
+	private function doAttribs( $attribs ) {
+
+		// first check for rdf:parseType attribute, as that can change
+		// how the attributes are interperted.
+
+		if ( isset( $attribs[self::NS_RDF . ' parseType'] )
+			&& $attribs[self::NS_RDF . ' parseType'] === 'Resource'
+			&& $this->mode[0] === self::MODE_SIMPLE )
+		{
+			// this is equivalent to having an inner rdf:Description
+			$this->mode[0] = self::MODE_QDESC;
+		}
+		foreach ( $attribs as $name => $val ) {
+
+
+			if ( strpos( $name, ' ' ) === false ) {
+				// This shouldn't happen, but so far some old software forgets namespace
+				// on rdf:about.
+				wfDebugLog( 'XMP', __METHOD__ . ' Encountered non-namespaced attribute: '
+					. " $name=\"$val\". Skipping. " );
+				continue;
+			}
+			list( $ns, $tag ) = explode( ' ', $name, 2 );
+			if ( $ns === self::NS_RDF ) {
+				if ( $tag === 'value' || $tag === 'resource' ) {
+					// resource is for url.
+					// value attribute is a weird way of just putting the contents.
+					$this->char( $this->xmlParser, $val );
+				}
+			} elseif ( isset( $this->items[$ns][$tag] ) ) {
+				if ( $this->mode[0] === self::MODE_SIMPLE ) {
+					throw new MWException( __METHOD__
+						. " $ns:$tag found as attribute where not allowed" );
+				}
+				$this->saveValue( $ns, $tag, $val );
+			} else {
+				wfDebugLog( 'XMP', __METHOD__ . " Ignoring unrecognized element <$ns:$tag>." );
+			}
+		}
+	}
+
+	/**
+	* Given an extracted value, save it to results array
+	*
+	* note also uses $this->ancestorStruct and
+	* $this->processingArray to determine what name to
+	* save the value under. (in addition to $tag).
+	*
+	* @param $ns String namespace of tag this is for
+	* @param $tag String tag name
+	* @param $val String value to save
+	*/
+	private function saveValue( $ns, $tag, $val ) {
+
+		$info =& $this->items[$ns][$tag];
+		$finalName = isset( $info['map_name'] )
+			? $info['map_name'] : $tag;
+		if ( isset( $info['validate'] ) ) {
+			$validate = is_array( $info['validate'] ) ? $info['validate']
+				: array( 'XMPValidate', $info['validate'] );
+
+			if ( is_callable( $validate ) ) {
+				call_user_func_array( $validate, array( $info, &$val, true ) );
+				// the reasoning behind using &$val instead of using the return value
+				// is to be consistent between here and validating structures.
+				if ( is_null( $val ) ) {
+					wfDebugLog( 'XMP', __METHOD__ . " <$ns:$tag> failed validation." );
+					return;
+				}
+			} else {
+				wfDebugLog( 'XMP', __METHOD__ . " Validation function for $finalName ("
+					. $validate[0] . '::' . $validate[1] . '()) is not callable.' );
+			}
+		}
+
+		if ( $this->ancestorStruct && $this->processingArray ) {
+			// Aka both an array and a struct. ( self::MODE_BAGSTRUCT )
+			$this->results['xmp-' . $info['map_group']][$this->ancestorStruct][][$finalName] = $val;
+		} elseif ( $this->ancestorStruct ) {
+			$this->results['xmp-' . $info['map_group']][$this->ancestorStruct][$finalName] = $val;
+		} elseif ( $this->processingArray ) {
+			if ( $this->itemLang === false ) {
+				// normal array
+				$this->results['xmp-' . $info['map_group']][$finalName][] = $val;
+			} else {
+				// lang array.
+				$this->results['xmp-' . $info['map_group']][$finalName][$this->itemLang] = $val;
+			}
+		} else {
+			$this->results['xmp-' . $info['map_group']][$finalName] = $val;
+		}
+	}
+}
diff --git a/includes/media/XMPInfo.php b/includes/media/XMPInfo.php
new file mode 100644
index 00000000..1d580ff7
--- /dev/null
+++ b/includes/media/XMPInfo.php
@@ -0,0 +1,1139 @@
+<?php
+/**
+* This class is just a container for a big array
+* used by XMPReader to determine which XMP items to
+* extract.
+*/
+class XMPInfo {
+
+	/** get the items array
+	 * @return Array XMP item configuration array.
+	*/
+	public static function getItems ( ) {
+		if( !self::$ranHooks ) {
+			// This is for if someone makes a custom metadata extension.
+			// For example, a medical wiki might want to decode DICOM xmp properties.
+			wfRunHooks('XMPGetInfo', Array(&self::$items));
+			self::$ranHooks = true; // Only want to do this once.
+		}
+		return self::$items;
+	}
+
+	static private $ranHooks = false;
+
+	/**
+	* XMPInfo::$items keeps a list of all the items
+	* we are interested to extract, as well as
+	* information about the item like what type
+	* it is.
+	*
+	* Format is an array of namespaces,
+	* each containing an array of tags
+	* each tag is an array of information about the
+	* tag, including:
+	*       * map_group - what group (used for precedence during conflicts)
+	*       * mode - What type of item (self::MODE_SIMPLE usually, see above for all values)
+	*       * validate - method to validate input. Could also post-process the input. A string value is assumed to be a static method of XMPValidate. Can also take a array( 'className', 'methodName' ).
+	*       * choices  - array of potential values (format of 'value' => true ). Only used with validateClosed
+	*	* rangeLow and rangeHigh - alternative to choices for numeric ranges. Again for validateClosed only.
+	*       * children - for MODE_STRUCT items, allowed children.
+	*	* structPart - Indicates that this element can only appear as a member of a structure.
+	*
+	* currently this just has a bunch of exif values as this class is only half-done
+	*/
+
+	static private $items = array(
+		'http://ns.adobe.com/exif/1.0/' => array(
+			'ApertureValue' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'BrightnessValue' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'CompressedBitsPerPixel' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'DigitalZoomRatio' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'ExposureBiasValue' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'ExposureIndex' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'ExposureTime' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'FlashEnergy' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational',
+			),
+			'FNumber' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'FocalLength' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'FocalPlaneXResolution' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'FocalPlaneYResolution' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSAltitude' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational',
+			),
+			'GPSDestBearing' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSDestDistance' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSDOP' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSImgDirection' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSSpeed' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'GPSTrack' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'MaxApertureValue'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'ShutterSpeedValue' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			'SubjectDistance'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational'
+			),
+			/* Flash */
+			'Flash'             => array(
+				'mode'      => XMPReader::MODE_STRUCT,
+				'children'  => array(
+					'Fired'      => true,
+					'Function'   => true,
+					'Mode'       => true,
+					'RedEyeMode' => true,
+					'Return'     => true,
+				),
+				'validate'  => 'validateFlash',
+				'map_group' => 'exif',
+			),
+			'Fired'             => array(
+				'map_group' => 'exif',
+				'validate'  => 'validateBoolean',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'Function'          => array(
+				'map_group' => 'exif',
+				'validate'  => 'validateBoolean',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'Mode'              => array(
+				'map_group' => 'exif',
+				'validate'  => 'validateClosed',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'choices'   => array( '0' => true, '1' => true,
+						'2' => true, '3' => true ),
+				'structPart'=> true,
+			),
+			'Return'            => array(
+				'map_group' => 'exif',
+				'validate'  => 'validateClosed',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'choices'   => array( '0' => true,
+						'2' => true, '3' => true ),
+				'structPart'=> true,
+			),
+			'RedEyeMode'        => array(
+				'map_group' => 'exif',
+				'validate'  => 'validateBoolean',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			/* End Flash */
+			'ISOSpeedRatings'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateInteger'
+			),
+			/* end rational things */
+			'ColorSpace'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '65535' => true ),
+			),
+			'ComponentsConfiguration'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '2' => true, '3' => true, '4' => true,
+						'5' => true, '6' => true )
+			),
+			'Contrast'          => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '0' => true, '1' => true, '2' => true )
+			),
+			'CustomRendered'    => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '0' => true, '1' => true )
+			),
+			'DateTimeOriginal'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateDate',
+			),
+			'DateTimeDigitized' => array(  /* xmp:CreateDate */
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateDate',
+			),
+			/* todo: there might be interesting information in
+			 * exif:DeviceSettingDescription, but need to find an
+			 * example
+			 */
+			'ExifVersion'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'ExposureMode'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 2,
+			),
+			'ExposureProgram'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 8,
+			),
+			'FileSource'        => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '3' => true )
+			),
+			'FlashpixVersion'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'FocalLengthIn35mmFilm' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'FocalPlaneResolutionUnit' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '2' => true, '3' => true ),
+			),
+			'GainControl'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 4,
+			),
+			/* this value is post-processed out later */
+			'GPSAltitudeRef'    => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '0' => true, '1' => true ),
+			),
+			'GPSAreaInformation' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'GPSDestBearingRef' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( 'T' => true, 'M' => true ),
+			),
+			'GPSDestDistanceRef' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( 'K' => true, 'M' => true,
+						'N' => true ),
+			),
+			'GPSDestLatitude'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateGPS',
+			),
+			'GPSDestLongitude'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateGPS',
+			),
+			'GPSDifferential'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '0' => true, '1' => true ),
+			),
+			'GPSImgDirectionRef' => array(
+				'map_group'  => 'exif',
+				'mode'       => XMPReader::MODE_SIMPLE,
+				'validate'   => 'validateClosed',
+				'choices'    => array( 'T' => true, 'M' => true ),
+			),
+			'GPSLatitude'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateGPS',
+			),
+			'GPSLongitude'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateGPS',
+			),
+			'GPSMapDatum'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'GPSMeasureMode'    => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '2' => true, '3' => true )
+			),
+			'GPSProcessingMethod' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'GPSSatellites'     => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'GPSSpeedRef'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( 'K' => true, 'M' => true,
+						'N' => true ),
+			),
+			'GPSStatus'         => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( 'A' => true, 'V' => true )
+			),
+			'GPSTimeStamp'      => array(
+				'map_group' => 'exif',
+				// Note: in exif, GPSDateStamp does not include
+				// the time, where here it does.
+				'map_name'  => 'GPSDateStamp',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateDate',
+			),
+			'GPSTrackRef'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( 'T' => true, 'M' => true )
+			),
+			'GPSVersionID'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'ImageUniqueID'     => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'LightSource'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				/* can't use a range, as it skips... */
+				'choices'   =>  array( '0' => true, '1' => true,
+					'2' => true, '3' => true, '4' => true,
+					'9' => true, '10' => true, '11' => true,
+					'12' => true, '13' => true,
+					'14' => true, '15' => true,
+					'17' => true, '18' => true,
+					'19' => true, '20' => true,
+					'21' => true, '22' => true,
+					'23' => true, '24' => true,
+					'255' => true,
+				),
+			),
+			'MeteringMode'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 6,
+				'choices'   => array( '255' => true ),
+			),
+			/* Pixel(X|Y)Dimension are rather useless, but for
+			 * completeness since we do it with exif.
+			 */
+			'PixelXDimension'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'PixelYDimension'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'Saturation'        => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 2,
+			),
+			'SceneCaptureType'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 3,
+			),
+			'SceneType'         => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true ),
+			),
+			// Note, 6 is not valid SensingMethod.
+			'SensingMethod'     => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 1,
+				'rangeHigh' => 5,
+				'choices'   => array( '7' => true, 8 => true ),
+			),
+			'Sharpness'         => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 2,
+			),
+			'SpectralSensitivity' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			// This tag should perhaps be displayed to user better.
+			'SubjectArea'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateInteger',
+			),
+			'SubjectDistanceRange' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'rangeLow'  => 0,
+				'rangeHigh' => 3,
+			),
+			'SubjectLocation'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateInteger',
+			),
+			'UserComment'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_LANG,
+			),
+			'WhiteBalance'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '0' => true, '1' => true )
+			),
+		),
+		'http://ns.adobe.com/tiff/1.0/' => array(
+			'Artist'            => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'BitsPerSample'     => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateInteger',
+			),
+			'Compression'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '6' => true ),
+			),
+			/* this prop should not be used in XMP. dc:rights is the correct prop */
+			'Copyright'         => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_LANG,
+			),
+			'DateTime'          => array(  /* proper prop is xmp:ModifyDate */
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateDate',
+			),
+			'ImageDescription'  => array(  /* proper one is dc:description */
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_LANG,
+			),
+			'ImageLength'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'ImageWidth'        => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'Make'              => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Model'             => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			/**** Do not extract this property
+			 * It interferes with auto exif rotation.
+			 * 'Orientation'       => array(
+			 *	'map_group' => 'exif',
+			 *	'mode'      => XMPReader::MODE_SIMPLE,
+			 *	'validate'  => 'validateClosed',
+			 *	'choices'   => array( '1' => true, '2' => true, '3' => true, '4' => true, 5 => true,
+			 *			'6' => true, '7' => true, '8' => true ),
+			 *),
+			 ******/
+			'PhotometricInterpretation' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '2' => true, '6' => true ),
+			),
+			'PlanerConfiguration' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '2' => true ),
+			),
+			'PrimaryChromaticities' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateRational',
+			),
+			'ReferenceBlackWhite' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateRational',
+			),
+			'ResolutionUnit'    => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '2' => true, '3' => true ),
+			),
+			'SamplesPerPixel'   => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+			),
+			'Software'          => array(  /* see xmp:CreatorTool */
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			/* ignore TransferFunction */
+			'WhitePoint'        => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateRational',
+			),
+			'XResolution'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational',
+			),
+			'YResolution'       => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRational',
+			),
+			'YCbCrCoefficients' => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateRational',
+			),
+			'YCbCrPositioning'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '2' => true ),
+			),
+			'YCbCrSubSampling'  => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateClosed',
+				'choices'   => array( '1' => true, '2' => true ),
+			),
+		),
+		'http://ns.adobe.com/exif/1.0/aux/' => array(
+			'Lens'              => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'SerialNumber'      => array(
+				'map_group' => 'exif',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'OwnerName'         => array(
+				'map_group' => 'exif',
+				'map_name'  => 'CameraOwnerName',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+		),
+		'http://purl.org/dc/elements/1.1/' => array(
+			'title'             => array(
+				'map_group' => 'general',
+				'map_name'  => 'ObjectName',
+				'mode'      => XMPReader::MODE_LANG
+			),
+			'description'       => array(
+				'map_group' => 'general',
+				'map_name'  => 'ImageDescription',
+				'mode'      => XMPReader::MODE_LANG
+			),
+			'contributor'       => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-contributor',
+				'mode'      => XMPReader::MODE_BAG
+			),
+			'coverage'          => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-coverage',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'creator'           => array(
+				'map_group' => 'general',
+				'map_name'  => 'Artist', //map with exif Artist, iptc byline (2:80)
+				'mode'      => XMPReader::MODE_SEQ,
+			),
+			'date'              => array(
+				'map_group' => 'general',
+				// Note, not mapped with other date properties, as this type of date is
+				// non-specific: "A point or period of time associated with an event in
+				//  the lifecycle of the resource"
+				'map_name'  => 'dc-date',
+				'mode'      => XMPReader::MODE_SEQ,
+				'validate'  => 'validateDate',
+			),
+			/* Do not extract dc:format, as we've got better ways to determine mimetype */
+			'identifier'        => array(
+				'map_group' => 'deprecated',
+				'map_name'  => 'Identifier',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'language'          => array(
+				'map_group' => 'general',
+				'map_name'  => 'LanguageCode', /* mapped with iptc 2:135 */
+				'mode'      => XMPReader::MODE_BAG,
+				'validate'  => 'validateLangCode',
+			),
+			'publisher'         => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-publisher',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			// for related images/resources
+			'relation'          => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-relation',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			'rights'            => array(
+				'map_group' => 'general',
+				'map_name'  => 'Copyright',
+				'mode'      => XMPReader::MODE_LANG,
+			),
+			// Note: source is not mapped with iptc source, since iptc
+			// source describes the source of the image in terms of a person
+			// who provided the image, where this is to describe an image that the
+			// current one is based on.
+			'source'            => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-source',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'subject'           => array(
+				'map_group' => 'general',
+				'map_name'  => 'Keywords', /* maps to iptc 2:25 */
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			'type'              => array(
+				'map_group' => 'general',
+				'map_name'  => 'dc-type',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+		),
+		'http://ns.adobe.com/xap/1.0/' => array(
+			'CreateDate' => array(
+				'map_group' => 'general',
+				'map_name' => 'DateTimeDigitized',
+				'mode'     => XMPReader::MODE_SIMPLE,
+				'validate' => 'validateDate',
+			),
+			'CreatorTool' => array(
+				'map_group' => 'general',
+				'map_name'  => 'Software',
+				'mode'      => XMPReader::MODE_SIMPLE
+			),
+			'Identifier' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			'Label' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'ModifyDate' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'DateTime',
+				'validate'  => 'validateDate',
+			),
+			'MetadataDate' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				// map_name to be consistent with other date names.
+				'map_name'  => 'DateTimeMetadata',
+				'validate'  => 'validateDate',
+			),
+			'Nickname' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Rating' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateRating',
+			),
+		),
+		'http://ns.adobe.com/xap/1.0/rights/' => array(
+			'Certificate' => array(
+				'map_group' => 'general',
+				'map_name'  => 'RightsCertificate',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Marked' => array(
+				'map_group' => 'general',
+				'map_name'  => 'Copyrighted',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateBoolean',
+			),
+			'Owner' => array(
+				'map_group' => 'general',
+				'map_name'  => 'CopyrightOwner',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			// this seems similar to dc:rights.
+			'UsageTerms' => array(
+				'map_group' => 'general',
+				'mode' => XMPReader::MODE_LANG,
+			),
+			'WebStatement' => array(
+				'map_group' => 'general',
+				'mode' => XMPReader::MODE_SIMPLE,
+			),
+		),
+		// XMP media management.
+		'http://ns.adobe.com/xap/1.0/mm/' => array(
+			// if we extract the exif UniqueImageID, might
+			// as well do this too.
+			'OriginalDocumentID' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			// It might also be useful to do xmpMM:LastURL
+			// and xmpMM:DerivedFrom as you can potentially,
+			// get the url of this document/source for this
+			// document. However whats more likely is you'd
+			// get a file:// url for the path of the doc,
+			// which is somewhat of a privacy issue.
+		),
+		'http://creativecommons.org/ns#' => array(
+			'license' => array(
+				'map_name'  => 'LicenseUrl',
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'morePermissions' => array(
+				'map_name'  => 'MorePermissionsUrl',
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'attributionURL' => array(
+				'map_group' => 'general',
+				'map_name'  => 'AttributionUrl',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'attributionName' => array(
+				'map_group' => 'general',
+				'map_name'  => 'PreferredAttributionName',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+		),
+		//Note, this property affects how jpeg metadata is extracted.
+		'http://ns.adobe.com/xmp/note/' => array(
+			'HasExtendedXMP' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+		),
+		/* Note, in iptc schemas, the legacy properties are denoted
+		 * as deprecated, since other properties should used instead,
+		 * and properties marked as deprecated in the standard are
+		 * are marked as general here as they don't have replacements
+		 */
+		'http://ns.adobe.com/photoshop/1.0/' => array(
+			'City' => array(
+				'map_group' => 'deprecated',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'CityDest',
+			),
+			'Country' => array(
+				'map_group' => 'deprecated',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'CountryDest',
+			),
+			'State' => array(
+				'map_group' => 'deprecated',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'ProvinceOrStateDest',
+			),
+			'DateCreated' => array(
+				'map_group' => 'deprecated',
+				// marking as deprecated as the xmp prop preferred
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'DateTimeOriginal',
+				'validate'  => 'validateDate',
+				// note this prop is an XMP, not IPTC date
+			),
+			'CaptionWriter' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'Writer',
+			),
+			'Instructions' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'SpecialInstructions',
+			),
+			'TransmissionReference' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'OriginalTransmissionRef',
+			),
+			'AuthorsPosition' => array(
+				/* This corresponds with 2:85
+				 * By-line Title, which needs to be
+				 * handled weirdly to correspond
+				 * with iptc/exif. */
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE
+			),
+			'Credit' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Source' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Urgency' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'Category' => array(
+				// Note, this prop is deprecated, but in general
+				// group since it doesn't have a replacement.
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'iimCategory',
+			),
+			'SupplementalCategories' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+				'map_name'  => 'iimSupplementalCategory',
+			),
+			'Headline' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE
+			),
+		),
+		'http://iptc.org/std/Iptc4xmpCore/1.0/xmlns/' => array(
+			'CountryCode' => array(
+				'map_group' => 'deprecated',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'CountryCodeDest',
+			),
+			'IntellectualGenre' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			// Note, this is a six digit code.
+			// See: http://cv.iptc.org/newscodes/scene/
+			// Since these aren't really all that common,
+			// we just show the number.
+			'Scene' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+				'validate'  => 'validateInteger',
+				'map_name'  => 'SceneCode',
+			),
+			/* Note: SubjectCode should be an 8 ascii digits.
+			 * it is not really an integer (has leading 0's,
+			 * cannot have a +/- sign), but validateInteger
+			 * will let it through.
+			 */
+			'SubjectCode' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+				'map_name'  => 'SubjectNewsCode',
+				'validate'  => 'validateInteger'
+			),
+			'Location' => array(
+				'map_group' => 'deprecated',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'map_name'  => 'SublocationDest',
+			),
+			'CreatorContactInfo' => array(
+				/* Note this maps to 2:118 in iim
+				 * (Contact) field. However those field
+				 * types are slightly different - 2:118
+				 * is free form text field, where this
+				 * is more structured.
+				 */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_STRUCT,
+				'map_name'  => 'Contact',
+				'children'  => array(
+					'CiAdrExtadr' => true,
+					'CiAdrCity'   => true,
+					'CiAdrCtry'   => true,
+					'CiEmailWork' => true,
+					'CiTelWork'   => true,
+					'CiAdrPcode'  => true,
+					'CiAdrRegion' => true,
+					'CiUrlWork'   => true,
+				),
+			),
+			'CiAdrExtadr' => array( /* address */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiAdrCity' => array( /* city */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiAdrCtry' => array( /* country */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiEmailWork' => array( /* email (possibly separated by ',') */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiTelWork' => array( /* telephone */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiAdrPcode' => array( /* postal code */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiAdrRegion' => array( /* province/state */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CiUrlWork' => array( /* url. Multiple may be separated by comma. */
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			/* End contact info struct properties */
+		),
+		'http://iptc.org/std/Iptc4xmpExt/2008-02-29/' => array(
+			'Event' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+			),
+			'OrganisationInImageName' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+				'map_name'  => 'OrganisationInImage'
+			),
+			'PersonInImage' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_BAG,
+			),
+			'MaxAvailHeight' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+				'map_name'  => 'OriginalImageHeight',
+			),
+			'MaxAvailWidth' => array(
+				'map_group' => 'general',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'validate'  => 'validateInteger',
+				'map_name'  => 'OriginalImageWidth',
+			),
+			// LocationShown and LocationCreated are handled
+			// specially because they are hierarchical, but we
+			// also want to merge with the old non-hierarchical.
+			'LocationShown' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_BAGSTRUCT,
+				'children'  => array(
+					'WorldRegion' => true,
+					'CountryCode' => true, /* iso code */
+					'CountryName' => true,
+					'ProvinceState' => true,
+					'City' => true,
+					'Sublocation' => true,
+				),
+			),
+			'LocationCreated' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_BAGSTRUCT,
+				'children'  => array(
+					'WorldRegion' => true,
+					'CountryCode' => true, /* iso code */
+					'CountryName' => true,
+					'ProvinceState' => true,
+					'City' => true,
+					'Sublocation' => true,
+				),
+			),
+			'WorldRegion' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CountryCode' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'CountryName' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+				'map_name'  => 'Country',
+			),
+			'ProvinceState' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+				'map_name'  => 'ProvinceOrState',
+			),
+			'City' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+			'Sublocation' => array(
+				'map_group' => 'special',
+				'mode'      => XMPReader::MODE_SIMPLE,
+				'structPart'=> true,
+			),
+
+			/* Other props that might be interesting but
+			 * Not currently extracted:
+			 * ArtworkOrObject, (info about objects in picture)
+			 * DigitalSourceType
+			 * RegistryId
+			 */
+		),
+
+		/* Plus props we might want to consider:
+		 * (Note: some of these have unclear/incomplete definitions
+		 * from the iptc4xmp standard).
+		 * ImageSupplier (kind of like iptc source field)
+		 * ImageSupplierId (id code for image from supplier)
+		 * CopyrightOwner
+		 * ImageCreator
+		 * Licensor
+		 * Various model release fields
+		 * Property release fields.
+		 */
+	);
+}
diff --git a/includes/media/XMPValidate.php b/includes/media/XMPValidate.php
new file mode 100644
index 00000000..0f1d375c
--- /dev/null
+++ b/includes/media/XMPValidate.php
@@ -0,0 +1,323 @@
+<?php
+/**
+* This contains some static methods for
+* validating XMP properties. See XMPInfo and XMPReader classes.
+*
+* Each of these functions take the same parameters
+* * an info array which is a subset of the XMPInfo::items array
+* * A value (passed as reference) to validate. This can be either a
+*	simple value or an array
+* * A boolean to determine if this is validating a simple or complex values
+*
+* It should be noted that when an array is being validated, typically the validation
+* function is called once for each value, and then once at the end for the entire array.
+*
+* These validation functions can also be used to modify the data. See the gps and flash one's
+* for example.
+*
+* @see http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart1.pdf starting at pg 28
+* @see http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart2.pdf starting at pg 11
+*/
+class XMPValidate {
+	/**
+	* function to validate boolean properties ( True or False )
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateBoolean( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		if ( $val !== 'True' && $val !== 'False' ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected True or False but got $val" );
+			$val = null;
+		}
+
+	}
+
+	/**
+	* function to validate rational properties ( 12/10 )
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateRational( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		if ( !preg_match( '/^(?:-?\d+)\/(?:\d+[1-9]|[1-9]\d*)$/D', $val ) ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected rational but got $val" );
+			$val = null;
+		}
+
+	}
+
+	/**
+	* function to validate rating properties -1, 0-5
+	*
+	* if its outside of range put it into range.
+	*
+	* @see MWG spec
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateRating( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		if ( !preg_match( '/^[-+]?\d*(?:\.?\d*)$/D', $val )
+			|| !is_numeric($val)
+		 ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected rating but got $val" );
+			$val = null;
+			return;
+		} else {
+			$nVal = (float) $val;
+			if ( $nVal < 0 ) {
+				// We do < 0 here instead of < -1 here, since
+				// the values between 0 and -1 are also illegal
+				// as -1 is meant as a special reject rating.
+				wfDebugLog( 'XMP', __METHOD__ . " Rating too low, setting to -1 (Rejected)");
+				$val = '-1';
+				return;
+			}
+			if ( $nVal > 5 ) {
+				wfDebugLog( 'XMP', __METHOD__ . " Rating too high, setting to 5");
+				$val = '5';
+				return;
+			}
+		}
+	}
+
+	/**
+	* function to validate integers
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateInteger( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		if ( !preg_match( '/^[-+]?\d+$/D', $val ) ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected integer but got $val" );
+			$val = null;
+		}
+
+	}
+
+	/**
+	* function to validate properties with a fixed number of allowed
+	* choices. (closed choice)
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateClosed( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+
+		//check if its in a numeric range
+		$inRange = false;
+		if ( isset( $info['rangeLow'] ) 
+			&& isset( $info['rangeHigh'] )
+			&& is_numeric( $val )
+			&& ( intval( $val ) <= $info['rangeHigh'] )
+			&& ( intval( $val ) >= $info['rangeLow'] )
+		) {
+			$inRange = true;
+		}
+
+		if ( !isset( $info['choices'][$val] ) && !$inRange ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected closed choice, but got $val" );
+			$val = null;
+		}
+	}
+
+	/**
+	* function to validate and modify flash structure
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateFlash( $info, &$val, $standalone ) {
+		if ( $standalone ) {
+			// this only validates flash structs, not individual properties
+			return;
+		}
+		if ( !( isset( $val['Fired'] )
+			&& isset( $val['Function'] )
+			&& isset( $val['Mode'] )
+			&& isset( $val['RedEyeMode'] )
+			&& isset( $val['Return'] )
+		) ) {
+			wfDebugLog( 'XMP', __METHOD__ . " Flash structure did not have all the required components" );
+			$val = null;
+		} else {
+			$val = ( "\0" | ( $val['Fired'] === 'True' )
+				| ( intval( $val['Return'] ) << 1 )
+				| ( intval( $val['Mode'] ) << 3 )
+				| ( ( $val['Function'] === 'True' ) << 5 )
+				| ( ( $val['RedEyeMode'] === 'True' ) << 6 ) );
+		}
+	}
+
+	/**
+	* function to validate LangCode properties ( en-GB, etc )
+	*
+	* This is just a naive check to make sure it somewhat looks like a lang code.
+	*
+	* @see rfc 3066
+	* @see http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart1.pdf page 30 (section 8.2.2.5)
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateLangCode( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		if ( !preg_match( '/^[-A-Za-z0-9]{2,}$/D', $val) ) {
+			//this is a rather naive check.
+			wfDebugLog( 'XMP', __METHOD__ . " Expected Lang code but got $val" );
+			$val = null;
+		}
+
+	}
+
+	/**
+	* function to validate date properties, and convert to Exif format.
+	*
+	* @param $info Array information about current property
+	* @param &$val Mixed current value to validate. Converts to TS_EXIF as a side-effect.
+	* @param $standalone Boolean if this is a simple property or array
+	*/
+	public static function validateDate( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			// this only validates standalone properties, not arrays, etc
+			return;
+		}
+		$res = array();
+		if ( !preg_match(
+			/* ahh! scary regex... */
+			'/^([0-3]\d{3})(?:-([01]\d)(?:-([0-3]\d)(?:T([0-2]\d):([0-6]\d)(?::([0-6]\d)(?:\.\d+)?)?([-+]\d{2}:\d{2}|Z)?)?)?)?$/D'
+			, $val, $res)
+		) {
+			wfDebugLog( 'XMP', __METHOD__ . " Expected date but got $val" );
+			$val = null;
+		} else {
+			/*
+			 * $res is formatted as follows:
+			 * 0 -> full date.
+			 * 1 -> year, 2-> month, 3-> day, 4-> hour, 5-> minute, 6->second
+			 * 7-> Timezone specifier (Z or something like +12:30 )
+			 * many parts are optional, some aren't. For example if you specify
+			 * minute, you must specify hour, day, month, and year but not second or TZ.
+			 */
+
+			/*
+			 * First of all, if year = 0000, Something is wrongish,
+			 * so don't extract. This seems to happen when
+			 * some programs convert between metadata formats.
+			 */
+			if ( $res[1] === '0000' ) {
+				wfDebugLog( 'XMP', __METHOD__ . " Invalid date (year 0): $val" );
+				$val = null;
+				return;
+			}
+			//if month, etc unspecified, full out as 01.
+			$res[2] = isset( $res[2] ) ? $res[2] : '01'; //month
+			$res[3] = isset( $res[3] ) ? $res[3] : '01'; //day
+			if ( !isset( $res[4] ) ) { //hour
+				//just have the year month day
+				$val = $res[1] . ':' . $res[2] . ':' . $res[3];
+				return;
+			}
+			//if hour is set, so is minute or regex above will fail.
+			//Extra check for empty string necessary due to TZ but no second case.
+			$res[6] = isset( $res[6] ) && $res[6] != '' ? $res[6] : '00';
+
+			if ( !isset( $res[7] ) || $res[7] === 'Z' ) {
+				$val = $res[1] . ':' . $res[2] . ':' . $res[3]
+					. ' ' . $res[4] . ':' . $res[5] . ':' . $res[6];
+				return;
+			}
+
+			//do timezone processing. We've already done the case that tz = Z.
+
+			$unix = wfTimestamp( TS_UNIX, $res[1] . $res[2] . $res[3] . $res[4] . $res[5] . $res[6] );
+			$offset = intval( substr( $res[7], 1, 2 ) ) * 60 * 60;
+			$offset += intval( substr( $res[7], 4, 2 ) ) * 60;
+			if ( substr( $res[7], 0, 1 ) === '-' ) {
+				$offset = -$offset;
+			}
+			$val = wfTimestamp( TS_EXIF, $unix + $offset );
+		}
+
+	}
+
+	/** function to validate, and more importantly
+	 * translate the XMP DMS form of gps coords to
+	 * the decimal form we use.
+	 *
+	 * @see http://www.adobe.com/devnet/xmp/pdfs/XMPSpecificationPart2.pdf
+	 *        section 1.2.7.4 on page 23
+	 *
+	 * @param $info Array unused (info about prop)
+	 * @param &$val String GPS string in either DDD,MM,SSk or
+	 *           or DDD,MM.mmk form
+	 * @param $standalone Boolean if its a simple prop (should always be true)
+	 */
+	public static function validateGPS ( $info, &$val, $standalone ) {
+		if ( !$standalone ) {
+			return;
+		}
+
+		$m = array();
+		if ( preg_match( 
+			'/(\d{1,3}),(\d{1,2}),(\d{1,2})([NWSE])/D',
+			$val, $m )
+		) {
+			$coord = intval( $m[1] );
+			$coord += intval( $m[2] ) * (1/60);
+			$coord += intval( $m[3] ) * (1/3600);
+			if ( $m[4] === 'S' || $m[4] === 'W' ) {
+				$coord = -$coord;
+			}
+			$val = $coord;
+			return;
+		} elseif ( preg_match( 
+			'/(\d{1,3}),(\d{1,2}(?:.\d*)?)([NWSE])/D',
+			$val, $m )
+		) {
+			$coord = intval( $m[1] );
+			$coord += floatval( $m[2] ) * (1/60);
+			if ( $m[3] === 'S' || $m[3] === 'W' ) {
+				$coord = -$coord;
+			}
+			$val = $coord;
+			return;
+
+		} else {
+			wfDebugLog( 'XMP', __METHOD__ 
+				. " Expected GPSCoordinate, but got $val." );
+			$val = null;
+			return;
+		}
+	}
+}