src/pixy/meta/Metadata.java - pixymeta_android - Git at Google

 /*
  * Copyright (c) 2014-2021 by Wen Yu
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License 2.0 which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * This Source Code may also be made available under the following Secondary
  * Licenses when the conditions for such availability set forth in the Eclipse
  * Public License, v. 2.0 are satisfied: GNU General Public License, version 2
  * or any later version.
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
  *
  * Change History - most recent changes go on top of previous changes
  *
  * Metadata.java
  *
  * Who   Date       Description
  * ====  =========  ======================================================
  * WY    26Sep2015  Added insertComment(InputStream, OutputStream, String}
  * WY    06Jul2015  Added insertXMP(InputSream, OutputStream, XMP)
  * WY    16Apr2015  Changed insertIRB() parameter List to Collection
  * WY    16Apr2015  Removed ICC_Profile related code
  * WY    13Mar2015  initial creation
  */

 package pixy.meta;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import android.graphics.Bitmap;
 import pixy.meta.Metadata;
 import pixy.util.MetadataUtils;
 import pixy.meta.MetadataReader;
 import pixy.meta.MetadataType;
 import pixy.meta.adobe._8BIM;
 import pixy.meta.bmp.BMPMeta;
 import pixy.meta.exif.Exif;
 import pixy.meta.gif.GIFMeta;
 import pixy.meta.iptc.IPTCDataSet;
 import pixy.meta.jpeg.JPGMeta;
 import pixy.meta.png.PNGMeta;
 import pixy.meta.tiff.TIFFMeta;
 import pixy.meta.xmp.XMP;
 import pixy.image.ImageType;
 import pixy.io.FileCacheRandomAccessInputStream;
 import pixy.io.FileCacheRandomAccessOutputStream;
 import pixy.io.PeekHeadInputStream;
 import pixy.io.RandomAccessInputStream;
 import pixy.io.RandomAccessOutputStream;

 /**
  * Base class for image metadata.
  *
  * @author Wen Yu, yuwen_66@yahoo.com
  * @version 1.0 01/12/2015
  */
 public abstract class Metadata implements MetadataReader, Iterable<MetadataEntry> {
 	public static final int IMAGE_MAGIC_NUMBER_LEN = 4;
 	// Fields
 	private MetadataType type;
 	protected byte[] data;
 	protected boolean isDataRead;

 	// Obtain a logger instance
 	private static final Logger LOGGER = LoggerFactory.getLogger(Metadata.class);

 	public static void  extractThumbnails(File image, String pathToThumbnail) throws IOException {
 		FileInputStream fin = new FileInputStream(image);
 		extractThumbnails(fin, pathToThumbnail);
 		fin.close();
 	}

 	public static void extractThumbnails(InputStream is, String pathToThumbnail) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate thumbnail extracting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.extractThumbnails(peekHeadInputStream, pathToThumbnail);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				TIFFMeta.extractThumbnail(randIS, pathToThumbnail);
 				randIS.shallowClose();
 				break;
 			case PNG:
 				LOGGER.info("PNG image format does not contain any thumbnail");
 				break;
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not contain any thumbnails", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("Thumbnail extracting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void extractThumbnails(String image, String pathToThumbnail) throws IOException {
 		extractThumbnails(new File(image), pathToThumbnail);
 	}

 	public static void insertComment(InputStream is, OutputStream os, String comment) throws IOException {
 		insertComments(is, os, Arrays.asList(comment));
 	}

 	public static void insertComments(InputStream is, OutputStream os, List<String> comments) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate IPTC inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertComments(peekHeadInputStream, os, comments);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
 				TIFFMeta.insertComments(comments, randIS, randOS);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 				PNGMeta.insertComments(peekHeadInputStream, os, comments);
 				break;
 			case GIF:
 				GIFMeta.insertComments(peekHeadInputStream, os, comments);
 				break;
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support comment data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("comment data inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	/**
 	 * @param is input image stream
 	 * @param os output image stream
 	 * @param exif Exif instance
 	 * @throws IOException
 	 */
 	public static void insertExif(InputStream is, OutputStream os, Exif exif) throws IOException {
 		insertExif(is, os, exif, false);
 	}

 	/**
 	 * @param is input image stream
 	 * @param os output image stream
 	 * @param exif Exif instance
 	 * @param update true to keep the original data, otherwise false
 	 * @throws IOException
 	 */
 	public static void insertExif(InputStream is, OutputStream os, Exif exif, boolean update) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate EXIF inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertExif(peekHeadInputStream, os, exif, update);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
 				TIFFMeta.insertExif(randIS, randOS, exif, update);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 			case PNG:
 				LOGGER.info("{} image format does not support EXIF data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("EXIF data inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertICCProfile(InputStream is, OutputStream out, byte[] icc_profile) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate ICCP inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertICCProfile(peekHeadInputStream, out, icc_profile);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
 				TIFFMeta.insertICCProfile(icc_profile, 0, randIS, randOS);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support ICCProfile data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("ICCProfile data inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertIPTC(InputStream is, OutputStream out, Collection<IPTCDataSet> iptcs) throws IOException {
 		insertIPTC(is, out, iptcs, false);
 	}

 	public static void insertIPTC(InputStream is, OutputStream out, Collection<IPTCDataSet> iptcs, boolean update) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate IPTC inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertIPTC(peekHeadInputStream, out, iptcs, update);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
 				TIFFMeta.insertIPTC(randIS, randOS, iptcs, update);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support IPTC data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("IPTC data inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertIRB(InputStream is, OutputStream out, Collection<_8BIM> bims) throws IOException {
 		insertIRB(is, out, bims, false);
 	}

 	public static void insertIRB(InputStream is, OutputStream os, Collection<_8BIM> bims, boolean update) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate IRB inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertIRB(peekHeadInputStream, os, bims, update);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
 				TIFFMeta.insertIRB(randIS, randOS, bims, update);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support IRB data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("IRB data inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertIRBThumbnail(InputStream is, OutputStream out, Bitmap thumbnail) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate IRB thumbnail inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertIRBThumbnail(peekHeadInputStream, out, thumbnail);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
 				TIFFMeta.insertThumbnail(randIS, randOS, thumbnail);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 			case GIF:
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support IRB thumbnail", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("IRB thumbnail inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertXMP(InputStream is, OutputStream out, XMP xmp) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate XMP inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertXMP(peekHeadInputStream, out, xmp); // No ExtendedXMP
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
 				TIFFMeta.insertXMP(xmp, randIS, randOS);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 				PNGMeta.insertXMP(peekHeadInputStream, out, xmp);
 				break;
 			case GIF:
 				GIFMeta.insertXMPApplicationBlock(peekHeadInputStream, out, xmp);
 				break;
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support XMP data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("XMP inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static void insertXMP(InputStream is, OutputStream out, String xmp) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate XMP inserting to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				JPGMeta.insertXMP(peekHeadInputStream, out, xmp, null); // No ExtendedXMP
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
 				TIFFMeta.insertXMP(xmp, randIS, randOS);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PNG:
 				PNGMeta.insertXMP(peekHeadInputStream, out, xmp);
 				break;
 			case GIF:
 				GIFMeta.insertXMPApplicationBlock(peekHeadInputStream, out, xmp);
 				break;
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support XMP data", imageType);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("XMP inserting is not supported for " + imageType + " image");
 		}
 		peekHeadInputStream.shallowClose();
 	}

 	public static Map<MetadataType, Metadata> readMetadata(File image) throws IOException {
 		FileInputStream fin = new FileInputStream(image);
 		Map<MetadataType, Metadata> metadataMap = readMetadata(fin);
 		fin.close();

 		return metadataMap;
 	}

 	/**
 	 * Reads all metadata associated with the input image
 	 *
 	 * @param is InputStream for the image
 	 * @return a list of Metadata for the input stream
 	 * @throws IOException
 	 */
 	public static Map<MetadataType, Metadata> readMetadata(InputStream is) throws IOException {
 		// Metadata map for all the Metadata read
 		Map<MetadataType, Metadata> metadataMap = new HashMap<MetadataType, Metadata>();
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
 		// Delegate metadata reading to corresponding image tweakers.
 		switch(imageType) {
 			case JPG:
 				metadataMap = JPGMeta.readMetadata(peekHeadInputStream);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
 				metadataMap = TIFFMeta.readMetadata(randIS);
 				randIS.shallowClose();
 				break;
 			case PNG:
 				metadataMap = PNGMeta.readMetadata(peekHeadInputStream);
 				break;
 			case GIF:
 				metadataMap = GIFMeta.readMetadata(peekHeadInputStream);
 				break;
 			case BMP:
 				metadataMap = BMPMeta.readMetadata(peekHeadInputStream);
 				break;
 			default:
 				peekHeadInputStream.close();
 				throw new IllegalArgumentException("Metadata reading is not supported for " + imageType + " image");

 		}
 		peekHeadInputStream.shallowClose();

 		return metadataMap;
 	}

 	public static Map<MetadataType, Metadata> readMetadata(String image) throws IOException {
 		return readMetadata(new File(image));
 	}

 	/**
 	 * Remove meta data from image
 	 *
 	 * @param is InputStream for the input image
 	 * @param os OutputStream for the output image
 	 * @throws IOException
 	 */
 	public static Map<MetadataType, Metadata> removeMetadata(InputStream is, OutputStream os, MetadataType ...metadataTypes) throws IOException {
 		// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
 		PeekHeadInputStream peakHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
 		ImageType imageType = MetadataUtils.guessImageType(peakHeadInputStream);
 		// The map of removed metadata
 		Map<MetadataType, Metadata> metadataMap = Collections.emptyMap();
 		// Delegate meta data removing to corresponding image tweaker.
 		switch(imageType) {
 			case JPG:
 				metadataMap = JPGMeta.removeMetadata(peakHeadInputStream, os, metadataTypes);
 				break;
 			case TIFF:
 				RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peakHeadInputStream);
 				RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
 				metadataMap = TIFFMeta.removeMetadata(randIS, randOS, metadataTypes);
 				randIS.shallowClose();
 				randOS.shallowClose();
 				break;
 			case PCX:
 			case TGA:
 			case BMP:
 				LOGGER.info("{} image format does not support meta data", imageType);
 				break;
 			default:
 				peakHeadInputStream.close();
 				throw new IllegalArgumentException("Metadata removing is not supported for " + imageType + " image");
 		}

 		peakHeadInputStream.shallowClose();

 		return metadataMap;
 	}

 	public Metadata(MetadataType type) {
 		this.type = type;
 	}

 	public Metadata(MetadataType type, byte[] data) {
 		if(type == null) throw new IllegalArgumentException("Metadata type must be specified");
 		if(data == null) throw new IllegalArgumentException("Input data array is null");
 		if(data.length == 0) isDataRead = true; // Allow for zero length data but disable read
 		this.type = type;
 		this.data = data;
 	}

 	public void ensureDataRead() {
 		if(!isDataRead) {
 			try {
 				read();
 			} catch (IOException e) {
 				e.printStackTrace();
 			}
 		}
 	}

 	public byte[] getData() {
 		if(data != null)
 			return data.clone();

 		return null;
 	}

 	public MetadataType getType() {
 		return type;
 	}

 	public boolean isDataRead() {
 		return isDataRead;
 	}

 	/**
 	 * Writes the metadata out to the output stream
 	 *
 	 * @param out OutputStream to write the metadata to
 	 * @throws IOException
 	 */
 	public void write(OutputStream out) throws IOException {
 		byte[] data = getData();
 		if(data != null)
 			out.write(data);
 	}
 }
	/*
	* Copyright (c) 2014-2021 by Wen Yu
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License 2.0 which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* This Source Code may also be made available under the following Secondary
	* Licenses when the conditions for such availability set forth in the Eclipse
	* Public License, v. 2.0 are satisfied: GNU General Public License, version 2
	* or any later version.
	*
	* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
	*
	* Change History - most recent changes go on top of previous changes
	*
	* Metadata.java
	*
	* Who Date Description
	* ==== ========= ======================================================
	* WY 26Sep2015 Added insertComment(InputStream, OutputStream, String}
	* WY 06Jul2015 Added insertXMP(InputSream, OutputStream, XMP)
	* WY 16Apr2015 Changed insertIRB() parameter List to Collection
	* WY 16Apr2015 Removed ICC_Profile related code
	* WY 13Mar2015 initial creation
	*/

	package pixy.meta;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	import android.graphics.Bitmap;
	import pixy.meta.Metadata;
	import pixy.util.MetadataUtils;
	import pixy.meta.MetadataReader;
	import pixy.meta.MetadataType;
	import pixy.meta.adobe._8BIM;
	import pixy.meta.bmp.BMPMeta;
	import pixy.meta.exif.Exif;
	import pixy.meta.gif.GIFMeta;
	import pixy.meta.iptc.IPTCDataSet;
	import pixy.meta.jpeg.JPGMeta;
	import pixy.meta.png.PNGMeta;
	import pixy.meta.tiff.TIFFMeta;
	import pixy.meta.xmp.XMP;
	import pixy.image.ImageType;
	import pixy.io.FileCacheRandomAccessInputStream;
	import pixy.io.FileCacheRandomAccessOutputStream;
	import pixy.io.PeekHeadInputStream;
	import pixy.io.RandomAccessInputStream;
	import pixy.io.RandomAccessOutputStream;

	/**
	* Base class for image metadata.
	*
	* @author Wen Yu, yuwen_66@yahoo.com
	* @version 1.0 01/12/2015
	*/
	public abstract class Metadata implements MetadataReader, Iterable<MetadataEntry> {
	public static final int IMAGE_MAGIC_NUMBER_LEN = 4;
	// Fields
	private MetadataType type;
	protected byte[] data;
	protected boolean isDataRead;

	// Obtain a logger instance
	private static final Logger LOGGER = LoggerFactory.getLogger(Metadata.class);

	public static void extractThumbnails(File image, String pathToThumbnail) throws IOException {
	FileInputStream fin = new FileInputStream(image);
	extractThumbnails(fin, pathToThumbnail);
	fin.close();
	}

	public static void extractThumbnails(InputStream is, String pathToThumbnail) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate thumbnail extracting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.extractThumbnails(peekHeadInputStream, pathToThumbnail);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	TIFFMeta.extractThumbnail(randIS, pathToThumbnail);
	randIS.shallowClose();
	break;
	case PNG:
	LOGGER.info("PNG image format does not contain any thumbnail");
	break;
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not contain any thumbnails", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("Thumbnail extracting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void extractThumbnails(String image, String pathToThumbnail) throws IOException {
	extractThumbnails(new File(image), pathToThumbnail);
	}

	public static void insertComment(InputStream is, OutputStream os, String comment) throws IOException {
	insertComments(is, os, Arrays.asList(comment));
	}

	public static void insertComments(InputStream is, OutputStream os, List<String> comments) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate IPTC inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertComments(peekHeadInputStream, os, comments);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
	TIFFMeta.insertComments(comments, randIS, randOS);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	PNGMeta.insertComments(peekHeadInputStream, os, comments);
	break;
	case GIF:
	GIFMeta.insertComments(peekHeadInputStream, os, comments);
	break;
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support comment data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("comment data inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	/**
	* @param is input image stream
	* @param os output image stream
	* @param exif Exif instance
	* @throws IOException
	*/
	public static void insertExif(InputStream is, OutputStream os, Exif exif) throws IOException {
	insertExif(is, os, exif, false);
	}

	/**
	* @param is input image stream
	* @param os output image stream
	* @param exif Exif instance
	* @param update true to keep the original data, otherwise false
	* @throws IOException
	*/
	public static void insertExif(InputStream is, OutputStream os, Exif exif, boolean update) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate EXIF inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertExif(peekHeadInputStream, os, exif, update);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
	TIFFMeta.insertExif(randIS, randOS, exif, update);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	case PNG:
	LOGGER.info("{} image format does not support EXIF data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("EXIF data inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertICCProfile(InputStream is, OutputStream out, byte[] icc_profile) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate ICCP inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertICCProfile(peekHeadInputStream, out, icc_profile);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
	TIFFMeta.insertICCProfile(icc_profile, 0, randIS, randOS);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support ICCProfile data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("ICCProfile data inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertIPTC(InputStream is, OutputStream out, Collection<IPTCDataSet> iptcs) throws IOException {
	insertIPTC(is, out, iptcs, false);
	}

	public static void insertIPTC(InputStream is, OutputStream out, Collection<IPTCDataSet> iptcs, boolean update) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate IPTC inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertIPTC(peekHeadInputStream, out, iptcs, update);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
	TIFFMeta.insertIPTC(randIS, randOS, iptcs, update);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support IPTC data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("IPTC data inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertIRB(InputStream is, OutputStream out, Collection<_8BIM> bims) throws IOException {
	insertIRB(is, out, bims, false);
	}

	public static void insertIRB(InputStream is, OutputStream os, Collection<_8BIM> bims, boolean update) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate IRB inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertIRB(peekHeadInputStream, os, bims, update);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
	TIFFMeta.insertIRB(randIS, randOS, bims, update);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support IRB data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("IRB data inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertIRBThumbnail(InputStream is, OutputStream out, Bitmap thumbnail) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate IRB thumbnail inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertIRBThumbnail(peekHeadInputStream, out, thumbnail);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
	TIFFMeta.insertThumbnail(randIS, randOS, thumbnail);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	case GIF:
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support IRB thumbnail", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("IRB thumbnail inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertXMP(InputStream is, OutputStream out, XMP xmp) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate XMP inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertXMP(peekHeadInputStream, out, xmp); // No ExtendedXMP
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
	TIFFMeta.insertXMP(xmp, randIS, randOS);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	PNGMeta.insertXMP(peekHeadInputStream, out, xmp);
	break;
	case GIF:
	GIFMeta.insertXMPApplicationBlock(peekHeadInputStream, out, xmp);
	break;
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support XMP data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("XMP inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static void insertXMP(InputStream is, OutputStream out, String xmp) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate XMP inserting to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	JPGMeta.insertXMP(peekHeadInputStream, out, xmp, null); // No ExtendedXMP
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(out);
	TIFFMeta.insertXMP(xmp, randIS, randOS);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PNG:
	PNGMeta.insertXMP(peekHeadInputStream, out, xmp);
	break;
	case GIF:
	GIFMeta.insertXMPApplicationBlock(peekHeadInputStream, out, xmp);
	break;
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support XMP data", imageType);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("XMP inserting is not supported for " + imageType + " image");
	}
	peekHeadInputStream.shallowClose();
	}

	public static Map<MetadataType, Metadata> readMetadata(File image) throws IOException {
	FileInputStream fin = new FileInputStream(image);
	Map<MetadataType, Metadata> metadataMap = readMetadata(fin);
	fin.close();

	return metadataMap;
	}

	/**
	* Reads all metadata associated with the input image
	*
	* @param is InputStream for the image
	* @return a list of Metadata for the input stream
	* @throws IOException
	*/
	public static Map<MetadataType, Metadata> readMetadata(InputStream is) throws IOException {
	// Metadata map for all the Metadata read
	Map<MetadataType, Metadata> metadataMap = new HashMap<MetadataType, Metadata>();
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peekHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peekHeadInputStream);
	// Delegate metadata reading to corresponding image tweakers.
	switch(imageType) {
	case JPG:
	metadataMap = JPGMeta.readMetadata(peekHeadInputStream);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peekHeadInputStream);
	metadataMap = TIFFMeta.readMetadata(randIS);
	randIS.shallowClose();
	break;
	case PNG:
	metadataMap = PNGMeta.readMetadata(peekHeadInputStream);
	break;
	case GIF:
	metadataMap = GIFMeta.readMetadata(peekHeadInputStream);
	break;
	case BMP:
	metadataMap = BMPMeta.readMetadata(peekHeadInputStream);
	break;
	default:
	peekHeadInputStream.close();
	throw new IllegalArgumentException("Metadata reading is not supported for " + imageType + " image");

	}
	peekHeadInputStream.shallowClose();

	return metadataMap;
	}

	public static Map<MetadataType, Metadata> readMetadata(String image) throws IOException {
	return readMetadata(new File(image));
	}

	/**
	* Remove meta data from image
	*
	* @param is InputStream for the input image
	* @param os OutputStream for the output image
	* @throws IOException
	*/
	public static Map<MetadataType, Metadata> removeMetadata(InputStream is, OutputStream os, MetadataType ...metadataTypes) throws IOException {
	// ImageIO.IMAGE_MAGIC_NUMBER_LEN bytes as image magic number
	PeekHeadInputStream peakHeadInputStream = new PeekHeadInputStream(is, IMAGE_MAGIC_NUMBER_LEN);
	ImageType imageType = MetadataUtils.guessImageType(peakHeadInputStream);
	// The map of removed metadata
	Map<MetadataType, Metadata> metadataMap = Collections.emptyMap();
	// Delegate meta data removing to corresponding image tweaker.
	switch(imageType) {
	case JPG:
	metadataMap = JPGMeta.removeMetadata(peakHeadInputStream, os, metadataTypes);
	break;
	case TIFF:
	RandomAccessInputStream randIS = new FileCacheRandomAccessInputStream(peakHeadInputStream);
	RandomAccessOutputStream randOS = new FileCacheRandomAccessOutputStream(os);
	metadataMap = TIFFMeta.removeMetadata(randIS, randOS, metadataTypes);
	randIS.shallowClose();
	randOS.shallowClose();
	break;
	case PCX:
	case TGA:
	case BMP:
	LOGGER.info("{} image format does not support meta data", imageType);
	break;
	default:
	peakHeadInputStream.close();
	throw new IllegalArgumentException("Metadata removing is not supported for " + imageType + " image");
	}

	peakHeadInputStream.shallowClose();

	return metadataMap;
	}

	public Metadata(MetadataType type) {
	this.type = type;
	}

	public Metadata(MetadataType type, byte[] data) {
	if(type == null) throw new IllegalArgumentException("Metadata type must be specified");
	if(data == null) throw new IllegalArgumentException("Input data array is null");
	if(data.length == 0) isDataRead = true; // Allow for zero length data but disable read
	this.type = type;
	this.data = data;
	}

	public void ensureDataRead() {
	if(!isDataRead) {
	try {
	read();
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	}

	public byte[] getData() {
	if(data != null)
	return data.clone();

	return null;
	}

	public MetadataType getType() {
	return type;
	}

	public boolean isDataRead() {
	return isDataRead;
	}

	/**
	* Writes the metadata out to the output stream
	*
	* @param out OutputStream to write the metadata to
	* @throws IOException
	*/
	public void write(OutputStream out) throws IOException {
	byte[] data = getData();
	if(data != null)
	out.write(data);
	}
	}