numerator/denominator.
*
* @author Drew Noakes http://drewnoakes.com
*/
public class Rational extends java.lang.Number implements Serializable
{
/**
* Holds the numerator.
*/
private final int numerator;
/**
* Holds the denominator.
*/
private final int denominator;
private int maxSimplificationCalculations = 1000;
/**
* Creates a new instance of Rational. Rational objects are immutable, so
* once you've set your numerator and denominator values here, you're stuck
* with them!
*/
public Rational(int numerator, int denominator)
{
this.numerator = numerator;
this.denominator = denominator;
}
/**
* Returns the value of the specified number as a double.
* This may involve rounding.
*
* @return the numeric value represented by this object after conversion
* to type double.
*/
public double doubleValue()
{
return (double)numerator / (double)denominator;
}
/**
* Returns the value of the specified number as a float.
* This may involve rounding.
*
* @return the numeric value represented by this object after conversion
* to type float.
*/
public float floatValue()
{
return (float)numerator / (float)denominator;
}
/**
* Returns the value of the specified number as a byte.
* This may involve rounding or truncation. This implementation simply
* casts the result of doubleValue() to byte.
*
* @return the numeric value represented by this object after conversion
* to type byte.
*/
public final byte byteValue()
{
return (byte)doubleValue();
}
/**
* Returns the value of the specified number as an int.
* This may involve rounding or truncation. This implementation simply
* casts the result of doubleValue() to int.
*
* @return the numeric value represented by this object after conversion
* to type int.
*/
public final int intValue()
{
return (int)doubleValue();
}
/**
* Returns the value of the specified number as a long.
* This may involve rounding or truncation. This implementation simply
* casts the result of doubleValue() to long.
*
* @return the numeric value represented by this object after conversion
* to type long.
*/
public final long longValue()
{
return (long)doubleValue();
}
/**
* Returns the value of the specified number as a short.
* This may involve rounding or truncation. This implementation simply
* casts the result of doubleValue() to short.
*
* @return the numeric value represented by this object after conversion
* to type short.
*/
public final short shortValue()
{
return (short)doubleValue();
}
/**
* Returns the denominator.
*/
public final int getDenominator()
{
return this.denominator;
}
/**
* Returns the numerator.
*/
public final int getNumerator()
{
return this.numerator;
}
/**
* Returns the reciprocal value of this obejct as a new Rational.
* @return the reciprocal in a new object
*/
public Rational getReciprocal()
{
return new Rational(this.denominator, this.numerator);
}
/**
* Checks if this rational number is an Integer, either positive or negative.
*/
public boolean isInteger()
{
if (denominator == 1 ||
(denominator != 0 && (numerator % denominator == 0)) ||
(denominator == 0 && numerator == 0)
) {
return true;
} else {
return false;
}
}
/**
* Returns a string representation of the object of form numerator/denominator.
* @return a string representation of the object.
*/
public String toString()
{
return numerator + "/" + denominator;
}
/**
* Returns the simplest represenation of this Rational's value possible.
*/
public String toSimpleString(boolean allowDecimal)
{
if (denominator == 0 && numerator != 0) {
return toString();
} else if (isInteger()) {
return Integer.toString(intValue());
} else if (numerator != 1 && denominator % numerator == 0) {
// common factor between denominator and numerator
int newDenominator = denominator / numerator;
return new Rational(1, newDenominator).toSimpleString(allowDecimal);
} else {
Rational simplifiedInstance = getSimplifiedInstance();
if (allowDecimal) {
String doubleString = Double.toString(simplifiedInstance.doubleValue());
if (doubleString.length() < 5) {
return doubleString;
}
}
return simplifiedInstance.toString();
}
}
/**
* Decides whether a brute-force simplification calculation should be avoided
* by comparing the maximum number of possible calculations with some threshold.
* @return true if the simplification should be performed, otherwise false
*/
private boolean tooComplexForSimplification()
{
double maxPossibleCalculations = (((double)(Math.min(denominator, numerator) - 1) / 5d) + 2);
return maxPossibleCalculations > maxSimplificationCalculations;
}
/**
* Compares two Rational instances, returning true if they are mathematically
* equivalent.
* @param obj the Rational to compare this instance to.
* @return true if instances are mathematically equivalent, otherwise false. Will also
* return false if obj is not an instance of Rational.
*/
public boolean equals(Object obj)
{
if (!(obj instanceof Rational)) {
return false;
}
Rational that = (Rational)obj;
return this.doubleValue() == that.doubleValue();
}
/**
*
* Simplifies the Rational number.
** Prime number series: 1, 2, 3, 5, 7, 9, 11, 13, 17
** To reduce a rational, need to see if both numerator and denominator are divisible * by a common factor. Using the prime number series in ascending order guarantees * the minimun number of checks required.
** However, generating the prime number series seems to be a hefty task. Perhaps * it's simpler to check if both d & n are divisible by all numbers from 2 -> * (Math.min(denominator, numerator) / 2). In doing this, one can check for 2 * and 5 once, then ignore all even numbers, and all numbers ending in 0 or 5. * This leaves four numbers from every ten to check.
** Therefore, the max number of pairs of modulus divisions required will be:
*
* 4 Math.min(denominator, numerator) - 1
* -- * ------------------------------------ + 2
* 10 2
*
* Math.min(denominator, numerator) - 1
* = ------------------------------------ + 2
* 5
* null
*/
public void setObject(int tagType, Object value)
{
if (value==null) {
throw new NullPointerException("cannot set a null object");
}
Integer key = new Integer(tagType);
if (!_tagMap.containsKey(key)) {
_definedTagList.add(new Tag(tagType, this));
}
_tagMap.put(key, value);
}
/**
* Private helper method, containing common functionality for all 'add...Array'
* methods.
* @param tagType the tag's value as an int
* @param array the array of values for the specified tag
*/
public void setObjectArray(int tagType, Object array)
{
// for now, we don't do anything special -- this method might be a candidate for removal once the dust settles
setObject(tagType, array);
}
// TAG GETTERS
/**
* Returns the specified tag's value as an int, if possible.
*/
public int getInt(int tagType) throws MetadataException
{
Object o = getObject(tagType);
if (o==null) {
throw new MetadataException("Tag " + getTagName(tagType) + " has not been set -- check using containsTag() first");
} else if (o instanceof String) {
try {
return Integer.parseInt((String)o);
} catch (NumberFormatException nfe) {
// convert the char array to an int
String s = (String)o;
byte[] bytes = s.getBytes();
long val = 0;
for (int i = 0; i < bytes.length; i++) {
val = val << 8;
val += bytes[i];
}
return (int)val;
}
} else if (o instanceof Number) {
return ((Number)o).intValue();
} else if (o instanceof Rational[]) {
Rational[] rationals = (Rational[])o;
if (rationals.length==1)
return rationals[0].intValue();
} else if (o instanceof byte[]) {
byte[] bytes = (byte[])o;
if (bytes.length==1)
return bytes[0];
} else if (o instanceof int[]) {
int[] ints = (int[])o;
if (ints.length==1)
return ints[0];
}
throw new MetadataException("Tag '" + tagType + "' cannot be cast to int. It is of type '" + o.getClass() + "'.");
}
// TODO get Array methods need to return cloned data, to maintain this directory's integrity
/**
* Gets the specified tag's value as a String array, if possible. Only supported
* where the tag is set as String[], String, int[], byte[] or Rational[].
* @param tagType the tag identifier
* @return the tag's value as an array of Strings
* @throws MetadataException if the tag has not been set or cannot be represented
* as a String[]
*/
public String[] getStringArray(int tagType) throws MetadataException
{
Object o = getObject(tagType);
if (o==null) {
throw new MetadataException("Tag " + getTagName(tagType) + " has not been set -- check using containsTag() first");
} else if (o instanceof String[]) {
return (String[])o;
} else if (o instanceof String) {
String[] strings = {(String)o};
return strings;
} else if (o instanceof int[]) {
int[] ints = (int[])o;
String[] strings = new String[ints.length];
for (int i = 0; inull if the tag hasn't been defined.
*/
public String getDescription(int tagType) throws MetadataException
{
switch (tagType) {
case ExifDirectory.TAG_ORIENTATION:
return getOrientationDescription();
case ExifDirectory.TAG_NEW_SUBFILE_TYPE:
return getNewSubfileTypeDescription();
case ExifDirectory.TAG_SUBFILE_TYPE:
return getSubfileTypeDescription();
case ExifDirectory.TAG_THRESHOLDING:
return getThresholdingDescription();
case ExifDirectory.TAG_FILL_ORDER:
return getFillOrderDescription();
case ExifDirectory.TAG_RESOLUTION_UNIT:
return getResolutionDescription();
case ExifDirectory.TAG_YCBCR_POSITIONING:
return getYCbCrPositioningDescription();
case ExifDirectory.TAG_EXPOSURE_TIME:
return getExposureTimeDescription();
case ExifDirectory.TAG_SHUTTER_SPEED:
return getShutterSpeedDescription();
case ExifDirectory.TAG_FNUMBER:
return getFNumberDescription();
case ExifDirectory.TAG_X_RESOLUTION:
return getXResolutionDescription();
case ExifDirectory.TAG_Y_RESOLUTION:
return getYResolutionDescription();
case ExifDirectory.TAG_THUMBNAIL_OFFSET:
return getThumbnailOffsetDescription();
case ExifDirectory.TAG_THUMBNAIL_LENGTH:
return getThumbnailLengthDescription();
case ExifDirectory.TAG_COMPRESSION_LEVEL:
return getCompressionLevelDescription();
case ExifDirectory.TAG_SUBJECT_DISTANCE:
return getSubjectDistanceDescription();
case ExifDirectory.TAG_METERING_MODE:
return getMeteringModeDescription();
case ExifDirectory.TAG_WHITE_BALANCE:
return getWhiteBalanceDescription();
case ExifDirectory.TAG_FLASH:
return getFlashDescription();
case ExifDirectory.TAG_FOCAL_LENGTH:
return getFocalLengthDescription();
case ExifDirectory.TAG_COLOR_SPACE:
return getColorSpaceDescription();
case ExifDirectory.TAG_EXIF_IMAGE_WIDTH:
return getExifImageWidthDescription();
case ExifDirectory.TAG_EXIF_IMAGE_HEIGHT:
return getExifImageHeightDescription();
case ExifDirectory.TAG_FOCAL_PLANE_UNIT:
return getFocalPlaneResolutionUnitDescription();
case ExifDirectory.TAG_FOCAL_PLANE_X_RES:
return getFocalPlaneXResolutionDescription();
case ExifDirectory.TAG_FOCAL_PLANE_Y_RES:
return getFocalPlaneYResolutionDescription();
case ExifDirectory.TAG_THUMBNAIL_IMAGE_WIDTH:
return getThumbnailImageWidthDescription();
case ExifDirectory.TAG_THUMBNAIL_IMAGE_HEIGHT:
return getThumbnailImageHeightDescription();
case ExifDirectory.TAG_BITS_PER_SAMPLE:
return getBitsPerSampleDescription();
case ExifDirectory.TAG_COMPRESSION:
return getCompressionDescription();
case ExifDirectory.TAG_PHOTOMETRIC_INTERPRETATION:
return getPhotometricInterpretationDescription();
case ExifDirectory.TAG_ROWS_PER_STRIP:
return getRowsPerStripDescription();
case ExifDirectory.TAG_STRIP_BYTE_COUNTS:
return getStripByteCountsDescription();
case ExifDirectory.TAG_SAMPLES_PER_PIXEL:
return getSamplesPerPixelDescription();
case ExifDirectory.TAG_PLANAR_CONFIGURATION:
return getPlanarConfigurationDescription();
case ExifDirectory.TAG_YCBCR_SUBSAMPLING:
return getYCbCrSubsamplingDescription();
case ExifDirectory.TAG_EXPOSURE_PROGRAM:
return getExposureProgramDescription();
case ExifDirectory.TAG_APERTURE:
return getApertureValueDescription();
case ExifDirectory.TAG_MAX_APERTURE:
return getMaxApertureValueDescription();
case ExifDirectory.TAG_SENSING_METHOD:
return getSensingMethodDescription();
case ExifDirectory.TAG_EXPOSURE_BIAS:
return getExposureBiasDescription();
case ExifDirectory.TAG_FILE_SOURCE:
return getFileSourceDescription();
case ExifDirectory.TAG_SCENE_TYPE:
return getSceneTypeDescription();
case ExifDirectory.TAG_COMPONENTS_CONFIGURATION:
return getComponentConfigurationDescription();
case ExifDirectory.TAG_EXIF_VERSION:
return getExifVersionDescription();
case ExifDirectory.TAG_FLASHPIX_VERSION:
return getFlashPixVersionDescription();
case ExifDirectory.TAG_REFERENCE_BLACK_WHITE:
return getReferenceBlackWhiteDescription();
case ExifDirectory.TAG_ISO_EQUIVALENT:
return getIsoEquivalentDescription();
case ExifDirectory.TAG_THUMBNAIL_DATA:
return getThumbnailDescription();
case ExifDirectory.TAG_USER_COMMENT:
return getUserCommentDescription();
case ExifDirectory.TAG_CUSTOM_RENDERED:
return getCustomRenderedDescription();
case ExifDirectory.TAG_EXPOSURE_MODE:
return getExposureModeDescription();
case ExifDirectory.TAG_WHITE_BALANCE_MODE:
return getWhiteBalanceModeDescription();
case ExifDirectory.TAG_DIGITAL_ZOOM_RATIO:
return getDigitalZoomRatioDescription();
case ExifDirectory.TAG_35MM_FILM_EQUIV_FOCAL_LENGTH:
return get35mmFilmEquivFocalLengthDescription();
case ExifDirectory.TAG_SCENE_CAPTURE_TYPE:
return getSceneCaptureTypeDescription();
case ExifDirectory.TAG_GAIN_CONTROL:
return getGainControlDescription();
case ExifDirectory.TAG_CONTRAST:
return getContrastDescription();
case ExifDirectory.TAG_SATURATION:
return getSaturationDescription();
case ExifDirectory.TAG_SHARPNESS:
return getSharpnessDescription();
case ExifDirectory.TAG_SUBJECT_DISTANCE_RANGE:
return getSubjectDistanceRangeDescription();
case ExifDirectory.TAG_WIN_AUTHOR:
return getWindowsAuthorDescription();
case ExifDirectory.TAG_WIN_COMMENT:
return getWindowsCommentDescription();
case ExifDirectory.TAG_WIN_KEYWORDS:
return getWindowsKeywordsDescription();
case ExifDirectory.TAG_WIN_SUBJECT:
return getWindowsSubjectDescription();
case ExifDirectory.TAG_WIN_TITLE:
return getWindowsTitleDescription();
default:
return _directory.getString(tagType);
}
}
public String getNewSubfileTypeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_NEW_SUBFILE_TYPE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_NEW_SUBFILE_TYPE)) {
case 1: return "Full-resolution image";
case 2: return "Reduced-resolution image";
case 3: return "Single page of multi-page reduced-resolution image";
case 4: return "Transparency mask";
case 5: return "Transparency mask of reduced-resolution image";
case 6: return "Transparency mask of multi-page image";
case 7: return "Transparency mask of reduced-resolution multi-page image";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_NEW_SUBFILE_TYPE) + ")";
}
}
public String getSubfileTypeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_SUBFILE_TYPE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_SUBFILE_TYPE)) {
case 1: return "Full-resolution image";
case 2: return "Reduced-resolution image";
case 3: return "Single page of multi-page image";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_SUBFILE_TYPE) + ")";
}
}
public String getThresholdingDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_THRESHOLDING)) return null;
switch (_directory.getInt(ExifDirectory.TAG_THRESHOLDING)) {
case 1: return "No dithering or halftoning";
case 2: return "Ordered dither or halftone";
case 3: return "Randomized dither";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_THRESHOLDING) + ")";
}
}
public String getFillOrderDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_FILL_ORDER)) return null;
switch (_directory.getInt(ExifDirectory.TAG_FILL_ORDER)) {
case 1: return "Normal";
case 2: return "Reversed";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_FILL_ORDER) + ")";
}
}
public String getSubjectDistanceRangeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_SUBJECT_DISTANCE_RANGE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_SUBJECT_DISTANCE_RANGE)) {
case 0:
return "Unknown";
case 1:
return "Macro";
case 2:
return "Close view";
case 3:
return "Distant view";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_SUBJECT_DISTANCE_RANGE) + ")";
}
}
public String getSharpnessDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_SHARPNESS)) return null;
switch (_directory.getInt(ExifDirectory.TAG_SHARPNESS)) {
case 0:
return "None";
case 1:
return "Low";
case 2:
return "Hard";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_SHARPNESS) + ")";
}
}
public String getSaturationDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_SATURATION)) return null;
switch (_directory.getInt(ExifDirectory.TAG_SATURATION)) {
case 0:
return "None";
case 1:
return "Low saturation";
case 2:
return "High saturation";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_SATURATION) + ")";
}
}
public String getContrastDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_CONTRAST)) return null;
switch (_directory.getInt(ExifDirectory.TAG_CONTRAST)) {
case 0:
return "None";
case 1:
return "Soft";
case 2:
return "Hard";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_CONTRAST) + ")";
}
}
public String getGainControlDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_GAIN_CONTROL)) return null;
switch (_directory.getInt(ExifDirectory.TAG_GAIN_CONTROL)) {
case 0:
return "None";
case 1:
return "Low gain up";
case 2:
return "Low gain down";
case 3:
return "High gain up";
case 4:
return "High gain down";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_GAIN_CONTROL) + ")";
}
}
public String getSceneCaptureTypeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_SCENE_CAPTURE_TYPE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_SCENE_CAPTURE_TYPE)) {
case 0:
return "Standard";
case 1:
return "Landscape";
case 2:
return "Portrait";
case 3:
return "Night scene";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_SCENE_CAPTURE_TYPE) + ")";
}
}
public String get35mmFilmEquivFocalLengthDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_35MM_FILM_EQUIV_FOCAL_LENGTH)) return null;
int equivalentFocalLength = _directory.getInt(ExifDirectory.TAG_35MM_FILM_EQUIV_FOCAL_LENGTH);
if (equivalentFocalLength==0)
return "Unknown";
else
return SimpleDecimalFormatter.format(equivalentFocalLength) + "mm";
}
public String getDigitalZoomRatioDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_DIGITAL_ZOOM_RATIO)) return null;
Rational rational = _directory.getRational(ExifDirectory.TAG_DIGITAL_ZOOM_RATIO);
if (rational.getNumerator()==0)
return "Digital zoom not used.";
return SimpleDecimalFormatter.format(rational.doubleValue());
}
public String getWhiteBalanceModeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_WHITE_BALANCE_MODE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_WHITE_BALANCE_MODE)) {
case 0:
return "Auto white balance";
case 1:
return "Manual white balance";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_WHITE_BALANCE_MODE) + ")";
}
}
public String getExposureModeDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_EXPOSURE_MODE)) return null;
switch (_directory.getInt(ExifDirectory.TAG_EXPOSURE_MODE)) {
case 0:
return "Auto exposure";
case 1:
return "Manual exposure";
case 2:
return "Auto bracket";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_EXPOSURE_MODE) + ")";
}
}
public String getCustomRenderedDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_CUSTOM_RENDERED)) return null;
switch (_directory.getInt(ExifDirectory.TAG_CUSTOM_RENDERED)) {
case 0:
return "Normal process";
case 1:
return "Custom process";
default:
return "Unknown (" + _directory.getInt(ExifDirectory.TAG_CUSTOM_RENDERED) + ")";
}
}
public String getUserCommentDescription() throws MetadataException
{
if (!_directory.containsTag(ExifDirectory.TAG_USER_COMMENT)) return null;
byte[] commentBytes = _directory.getByteArray(ExifDirectory.TAG_USER_COMMENT);
if (commentBytes.length==0)
return "";
final String[] encodingNames = new String[] { "ASCII", "UNICODE", "JIS" };
if (commentBytes.length>=10)
{
String encodingRegion = new String(commentBytes, 0, 10);
// try each encoding name
for (int i = 0; iExifProcessingException with the
* specified detail message and inner exception.
* @param message the detail message
* @param cause an inner exception
*/
public ExifProcessingException(String message, Throwable cause)
{
super(message, cause);
}
}
libmetadata-extractor-java-2.3.1/src/com/drew/metadata/exif/ExifReader.java 0000644 0000000 0000000 00000074333 10716136374 025336 0 ustar root root /*
* EXIFExtractor.java
*
* This class based upon code from Jhead, a C program for extracting and
* manipulating the Exif data within files written by Matthias Wandel.
* http://www.sentex.net/~mwandel/jhead/
*
* Jhead is public domain software - that is, you can do whatever you want
* with it, and include it software that is licensed under the GNU or the
* BSD license, or whatever other licence you choose, including proprietary
* closed source licenses. Similarly, I release this Java version under the
* same license, though I do ask that you leave this header in tact.
*
* If you make modifications to this code that you think would benefit the
* wider community, please send me a copy and I'll post it on my site. Unlike
* Jhead, this code (as it stands) only supports reading of Exif data - no
* manipulation, and no thumbnail stuff.
*
* If you make use of this code, I'd appreciate hearing about it.
* drew.noakes@drewnoakes.com
* Latest version of this software kept at
* http://drewnoakes.com/
*
* Created on 28 April 2002, 23:54
* Modified 04 Aug 2002
* - Renamed constants to be inline with changes to ExifTagValues interface
* - Substituted usage of JDK 1.4 features (java.nio package)
* Modified 29 Oct 2002 (v1.2)
* - Proper traversing of Exif file structure and complete refactor & tidy of
* the codebase (a few unnoticed bugs removed)
* - Reads makernote data for 6 families of camera (5 makes)
* - Tags now stored in directories... use the IFD_* constants to refer to the
* image file directory you require (Exif, Interop, GPS and Makernote*) --
* this avoids collisions where two tags share the same code
* - Takes componentCount of unknown tags into account
* - Now understands GPS tags (thanks to Colin Briton for his help with this)
* - Some other bug fixes, pointed out by users around the world. Thanks!
* Modified 27 Nov 2002 (v2.0)
* - Renamed to ExifReader
* - Moved to new package com.drew.metadata.exif
* Modified since, however changes have not been logged. See release notes for
* library-wide modifications.
*/
package com.drew.metadata.exif;
import com.drew.imaging.jpeg.JpegProcessingException;
import com.drew.imaging.jpeg.JpegSegmentData;
import com.drew.imaging.jpeg.JpegSegmentReader;
import com.drew.lang.Rational;
import com.drew.metadata.Directory;
import com.drew.metadata.Metadata;
import com.drew.metadata.MetadataReader;
import java.io.File;
import java.io.InputStream;
import java.util.HashMap;
/**
* Extracts Exif data from a JPEG header segment, providing information about the
* camera/scanner/capture device (if available). Information is encapsulated in
* an Metadata object.
* @author Drew Noakes http://drewnoakes.com
*/
public class ExifReader implements MetadataReader
{
/**
* The JPEG segment as an array of bytes.
*/
private final byte[] _data;
/**
* Represents the native byte ordering used in the JPEG segment. If true,
* then we're using Motorolla ordering (Big endian), else we're using Intel
* ordering (Little endian).
*/
private boolean _isMotorollaByteOrder;
/**
* Bean instance to store information about the image and camera/scanner/capture
* device.
*/
private Metadata _metadata;
/**
* The number of bytes used per format descriptor.
*/
private static final int[] BYTES_PER_FORMAT = {0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8};
/**
* The number of formats known.
*/
private static final int MAX_FORMAT_CODE = 12;
// Format types
// Note: Cannot use the DataFormat enumeration in the case statement that uses these tags.
// Is there a better way?
private static final int FMT_BYTE = 1;
private static final int FMT_STRING = 2;
private static final int FMT_USHORT = 3;
private static final int FMT_ULONG = 4;
private static final int FMT_URATIONAL = 5;
private static final int FMT_SBYTE = 6;
private static final int FMT_UNDEFINED = 7;
private static final int FMT_SSHORT = 8;
private static final int FMT_SLONG = 9;
private static final int FMT_SRATIONAL = 10;
private static final int FMT_SINGLE = 11;
private static final int FMT_DOUBLE = 12;
public static final int TAG_EXIF_OFFSET = 0x8769;
public static final int TAG_INTEROP_OFFSET = 0xA005;
public static final int TAG_GPS_INFO_OFFSET = 0x8825;
public static final int TAG_MAKER_NOTE = 0x927C;
public static final int TIFF_HEADER_START_OFFSET = 6;
/**
* Creates an ExifReader for a JpegSegmentData object.
* @param segmentData
*/
public ExifReader(JpegSegmentData segmentData)
{
this(segmentData.getSegment(JpegSegmentReader.SEGMENT_APP1));
}
/**
* Creates an ExifReader for a Jpeg file.
* @param file
* @throws JpegProcessingException
*/
public ExifReader(File file) throws JpegProcessingException
{
this(new JpegSegmentReader(file).readSegment(JpegSegmentReader.SEGMENT_APP1));
}
/**
* Creates an ExifReader for a Jpeg stream.
* @param is JPEG stream. Stream will be closed.
*/
public ExifReader(InputStream is) throws JpegProcessingException
{
this(new JpegSegmentReader(is).readSegment(JpegSegmentReader.SEGMENT_APP1));
}
/**
* Creates an ExifReader for the given JPEG header segment.
*/
public ExifReader(byte[] data)
{
_data = data;
}
/**
* Performs the Exif data extraction, returning a new instance of Metadata.
*/
public Metadata extract()
{
return extract(new Metadata());
}
/**
* Performs the Exif data extraction, adding found values to the specified
* instance of Metadata.
*/
public Metadata extract(Metadata metadata)
{
_metadata = metadata;
if (_data==null)
return _metadata;
// once we know there's some data, create the directory and start working on it
ExifDirectory directory = (ExifDirectory)_metadata.getDirectory(ExifDirectory.class);
// check for the header length
if (_data.length<=14) {
directory.addError("Exif data segment must contain at least 14 bytes");
return _metadata;
}
// check for the header preamble
if (!"Exif\0\0".equals(new String(_data, 0, 6))) {
directory.addError("Exif data segment doesn't begin with 'Exif'");
return _metadata;
}
// this should be either "MM" or "II"
String byteOrderIdentifier = new String(_data, 6, 2);
if (!setByteOrder(byteOrderIdentifier)) {
directory.addError("Unclear distinction between Motorola/Intel byte ordering: " + byteOrderIdentifier);
return _metadata;
}
// Check the next two values for correctness.
if (get16Bits(8)!=0x2a) {
directory.addError("Invalid Exif start - should have 0x2A at offset 8 in Exif header");
return _metadata;
}
int firstDirectoryOffset = get32Bits(10) + TIFF_HEADER_START_OFFSET;
// David Ekholm sent an digital camera image that has this problem
if (firstDirectoryOffset>=_data.length - 1) {
directory.addError("First exif directory offset is beyond end of Exif data segment");
// First directory normally starts 14 bytes in -- try it here and catch another error in the worst case
firstDirectoryOffset = 14;
}
HashMap processedDirectoryOffsets = new HashMap();
// 0th IFD (we merge with Exif IFD)
processDirectory(directory, processedDirectoryOffsets, firstDirectoryOffset, TIFF_HEADER_START_OFFSET);
// after the extraction process, if we have the correct tags, we may be able to store thumbnail information
storeThumbnailBytes(directory, TIFF_HEADER_START_OFFSET);
return _metadata;
}
private void storeThumbnailBytes(ExifDirectory exifDirectory, int tiffHeaderOffset)
{
if (!exifDirectory.containsTag(ExifDirectory.TAG_COMPRESSION))
return;
if (!exifDirectory.containsTag(ExifDirectory.TAG_THUMBNAIL_LENGTH) ||
!exifDirectory.containsTag(ExifDirectory.TAG_THUMBNAIL_OFFSET))
return;
try {
int offset = exifDirectory.getInt(ExifDirectory.TAG_THUMBNAIL_OFFSET);
int length = exifDirectory.getInt(ExifDirectory.TAG_THUMBNAIL_LENGTH);
byte[] result = new byte[length];
for (int i = 0; i
* :0000: 4E 69 6B 6F 6E 00 01 00-05 00 02 00 02 00 06 00 Nikon...........
* :0010: 00 00 EC 02 00 00 03 00-03 00 01 00 00 00 06 00 ................
*
* :0000: 4E 69 6B 6F 6E 00 01 00-05 00 02 00 02 00 06 00 Nikon...........
* :0010: 00 00 EC 02 00 00 03 00-03 00 01 00 00 00 06 00 ................
*