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
+ *
Exif
+ * @return the name of the directory
+ */
+ public abstract String getName();
+
+ /**
+ * Provides the map of tag names, hashed by tag type identifier.
+ * @return the map of tag names
+ */
+ protected abstract HashMap getTagNameMap();
+
+// CONSTRUCTORS
+
+ /**
+ * Creates a new Directory.
+ */
+ public Directory()
+ {
+ _tagMap = new HashMap();
+ _definedTagList = new ArrayList();
+ }
+
+// VARIOUS METHODS
+
+ /**
+ * Indicates whether the specified tag type has been set.
+ * @param tagType the tag type to check for
+ * @return true if a value exists for the specified tag type, false if not
+ */
+ public boolean containsTag(int tagType)
+ {
+ return _tagMap.containsKey(new Integer(tagType));
+ }
+
+ /**
+ * Returns an Iterator of Tag instances that have been set in this Directory.
+ * @return an Iterator of Tag instances
+ */
+ public Iterator getTagIterator()
+ {
+ return _definedTagList.iterator();
+ }
+
+ /**
+ * Returns the number of tags set in this Directory.
+ * @return the number of tags set in this Directory
+ */
+ public int getTagCount()
+ {
+ return _definedTagList.size();
+ }
+
+ /**
+ * Sets the descriptor used to interperet tag values.
+ * @param descriptor the descriptor used to interperet tag values
+ */
+ public void setDescriptor(TagDescriptor descriptor)
+ {
+ if (descriptor==null) {
+ throw new NullPointerException("cannot set a null descriptor");
+ }
+ _descriptor = descriptor;
+ }
+
+ public void addError(String message)
+ {
+ if (_errorList==null) {
+ _errorList = new ArrayList();
+ }
+ _errorList.add(message);
+ }
+
+ public boolean hasErrors()
+ {
+ return (_errorList!=null && _errorList.size()>0);
+ }
+
+ public Iterator getErrors()
+ {
+ return _errorList.iterator();
+ }
+
+ public int getErrorCount()
+ {
+ return _errorList.size();
+ }
+
+// TAG SETTERS
+
+ /**
+ * Sets an int value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as an int
+ */
+ public void setInt(int tagType, int value)
+ {
+ setObject(tagType, new Integer(value));
+ }
+
+ /**
+ * Sets a double value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a double
+ */
+ public void setDouble(int tagType, double value)
+ {
+ setObject(tagType, new Double(value));
+ }
+
+ /**
+ * Sets a float value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a float
+ */
+ public void setFloat(int tagType, float value)
+ {
+ setObject(tagType, new Float(value));
+ }
+
+ /**
+ * Sets an int value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a String
+ */
+ public void setString(int tagType, String value)
+ {
+ setObject(tagType, value);
+ }
+
+ /**
+ * Sets an int value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a boolean
+ */
+ public void setBoolean(int tagType, boolean value)
+ {
+ setObject(tagType, new Boolean(value));
+ }
+
+ /**
+ * Sets a long value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a long
+ */
+ public void setLong(int tagType, long value)
+ {
+ setObject(tagType, new Long(value));
+ }
+
+ /**
+ * Sets a java.util.Date value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag as a java.util.Date
+ */
+ public void setDate(int tagType, java.util.Date value)
+ {
+ setObject(tagType, value);
+ }
+
+ /**
+ * Sets a Rational value for the specified tag.
+ * @param tagType the tag's value as an int
+ * @param rational rational number
+ */
+ public void setRational(int tagType, Rational rational)
+ {
+ setObject(tagType, rational);
+ }
+
+ /**
+ * Sets a Rational array for the specified tag.
+ * @param tagType the tag identifier
+ * @param rationals the Rational array to store
+ */
+ public void setRationalArray(int tagType, Rational[] rationals)
+ {
+ setObjectArray(tagType, rationals);
+ }
+
+ /**
+ * Sets an int array for the specified tag.
+ * @param tagType the tag identifier
+ * @param ints the int array to store
+ */
+ public void setIntArray(int tagType, int[] ints)
+ {
+ setObjectArray(tagType, ints);
+ }
+
+ /**
+ * Sets a byte array for the specified tag.
+ * @param tagType the tag identifier
+ * @param bytes the byte array to store
+ */
+ public void setByteArray(int tagType, byte[] bytes)
+ {
+ setObjectArray(tagType, bytes);
+ }
+
+ /**
+ * Sets a String array for the specified tag.
+ * @param tagType the tag identifier
+ * @param strings the String array to store
+ */
+ public void setStringArray(int tagType, String[] strings)
+ {
+ setObjectArray(tagType, strings);
+ }
+
+ /**
+ * Private helper method, containing common functionality for all 'add'
+ * methods.
+ * @param tagType the tag's value as an int
+ * @param value the value for the specified tag
+ * @throws NullPointerException if value is 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; iDirectory of specified type. If this Metadata object already contains
+ * such a directory, it is returned. Otherwise a new instance of this directory will be created and stored within
+ * this Metadata object.
+ * @param type the type of the Directory implementation required.
+ * @return a directory of the specified type.
+ */
+ public Directory getDirectory(Class type)
+ {
+ if (!Directory.class.isAssignableFrom(type)) {
+ throw new RuntimeException("Class type passed to getDirectory must be an implementation of com.drew.metadata.Directory");
+ }
+ // check if we've already issued this type of directory
+ if (directoryMap.containsKey(type)) {
+ return (Directory)directoryMap.get(type);
+ }
+ Object directory;
+ try {
+ directory = type.newInstance();
+ } catch (Exception e) {
+ throw new RuntimeException("Cannot instantiate provided Directory type: " + type.toString());
+ }
+ // store the directory in case it's requested later
+ directoryMap.put(type, directory);
+ directoryList.add(directory);
+ return (Directory)directory;
+ }
+
+ /**
+ * Indicates whether a given directory type has been created in this metadata
+ * repository. Directories are created by calling getDirectory(Class).
+ * @param type the Directory type
+ * @return true if the metadata directory has been created
+ */
+ public boolean containsDirectory(Class type)
+ {
+ return directoryMap.containsKey(type);
+ }
+}
Index: /trunk/src/com/drew/metadata/MetadataException.java
===================================================================
--- /trunk/src/com/drew/metadata/MetadataException.java (revision 4231)
+++ /trunk/src/com/drew/metadata/MetadataException.java (revision 4231)
@@ -0,0 +1,40 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 13-Nov-2002 18:10:23 using IntelliJ IDEA.
+ */
+package com.drew.metadata;
+
+import com.drew.lang.CompoundException;
+
+/**
+ *
+ */
+public class MetadataException extends CompoundException
+{
+ public MetadataException(String msg)
+ {
+ super(msg);
+ }
+
+ public MetadataException(Throwable exception)
+ {
+ super(exception);
+ }
+
+ public MetadataException(String msg, Throwable innerException)
+ {
+ super(msg, innerException);
+ }
+}
Index: /trunk/src/com/drew/metadata/MetadataReader.java
===================================================================
--- /trunk/src/com/drew/metadata/MetadataReader.java (revision 4231)
+++ /trunk/src/com/drew/metadata/MetadataReader.java (revision 4231)
@@ -0,0 +1,27 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 26-Nov-2002 11:21:43 using IntelliJ IDEA.
+ */
+package com.drew.metadata;
+
+/**
+ *
+ */
+public interface MetadataReader
+{
+ public Metadata extract();
+
+ public Metadata extract(Metadata metadata);
+}
Index: /trunk/src/com/drew/metadata/SampleUsage.java
===================================================================
--- /trunk/src/com/drew/metadata/SampleUsage.java (revision 4231)
+++ /trunk/src/com/drew/metadata/SampleUsage.java (revision 4231)
@@ -0,0 +1,120 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 05-Nov-2002 18:57:14 using IntelliJ IDEA.
+ */
+package com.drew.metadata;
+
+import com.drew.imaging.jpeg.JpegMetadataReader;
+import com.drew.imaging.jpeg.JpegProcessingException;
+import com.drew.imaging.jpeg.JpegSegmentReader;
+import com.drew.metadata.exif.ExifReader;
+import com.drew.metadata.iptc.IptcReader;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Iterator;
+
+/**
+ *
+ */
+public class SampleUsage
+{
+ /**
+ * Constructor which executes multiple sample usages, each of which return the same output. This class showcases
+ * multiple usages of this metadata class library.
+ * @param fileName path to a jpeg file upon which to operate
+ */
+ public SampleUsage(String fileName)
+ {
+ File jpegFile = new File(fileName);
+
+ // There are multiple ways to get a Metadata object
+
+ // Approach 1
+ // This approach reads all types of known Jpeg metadata (at present,
+ // Exif and Iptc) in a single call. In most cases, this is the most
+ // appropriate usage.
+ try {
+ Metadata metadata = JpegMetadataReader.readMetadata(jpegFile);
+ printImageTags(1, metadata);
+ } catch (JpegProcessingException e) {
+ System.err.println("error 1a");
+ }
+
+ // Approach 2
+ // This approach shows using individual MetadataReader implementations
+ // to read a file. This is less efficient than approach 1, as the file
+ // is opened and read twice.
+ try {
+ Metadata metadata = new Metadata();
+ new ExifReader(jpegFile).extract(metadata);
+ new IptcReader(jpegFile).extract(metadata);
+ printImageTags(2, metadata);
+ } catch (JpegProcessingException jpe) {
+ System.err.println("error 2a");
+ }
+
+ // Approach 3
+ // As fast as approach 1 (this is what goes on inside the JpegMetadataReader's
+ // readMetadata() method), this code is handy if you want to look into other
+ // Jpeg segments too.
+ try {
+ JpegSegmentReader segmentReader = new JpegSegmentReader(jpegFile);
+ byte[] exifSegment = segmentReader.readSegment(JpegSegmentReader.SEGMENT_APP1);
+ byte[] iptcSegment = segmentReader.readSegment(JpegSegmentReader.SEGMENT_APPD);
+ Metadata metadata = new Metadata();
+ new ExifReader(exifSegment).extract(metadata);
+ new IptcReader(iptcSegment).extract(metadata);
+ printImageTags(3, metadata);
+ } catch (JpegProcessingException jpe) {
+ System.err.println("error 3a");
+ }
+ }
+
+ private void printImageTags(int approachCount, Metadata metadata)
+ {
+ System.out.println();
+ System.out.println("*** APPROACH " + approachCount + " ***");
+ System.out.println();
+ // iterate over the exif data and print to System.out
+ Iterator directories = metadata.getDirectoryIterator();
+ while (directories.hasNext()) {
+ Directory directory = (Directory)directories.next();
+ Iterator tags = directory.getTagIterator();
+ while (tags.hasNext()) {
+ Tag tag = (Tag)tags.next();
+ System.out.println(tag);
+ }
+ if (directory.hasErrors()) {
+ Iterator errors = directory.getErrors();
+ while (errors.hasNext()) {
+ System.out.println("ERROR: " + errors.next());
+ }
+ }
+ }
+ }
+
+ /**
+ * Executes the sample usage program.
+ * @param args command line parameters
+ */
+ public static void main(String[] args)
+ {
+ new SampleUsage("src/com/drew/metadata/test/withIptcExifGps.jpg");
+ }
+}
Index: /trunk/src/com/drew/metadata/Tag.java
===================================================================
--- /trunk/src/com/drew/metadata/Tag.java (revision 4231)
+++ /trunk/src/com/drew/metadata/Tag.java (revision 4231)
@@ -0,0 +1,101 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 26-Nov-2002 18:29:12 using IntelliJ IDEA.
+ */
+package com.drew.metadata;
+
+import java.io.Serializable;
+
+/**
+ *
+ */
+public class Tag implements Serializable
+{
+ private final int _tagType;
+ private final Directory _directory;
+
+ public Tag(int tagType, Directory directory)
+ {
+ _tagType = tagType;
+ _directory = directory;
+ }
+
+ /**
+ * Gets the tag type as an int
+ * @return the tag type as an int
+ */
+ public int getTagType()
+ {
+ return _tagType;
+ }
+
+ /**
+ * Gets the tag type in hex notation as a String with padded leading
+ * zeroes if necessary (i.e. 0x100E).
+ * @return the tag type as a string in hexadecimal notation
+ */
+ public String getTagTypeHex()
+ {
+ String hex = Integer.toHexString(_tagType);
+ while (hex.length() < 4) hex = "0" + hex;
+ return "0x" + hex;
+ }
+
+ /**
+ * Get a description of the tag's value, considering enumerated values
+ * and units.
+ * @return a description of the tag's value
+ */
+ public String getDescription() throws MetadataException
+ {
+ return _directory.getDescription(_tagType);
+ }
+
+ /**
+ * Get the name of the tag, such as Aperture, or
+ * InteropVersion.
+ * @return the tag's name
+ */
+ public String getTagName()
+ {
+ return _directory.getTagName(_tagType);
+ }
+
+ /**
+ * Get the name of the directory in which the tag exists, such as
+ * Exif, GPS or Interoperability.
+ * @return name of the directory in which this tag exists
+ */
+ public String getDirectoryName()
+ {
+ return _directory.getName();
+ }
+
+ /**
+ * A basic representation of the tag's type and value in format:
+ * FNumber - F2.8.
+ * @return the tag's type and value
+ */
+ public String toString()
+ {
+ String description;
+ try {
+ description = getDescription();
+ } catch (MetadataException e) {
+ description = _directory.getString(getTagType()) + " (unable to formulate description)";
+ }
+ return "[" + _directory.getName() + "] " + getTagName() + " - " + description;
+ }
+}
Index: /trunk/src/com/drew/metadata/TagDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/TagDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/TagDescriptor.java (revision 4231)
@@ -0,0 +1,46 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata;
+
+import java.io.Serializable;
+
+/**
+ * Abstract base class for all tag descriptor classes. Implementations are responsible for
+ * providing the human-readable string represenation of tag values stored in a directory.
+ * The directory is provided to the tag descriptor via its constructor.
+ */
+public abstract class TagDescriptor implements Serializable
+{
+ protected final Directory _directory;
+
+ public TagDescriptor(Directory directory)
+ {
+ _directory = directory;
+ }
+
+ /**
+ * Returns a descriptive value of the the specified tag for this image.
+ * Where possible, known values will be substituted here in place of the raw
+ * tokens actually kept in the Exif segment. If no substitution is
+ * available, the value provided by getString(int) will be returned.
+ *
+ * This and getString(int) are the only 'get' methods that won't throw an
+ * exception.
+ * @param tagType the tag to find a description for
+ * @return a description of the image's value for the specified tag, or
+ *
+ * This info is from http://www.funducode.com/freec/Fileformats/format3/format3b.htm
+ */
+ public static final int TAG_JPEG_NUMBER_OF_COMPONENTS = 5;
+
+ // NOTE! Component tag type int values must increment in steps of 1
+
+ /** the first of a possible 4 color components. Number of components specified in TAG_JPEG_NUMBER_OF_COMPONENTS.*/
+ public static final int TAG_JPEG_COMPONENT_DATA_1 = 6;
+ /** the second of a possible 4 color components. Number of components specified in TAG_JPEG_NUMBER_OF_COMPONENTS.*/
+ public static final int TAG_JPEG_COMPONENT_DATA_2 = 7;
+ /** the third of a possible 4 color components. Number of components specified in TAG_JPEG_NUMBER_OF_COMPONENTS.*/
+ public static final int TAG_JPEG_COMPONENT_DATA_3 = 8;
+ /** the fourth of a possible 4 color components. Number of components specified in TAG_JPEG_NUMBER_OF_COMPONENTS.*/
+ public static final int TAG_JPEG_COMPONENT_DATA_4 = 9;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static {
+ tagNameMap.put(new Integer(TAG_JPEG_DATA_PRECISION), "Data Precision");
+ tagNameMap.put(new Integer(TAG_JPEG_IMAGE_WIDTH), "Image Width");
+ tagNameMap.put(new Integer(TAG_JPEG_IMAGE_HEIGHT), "Image Height");
+ tagNameMap.put(new Integer(TAG_JPEG_NUMBER_OF_COMPONENTS), "Number of Components");
+ tagNameMap.put(new Integer(TAG_JPEG_COMPONENT_DATA_1), "Component 1");
+ tagNameMap.put(new Integer(TAG_JPEG_COMPONENT_DATA_2), "Component 2");
+ tagNameMap.put(new Integer(TAG_JPEG_COMPONENT_DATA_3), "Component 3");
+ tagNameMap.put(new Integer(TAG_JPEG_COMPONENT_DATA_4), "Component 4");
+ }
+
+ public JpegDirectory() {
+ this.setDescriptor(new JpegDescriptor(this));
+ }
+
+ public String getName() {
+ return "Jpeg";
+ }
+
+ protected HashMap getTagNameMap() {
+ return tagNameMap;
+ }
+
+ /**
+ *
+ * @param componentNumber The zero-based index of the component. This number is normally between 0 and 3.
+ * Use getNumberOfComponents for bounds-checking.
+ * @return
+ */
+ public JpegComponent getComponent(int componentNumber)
+ {
+ int tagType = JpegDirectory.TAG_JPEG_COMPONENT_DATA_1 + componentNumber;
+
+ JpegComponent component = (JpegComponent)getObject(tagType);
+
+ return component;
+ }
+
+ public int getImageWidth() throws MetadataException
+ {
+ return getInt(JpegDirectory.TAG_JPEG_IMAGE_WIDTH);
+ }
+
+ public int getImageHeight() throws MetadataException
+ {
+ return getInt(JpegDirectory.TAG_JPEG_IMAGE_HEIGHT);
+ }
+
+ public int getNumberOfComponents() throws MetadataException
+ {
+ return getInt(JpegDirectory.TAG_JPEG_NUMBER_OF_COMPONENTS);
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegReader.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegReader.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegReader.java (revision 4231)
@@ -0,0 +1,146 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on Aug 2, 2003 using IntelliJ IDEA.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.imaging.jpeg.JpegProcessingException;
+import com.drew.imaging.jpeg.JpegSegmentReader;
+import com.drew.metadata.Metadata;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.MetadataReader;
+
+import java.io.File;
+import java.io.InputStream;
+
+/**
+ *
+ * @author Darrell Silver http://www.darrellsilver.com and Drew Noakes
+ */
+public class JpegReader implements MetadataReader
+{
+ /**
+ * The SOF0 data segment.
+ */
+ private final byte[] _data;
+
+ /**
+ * Creates a new JpegReader for the specified Jpeg jpegFile.
+ */
+ public JpegReader(File jpegFile) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(jpegFile).readSegment(JpegSegmentReader.SEGMENT_SOF0));
+ }
+
+ /** Creates a JpegReader for a JPEG stream.
+ *
+ * @param is JPEG stream. Stream will be closed.
+ */
+ public JpegReader(InputStream is) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(is).readSegment(JpegSegmentReader.SEGMENT_APPD));
+ }
+
+ public JpegReader(byte[] data)
+ {
+ _data = data;
+ }
+
+ /**
+ * Performs the Jpeg data extraction, returning a new instance of For example, an XML escaper would convert the literal string {@code
+ * "Foo An {@code Escaper} instance is required to be stateless, and safe when
+ * used concurrently by multiple threads.
+ *
+ * Several popular escapers are defined as constants in the class {@link
+ * CharEscapers}. To create your own escapers, use {@link
+ * CharEscaperBuilder}, or extend {@link CharEscaper} or {@code UnicodeEscaper}.
+ *
+ *
+ */
+public interface Escaper {
+ /**
+ * Returns the escaped form of a given literal string.
+ *
+ * Note that this method may treat input characters differently depending on
+ * the specific escaper implementation.
+ * Note that this method may treat input characters differently depending on
+ * the specific escaper implementation.
+ * For details on escaping URIs for use in web pages, see section 2.4 of
+ * RFC 3986.
+ *
+ * In most cases this class should not need to be used directly. If you
+ * have no special requirements for escaping your URIs, you should use either
+ * {@link CharEscapers#uriEscaper()} or
+ * {@link CharEscapers#uriEscaper(boolean)}.
+ *
+ * When encoding a String, the following rules apply:
+ * RFC 2396 specifies the set of unreserved characters as "-", "_", ".", "!",
+ * "~", "*", "'", "(" and ")". It goes on to state:
+ *
+ * Unreserved characters can be escaped without changing the semantics
+ * of the URI, but this should not be done unless the URI is being used
+ * in a context that does not allow the unescaped character to appear.
+ *
+ * For performance reasons the only currently supported character encoding of
+ * this class is UTF-8.
+ *
+ * Note: This escaper produces uppercase hexidecimal sequences. From
+ * RFC 3986: Take care not to confuse precondition checking with other similar types
+ * of checks! Precondition exceptions -- including those provided here, but also
+ * {@link IndexOutOfBoundsException}, {@link NoSuchElementException}, {@link
+ * UnsupportedOperationException} and others -- are used to signal that the
+ * calling method has made an error. This tells the caller that it should
+ * not have invoked the method when it did, with the arguments it did, or
+ * perhaps ever. Postcondition or other invariant failures should not
+ * throw these types of exceptions.
+ *
+ * Note: The methods of the {@code Preconditions} class are highly
+ * unusual in one way: they are supposed to throw exceptions, and promise
+ * in their specifications to do so even when given perfectly valid input. That
+ * is, {@code null} is a valid parameter to the method {@link
+ * #checkNotNull(Object)} -- and technically this parameter could be even marked
+ * as {@link Nullable} -- yet the method will still throw an exception anyway,
+ * because that's what its contract says to do.
+ *
+ * This class may be used with the Google Web Toolkit (GWT).
+ *
+ *
+ */
+public final class Preconditions {
+ private Preconditions() {}
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @throws IllegalArgumentException if {@code expression} is false
+ */
+ public static void checkArgument(boolean expression) {
+ if (!expression) {
+ throw new IllegalArgumentException();
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessage the exception message to use if the check fails; will
+ * be converted to a string using {@link String#valueOf(Object)}
+ * @throws IllegalArgumentException if {@code expression} is false
+ */
+ public static void checkArgument(boolean expression, Object errorMessage) {
+ if (!expression) {
+ throw new IllegalArgumentException(String.valueOf(errorMessage));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving one or more parameters to the
+ * calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the
+ * check fail. The message is formed by replacing each {@code %s}
+ * placeholder in the template with an argument. These are matched by
+ * position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
+ * Unmatched arguments will be appended to the formatted message in square
+ * braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}.
+ * @throws IllegalArgumentException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code
+ * errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
+ * this happen)
+ */
+ public static void checkArgument(boolean expression,
+ String errorMessageTemplate, Object... errorMessageArgs) {
+ if (!expression) {
+ throw new IllegalArgumentException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @throws IllegalStateException if {@code expression} is false
+ */
+ public static void checkState(boolean expression) {
+ if (!expression) {
+ throw new IllegalStateException();
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessage the exception message to use if the check fails; will
+ * be converted to a string using {@link String#valueOf(Object)}
+ * @throws IllegalStateException if {@code expression} is false
+ */
+ public static void checkState(boolean expression, Object errorMessage) {
+ if (!expression) {
+ throw new IllegalStateException(String.valueOf(errorMessage));
+ }
+ }
+
+ /**
+ * Ensures the truth of an expression involving the state of the calling
+ * instance, but not involving any parameters to the calling method.
+ *
+ * @param expression a boolean expression
+ * @param errorMessageTemplate a template for the exception message should the
+ * check fail. The message is formed by replacing each {@code %s}
+ * placeholder in the template with an argument. These are matched by
+ * position - the first {@code %s} gets {@code errorMessageArgs[0]}, etc.
+ * Unmatched arguments will be appended to the formatted message in square
+ * braces. Unmatched placeholders will be left as-is.
+ * @param errorMessageArgs the arguments to be substituted into the message
+ * template. Arguments are converted to strings using
+ * {@link String#valueOf(Object)}.
+ * @throws IllegalStateException if {@code expression} is false
+ * @throws NullPointerException if the check fails and either {@code
+ * errorMessageTemplate} or {@code errorMessageArgs} is null (don't let
+ * this happen)
+ */
+ public static void checkState(boolean expression,
+ String errorMessageTemplate, Object... errorMessageArgs) {
+ if (!expression) {
+ throw new IllegalStateException(
+ format(errorMessageTemplate, errorMessageArgs));
+ }
+ }
+
+ /**
+ * Ensures that an object reference passed as a parameter to the calling
+ * method is not null.
+ *
+ * @param reference an object reference
+ * @return the non-null reference that was validated
+ * @throws NullPointerException if {@code reference} is null
+ */
+ public static For example, an XML escaper would convert the literal string {@code
+ * "Foo Note: This class is similar to {@link CharEscaper} but with one
+ * very important difference. A CharEscaper can only process Java
+ * UTF16 characters in
+ * isolation and may not cope when it encounters surrogate pairs. This class
+ * facilitates the correct escaping of all Unicode characters.
+ *
+ * As there are important reasons, including potential security issues, to
+ * handle Unicode correctly if you are considering implementing a new escaper
+ * you should favor using UnicodeEscaper wherever possible.
+ *
+ * A {@code UnicodeEscaper} instance is required to be stateless, and safe
+ * when used concurrently by multiple threads.
+ *
+ * Several popular escapers are defined as constants in the class {@link
+ * CharEscapers}. To create your own escapers extend this class and implement
+ * the {@link #escape(int)} method.
+ *
+ *
+ */
+public abstract class UnicodeEscaper implements Escaper {
+ /** The amount of padding (chars) to use when growing the escape buffer. */
+ private static final int DEST_PAD = 32;
+
+ /**
+ * Returns the escaped form of the given Unicode code point, or {@code null}
+ * if this code point does not need to be escaped. When called as part of an
+ * escaping operation, the given code point is guaranteed to be in the range
+ * {@code 0 <= cp <= Character#MAX_CODE_POINT}.
+ *
+ * If an empty array is returned, this effectively strips the input
+ * character from the resulting text.
+ *
+ * If the character does not need to be escaped, this method should return
+ * {@code null}, rather than an array containing the character representation
+ * of the code point. This enables the escaping algorithm to perform more
+ * efficiently.
+ *
+ * If the implementation of this method cannot correctly handle a
+ * particular code point then it should either throw an appropriate runtime
+ * exception or return a suitable replacement character. It must never
+ * silently discard invalid input as this may constitute a security risk.
+ *
+ * @param cp the Unicode code point to escape if necessary
+ * @return the replacement characters, or {@code null} if no escaping was
+ * needed
+ */
+ protected abstract char[] escape(int cp);
+
+ /**
+ * Scans a sub-sequence of characters from a given {@link CharSequence},
+ * returning the index of the next character that requires escaping.
+ *
+ * Note: When implementing an escaper, it is a good idea to override
+ * this method for efficiency. The base class implementation determines
+ * successive Unicode code points and invokes {@link #escape(int)} for each of
+ * them. If the semantics of your escaper are such that code points in the
+ * supplementary range are either all escaped or all unescaped, this method
+ * can be implemented more efficiently using {@link CharSequence#charAt(int)}.
+ *
+ * Note however that if your escaper does not escape characters in the
+ * supplementary range, you should either continue to validate the correctness
+ * of any surrogate characters encountered or provide a clear warning to users
+ * that your escaper does not validate its input.
+ *
+ * See {@link PercentEscaper} for an example.
+ *
+ * @param csq a sequence of characters
+ * @param start the index of the first character to be scanned
+ * @param end the index immediately after the last character to be scanned
+ * @throws IllegalArgumentException if the scanned sub-sequence of {@code csq}
+ * contains invalid surrogate pairs
+ */
+ protected int nextEscapeIndex(CharSequence csq, int start, int end) {
+ int index = start;
+ while (index < end) {
+ int cp = codePointAt(csq, index, end);
+ if (cp < 0 || escape(cp) != null) {
+ break;
+ }
+ index += Character.isSupplementaryCodePoint(cp) ? 2 : 1;
+ }
+ return index;
+ }
+
+ /**
+ * Returns the escaped form of a given literal string.
+ *
+ * If you are escaping input in arbitrary successive chunks, then it is not
+ * generally safe to use this method. If an input string ends with an
+ * unmatched high surrogate character, then this method will throw
+ * {@link IllegalArgumentException}. You should either ensure your input is
+ * valid UTF-16 before
+ * calling this method or use an escaped {@link Appendable} (as returned by
+ * {@link #escape(Appendable)}) which can cope with arbitrarily split input.
+ *
+ * Note: When implementing an escaper it is a good idea to override
+ * this method for efficiency by inlining the implementation of
+ * {@link #nextEscapeIndex(CharSequence, int, int)} directly. Doing this for
+ * {@link PercentEscaper} more than doubled the performance for unescaped
+ * strings (as measured by {@link CharEscapersBenchmark}).
+ *
+ * @param string the literal string to be escaped
+ * @return the escaped form of {@code string}
+ * @throws NullPointerException if {@code string} is null
+ * @throws IllegalArgumentException if invalid surrogate characters are
+ * encountered
+ */
+ public String escape(String string) {
+ int end = string.length();
+ int index = nextEscapeIndex(string, 0, end);
+ return index == end ? string : escapeSlow(string, index);
+ }
+
+ /**
+ * Returns the escaped form of a given literal string, starting at the given
+ * index. This method is called by the {@link #escape(String)} method when it
+ * discovers that escaping is required. It is protected to allow subclasses
+ * to override the fastpath escaping function to inline their escaping test.
+ * See {@link CharEscaperBuilder} for an example usage.
+ *
+ * This method is not reentrant and may only be invoked by the top level
+ * {@link #escape(String)} method.
+ *
+ * @param s the literal string to be escaped
+ * @param index the index to start escaping from
+ * @return the escaped form of {@code string}
+ * @throws NullPointerException if {@code string} is null
+ * @throws IllegalArgumentException if invalid surrogate characters are
+ * encountered
+ */
+ protected final String escapeSlow(String s, int index) {
+ int end = s.length();
+
+ // Get a destination buffer and setup some loop variables.
+ char[] dest = DEST_TL.get();
+ int destIndex = 0;
+ int unescapedChunkStart = 0;
+
+ while (index < end) {
+ int cp = codePointAt(s, index, end);
+ if (cp < 0) {
+ throw new IllegalArgumentException(
+ "Trailing high surrogate at end of input");
+ }
+ char[] escaped = escape(cp);
+ if (escaped != null) {
+ int charsSkipped = index - unescapedChunkStart;
+
+ // This is the size needed to add the replacement, not the full
+ // size needed by the string. We only regrow when we absolutely must.
+ int sizeNeeded = destIndex + charsSkipped + escaped.length;
+ if (dest.length < sizeNeeded) {
+ int destLength = sizeNeeded + (end - index) + DEST_PAD;
+ dest = growBuffer(dest, destIndex, destLength);
+ }
+ // If we have skipped any characters, we need to copy them now.
+ if (charsSkipped > 0) {
+ s.getChars(unescapedChunkStart, index, dest, destIndex);
+ destIndex += charsSkipped;
+ }
+ if (escaped.length > 0) {
+ System.arraycopy(escaped, 0, dest, destIndex, escaped.length);
+ destIndex += escaped.length;
+ }
+ }
+ unescapedChunkStart
+ = index + (Character.isSupplementaryCodePoint(cp) ? 2 : 1);
+ index = nextEscapeIndex(s, unescapedChunkStart, end);
+ }
+
+ // Process trailing unescaped characters - no need to account for escaped
+ // length or padding the allocation.
+ int charsSkipped = end - unescapedChunkStart;
+ if (charsSkipped > 0) {
+ int endIndex = destIndex + charsSkipped;
+ if (dest.length < endIndex) {
+ dest = growBuffer(dest, destIndex, endIndex);
+ }
+ s.getChars(unescapedChunkStart, end, dest, destIndex);
+ destIndex = endIndex;
+ }
+ return new String(dest, 0, destIndex);
+ }
+
+ /**
+ * Returns an {@code Appendable} instance which automatically escapes all
+ * text appended to it before passing the resulting text to an underlying
+ * {@code Appendable}.
+ *
+ * Unlike {@link #escape(String)} it is permitted to append arbitrarily
+ * split input to this Appendable, including input that is split over a
+ * surrogate pair. In this case the pending high surrogate character will not
+ * be processed until the corresponding low surrogate is appended. This means
+ * that a trailing high surrogate character at the end of the input cannot be
+ * detected and will be silently ignored. This is unavoidable since the
+ * Appendable interface has no {@code close()} method, and it is impossible to
+ * determine when the last characters have been appended.
+ *
+ * The methods of the returned object will propagate any exceptions thrown
+ * by the underlying {@code Appendable}.
+ *
+ * For well formed UTF-16
+ * the escaping behavior is identical to that of {@link #escape(String)} and
+ * the following code is equivalent to (but much slower than)
+ * {@code escaper.escape(string)}: Unlike {@link Character#codePointAt(CharSequence, int)} or
+ * {@link String#codePointAt(int)} this method will never fail silently when
+ * encountering an invalid surrogate pair.
+ *
+ * The behaviour of this method is as follows:
+ *
+ * Helper method that adds any OAuth parameters to the given request
+ * parameters which are missing from the current request but required for
+ * signing. A good example is the oauth_nonce parameter, which is typically
+ * not provided by the client in advance.
+ *
+ * It's probably not a very good idea to override this method. If you want
+ * to generate different nonces or timestamps, override
+ * {@link #generateNonce()} or {@link #generateTimestamp()} instead.
+ *
+ * Implemented by subclasses. The responsibility of this method is to
+ * contact the service provider at the given endpoint URL and fetch a
+ * request or access token. What kind of token is retrieved solely depends
+ * on the URL being used.
+ *
+ * Correct implementations of this method must guarantee the following
+ * post-conditions:
+ *
+ * Exposes a simple interface to sign HTTP requests using a given OAuth token
+ * and secret. Refer to {@link OAuthProvider} how to retrieve a valid token and
+ * token secret.
+ *
+ * HTTP messages are signed as follows:
+ *
+ *
+ *
+ * Causes the consumer to always include the oauth_token parameter to be
+ * sent, even if blank. If you're seeing 401s during calls to
+ * {@link OAuthProvider#retrieveRequestToken}, try setting this to true.
+ *
+ * Signs the given HTTP request by writing an OAuth signature (and other
+ * required OAuth parameters) to it. Where these parameters are written
+ * depends on the current {@link SigningStrategy}.
+ *
+ * "Signs" the given URL by appending all OAuth parameters to it which are
+ * required for message signing. The assumed HTTP method is GET.
+ * Essentially, this is equivalent to signing an HTTP GET request, but it
+ * can be useful if your application requires clickable links to protected
+ * resources, i.e. when your application does not have access to the actual
+ * request that is being sent.
+ *
+ * Supplies an interface that can be used to retrieve request and access tokens
+ * from an OAuth 1.0(a) service provider. A provider object requires an
+ * {@link OAuthConsumer} to sign the token request message; after a token has
+ * been retrieved, the consumer is automatically updated with the token and the
+ * corresponding secret.
+ *
+ * To initiate the token exchange, create a new provider instance and configure
+ * it with the URLs the service provider exposes for requesting tokens and
+ * resource authorization, e.g.:
+ *
+ * Depending on the HTTP library you use, you may need a different provider
+ * type, refer to the website documentation for how to do that.
+ *
+ * To receive a request token which the user must authorize, you invoke it using
+ * a consumer instance and a callback URL:
+ *
+ *
+ *
+ * That url must be opened in a Web browser, where the user can grant access to
+ * the resources in question. If that succeeds, the service provider will
+ * redirect to the callback URL and append the blessed request token.
+ *
+ * That token must now be exchanged for an access token, as such:
+ *
+ *
+ * null if the tag hasn't been defined.
+ */
+ public abstract String getDescription(int tagType) throws MetadataException;
+}
Index: /trunk/src/com/drew/metadata/exif/CanonMakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/CanonMakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/CanonMakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,716 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:12:05 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ *
+ */
+public class CanonMakernoteDescriptor extends TagDescriptor
+{
+ public CanonMakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType) {
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_ACTIVITY:
+ return getFlashActivityDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_TYPE:
+ return getFocusTypeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_DIGITAL_ZOOM:
+ return getDigitalZoomDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_QUALITY:
+ return getQualityDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_MACRO_MODE:
+ return getMacroModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_SELF_TIMER_DELAY:
+ return getSelfTimerDelayDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_MODE:
+ return getFlashModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_CONTINUOUS_DRIVE_MODE:
+ return getContinuousDriveModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_1:
+ return getFocusMode1Description();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_IMAGE_SIZE:
+ return getImageSizeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_EASY_SHOOTING_MODE:
+ return getEasyShootingModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_CONTRAST:
+ return getContrastDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_SATURATION:
+ return getSaturationDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_SHARPNESS:
+ return getSharpnessDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_ISO:
+ return getIsoDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_METERING_MODE:
+ return getMeteringModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_AF_POINT_SELECTED:
+ return getAfPointSelectedDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_EXPOSURE_MODE:
+ return getExposureModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_LONG_FOCAL_LENGTH:
+ return getLongFocalLengthDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_SHORT_FOCAL_LENGTH:
+ return getShortFocalLengthDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FOCAL_UNITS_PER_MM:
+ return getFocalUnitsPerMillimetreDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_DETAILS:
+ return getFlashDetailsDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_2:
+ return getFocusMode2Description();
+ case CanonMakernoteDirectory.TAG_CANON_STATE2_WHITE_BALANCE:
+ return getWhiteBalanceDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE2_AF_POINT_USED:
+ return getAfPointUsedDescription();
+ case CanonMakernoteDirectory.TAG_CANON_STATE2_FLASH_BIAS:
+ return getFlashBiasDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_LONG_EXPOSURE_NOISE_REDUCTION:
+ return getLongExposureNoiseReductionDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_AUTO_EXPOSURE_LOCK_BUTTONS:
+ return getShutterAutoExposureLockButtonDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MIRROR_LOCKUP:
+ return getMirrorLockupDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_TV_AV_AND_EXPOSURE_LEVEL:
+ return getTvAndAvExposureLevelDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_ASSIST_LIGHT:
+ return getAutoFocusAssistLightDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_SPEED_IN_AV_MODE:
+ return getShutterSpeedInAvModeDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_BRACKETTING:
+ return getAutoExposureBrackettingSequenceAndAutoCancellationDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_CURTAIN_SYNC:
+ return getShutterCurtainSyncDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_STOP:
+ return getLensAutoFocusStopButtonDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_FILL_FLASH_REDUCTION:
+ return getFillFlashReductionDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MENU_BUTTON_RETURN:
+ return getMenuButtonReturnPositionDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SET_BUTTON_FUNCTION:
+ return getSetButtonFunctionWhenShootingDescription();
+ case CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SENSOR_CLEANING:
+ return getSensorCleaningDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getLongExposureNoiseReductionDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_LONG_EXPOSURE_NOISE_REDUCTION)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_LONG_EXPOSURE_NOISE_REDUCTION);
+ switch (value) {
+ case 0: return "Off";
+ case 1: return "On";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getShutterAutoExposureLockButtonDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_AUTO_EXPOSURE_LOCK_BUTTONS)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_AUTO_EXPOSURE_LOCK_BUTTONS);
+ switch (value) {
+ case 0: return "AF/AE lock";
+ case 1: return "AE lock/AF";
+ case 2: return "AF/AF lock";
+ case 3: return "AE+release/AE+AF";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getMirrorLockupDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MIRROR_LOCKUP)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MIRROR_LOCKUP);
+ switch (value) {
+ case 0: return "Disabled";
+ case 1: return "Enabled";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getTvAndAvExposureLevelDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_TV_AV_AND_EXPOSURE_LEVEL)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_TV_AV_AND_EXPOSURE_LEVEL);
+ switch (value) {
+ case 0: return "1/2 stop";
+ case 1: return "1/3 stop";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getAutoFocusAssistLightDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_ASSIST_LIGHT)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_ASSIST_LIGHT);
+ switch (value) {
+ case 0: return "On (Auto)";
+ case 1: return "Off";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getShutterSpeedInAvModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_SPEED_IN_AV_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_SPEED_IN_AV_MODE);
+ switch (value) {
+ case 0: return "Automatic";
+ case 1: return "1/200 (fixed)";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getAutoExposureBrackettingSequenceAndAutoCancellationDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_BRACKETTING)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_BRACKETTING);
+ switch (value) {
+ case 0: return "0,-,+ / Enabled";
+ case 1: return "0,-,+ / Disabled";
+ case 2: return "-,0,+ / Enabled";
+ case 3: return "-,0,+ / Disabled";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getShutterCurtainSyncDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_CURTAIN_SYNC)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SHUTTER_CURTAIN_SYNC);
+ switch (value) {
+ case 0: return "1st Curtain Sync";
+ case 1: return "2nd Curtain Sync";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getLensAutoFocusStopButtonDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_STOP)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_AF_STOP);
+ switch (value) {
+ case 0: return "AF stop";
+ case 1: return "Operate AF";
+ case 2: return "Lock AE and start timer";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getFillFlashReductionDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_FILL_FLASH_REDUCTION)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_FILL_FLASH_REDUCTION);
+ switch (value) {
+ case 0: return "Enabled";
+ case 1: return "Disabled";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getMenuButtonReturnPositionDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MENU_BUTTON_RETURN)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_MENU_BUTTON_RETURN);
+ switch (value) {
+ case 0: return "Top";
+ case 1: return "Previous (volatile)";
+ case 2: return "Previous";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getSetButtonFunctionWhenShootingDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SET_BUTTON_FUNCTION)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SET_BUTTON_FUNCTION);
+ switch (value) {
+ case 0: return "Not Assigned";
+ case 1: return "Change Quality";
+ case 2: return "Change ISO Speed";
+ case 3: return "Select Parameters";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+ public String getSensorCleaningDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SENSOR_CLEANING)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_CUSTOM_FUNCTION_SENSOR_CLEANING);
+ switch (value) {
+ case 0: return "Disabled";
+ case 1: return "Enabled";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashBiasDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE2_FLASH_BIAS)) return null;
+
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE2_FLASH_BIAS);
+
+ boolean isNegative = false;
+ if (value > 0xF000)
+ {
+ isNegative = true;
+ value = 0xFFFF - value;
+ value++;
+ }
+
+ // this tag is interesting in that the values returned are:
+ // 0, 0.375, 0.5, 0.626, 1
+ // not
+ // 0, 0.33, 0.5, 0.66, 1
+
+ return ((isNegative) ? "-" : "") + Float.toString(value / 32f) + " EV";
+ }
+
+ public String getAfPointUsedDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE2_AF_POINT_USED)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE2_AF_POINT_USED);
+ if ((value & 0x7) == 0) {
+ return "Right";
+ } else if ((value & 0x7) == 1) {
+ return "Centre";
+ } else if ((value & 0x7) == 2) {
+ return "Left";
+ } else {
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getWhiteBalanceDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE2_WHITE_BALANCE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE2_WHITE_BALANCE);
+ switch (value) {
+ case 0:
+ return "Auto";
+ case 1:
+ return "Sunny";
+ case 2:
+ return "Cloudy";
+ case 3:
+ return "Tungsten";
+ case 4:
+ return "Flourescent";
+ case 5:
+ return "Flash";
+ case 6:
+ return "Custom";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFocusMode2Description() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_2)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_2);
+ switch (value) {
+ case 0:
+ return "Single";
+ case 1:
+ return "Continuous";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashDetailsDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_DETAILS)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_DETAILS);
+ if (((value << 14) & 1) > 0) {
+ return "External E-TTL";
+ }
+ if (((value << 13) & 1) > 0) {
+ return "Internal flash";
+ }
+ if (((value << 11) & 1) > 0) {
+ return "FP sync used";
+ }
+ if (((value << 4) & 1) > 0) {
+ return "FP sync enabled";
+ }
+ return "Unknown (" + value + ")";
+ }
+
+ public String getFocalUnitsPerMillimetreDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCAL_UNITS_PER_MM)) return "";
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCAL_UNITS_PER_MM);
+ if (value != 0) {
+ return Integer.toString(value);
+ } else {
+ return "";
+ }
+ }
+
+ public String getShortFocalLengthDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_SHORT_FOCAL_LENGTH)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_SHORT_FOCAL_LENGTH);
+ String units = getFocalUnitsPerMillimetreDescription();
+ return Integer.toString(value) + " " + units;
+ }
+
+ public String getLongFocalLengthDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_LONG_FOCAL_LENGTH)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_LONG_FOCAL_LENGTH);
+ String units = getFocalUnitsPerMillimetreDescription();
+ return Integer.toString(value) + " " + units;
+ }
+
+ public String getExposureModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_EXPOSURE_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_EXPOSURE_MODE);
+ switch (value) {
+ case 0:
+ return "Easy shooting";
+ case 1:
+ return "Program";
+ case 2:
+ return "Tv-priority";
+ case 3:
+ return "Av-priority";
+ case 4:
+ return "Manual";
+ case 5:
+ return "A-DEP";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getAfPointSelectedDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_AF_POINT_SELECTED)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_AF_POINT_SELECTED);
+ switch (value) {
+ case 0x3000:
+ return "None (MF)";
+ case 0x3001:
+ return "Auto selected";
+ case 0x3002:
+ return "Right";
+ case 0x3003:
+ return "Centre";
+ case 0x3004:
+ return "Left";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getMeteringModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_METERING_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_METERING_MODE);
+ switch (value) {
+ case 3:
+ return "Evaluative";
+ case 4:
+ return "Partial";
+ case 5:
+ return "Centre weighted";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getIsoDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_ISO)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_ISO);
+ switch (value) {
+ case 0:
+ return "Not specified (see ISOSpeedRatings tag)";
+ case 15:
+ return "Auto";
+ case 16:
+ return "50";
+ case 17:
+ return "100";
+ case 18:
+ return "200";
+ case 19:
+ return "400";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSharpnessDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_SHARPNESS)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_SHARPNESS);
+ switch (value) {
+ case 0xFFFF:
+ return "Low";
+ case 0x000:
+ return "Normal";
+ case 0x001:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSaturationDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_SATURATION)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_SATURATION);
+ switch (value) {
+ case 0xFFFF:
+ return "Low";
+ case 0x000:
+ return "Normal";
+ case 0x001:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getContrastDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_CONTRAST)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_CONTRAST);
+ switch (value) {
+ case 0xFFFF:
+ return "Low";
+ case 0x000:
+ return "Normal";
+ case 0x001:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getEasyShootingModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_EASY_SHOOTING_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_EASY_SHOOTING_MODE);
+ switch (value) {
+ case 0:
+ return "Full auto";
+ case 1:
+ return "Manual";
+ case 2:
+ return "Landscape";
+ case 3:
+ return "Fast shutter";
+ case 4:
+ return "Slow shutter";
+ case 5:
+ return "Night";
+ case 6:
+ return "B&W";
+ case 7:
+ return "Sepia";
+ case 8:
+ return "Portrait";
+ case 9:
+ return "Sports";
+ case 10:
+ return "Macro / Closeup";
+ case 11:
+ return "Pan focus";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getImageSizeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_IMAGE_SIZE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_IMAGE_SIZE);
+ switch (value) {
+ case 0:
+ return "Large";
+ case 1:
+ return "Medium";
+ case 2:
+ return "Small";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFocusMode1Description() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_1)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_MODE_1);
+ switch (value) {
+ case 0:
+ return "One-shot";
+ case 1:
+ return "AI Servo";
+ case 2:
+ return "AI Focus";
+ case 3:
+ return "Manual Focus";
+ case 4:
+ // TODO should check field 32 here (FOCUS_MODE_2)
+ return "Single";
+ case 5:
+ return "Continuous";
+ case 6:
+ return "Manual Focus";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getContinuousDriveModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_CONTINUOUS_DRIVE_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_CONTINUOUS_DRIVE_MODE);
+ switch (value) {
+ case 0:
+ if (_directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_SELF_TIMER_DELAY) == 0) {
+ return "Single shot";
+ } else {
+ return "Single shot with self-timer";
+ }
+ case 1:
+ return "Continuous";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_MODE);
+ switch (value) {
+ case 0:
+ return "No flash fired";
+ case 1:
+ return "Auto";
+ case 2:
+ return "On";
+ case 3:
+ return "Red-eye reduction";
+ case 4:
+ return "Slow-synchro";
+ case 5:
+ return "Auto and red-eye reduction";
+ case 6:
+ return "On and red-eye reduction";
+ case 16:
+ // note: this value not set on Canon D30
+ return "Extenal flash";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSelfTimerDelayDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_SELF_TIMER_DELAY)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_SELF_TIMER_DELAY);
+ if (value == 0) {
+ return "Self timer not used";
+ } else {
+ // TODO find an image that tests this calculation
+ return Double.toString((double)value * 0.1d) + " sec";
+ }
+ }
+
+ public String getMacroModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_MACRO_MODE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_MACRO_MODE);
+ switch (value) {
+ case 1:
+ return "Macro";
+ case 2:
+ return "Normal";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getQualityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_QUALITY)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_QUALITY);
+ switch (value) {
+ case 2:
+ return "Normal";
+ case 3:
+ return "Fine";
+ case 5:
+ return "Superfine";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getDigitalZoomDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_DIGITAL_ZOOM)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_DIGITAL_ZOOM);
+ switch (value) {
+ case 0:
+ return "No digital zoom";
+ case 1:
+ return "2x";
+ case 2:
+ return "4x";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFocusTypeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_TYPE)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FOCUS_TYPE);
+ switch (value) {
+ case 0:
+ return "Manual";
+ case 1:
+ return "Auto";
+ case 3:
+ return "Close-up (Macro)";
+ case 8:
+ return "Locked (Pan Mode)";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashActivityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_ACTIVITY)) return null;
+ int value = _directory.getInt(CanonMakernoteDirectory.TAG_CANON_STATE1_FLASH_ACTIVITY);
+ switch (value) {
+ case 0:
+ return "Flash did not fire";
+ case 1:
+ return "Flash fired";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/CanonMakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/CanonMakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/CanonMakernoteDirectory.java (revision 4231)
@@ -0,0 +1,448 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * Describes tags specific to Canon cameras.
+ *
+ * Thanks to Bill Richards for his contribution to this makernote directory.
+ *
+ * Many tag definitions explained here: http://www.ozhiker.com/electronics/pjmt/jpeg_info/canon_mn.html
+ */
+public class CanonMakernoteDirectory extends Directory
+{
+ // CANON cameras have some funny bespoke fields that need further processing...
+ public static final int TAG_CANON_CAMERA_STATE_1 = 0x0001;
+ public static final int TAG_CANON_CAMERA_STATE_2 = 0x0004;
+
+ public static final int TAG_CANON_IMAGE_TYPE = 0x0006;
+ public static final int TAG_CANON_FIRMWARE_VERSION = 0x0007;
+ public static final int TAG_CANON_IMAGE_NUMBER = 0x0008;
+ public static final int TAG_CANON_OWNER_NAME = 0x0009;
+ /**
+ * To display serial number as on camera use: printf( "%04X%05d", highbyte, lowbyte )
+ * TODO handle this in CanonMakernoteDescriptor
+ */
+ public static final int TAG_CANON_SERIAL_NUMBER = 0x000C;
+ public static final int TAG_CANON_UNKNOWN_1 = 0x000D;
+ public static final int TAG_CANON_CUSTOM_FUNCTIONS = 0x000F;
+
+ // These 'sub'-tag values have been created for consistency -- they don't exist within the exif segment
+ /**
+ * 1 = Macro
+ * 2 = Normal
+ */
+ public static final int TAG_CANON_STATE1_MACRO_MODE = 0xC101;
+ public static final int TAG_CANON_STATE1_SELF_TIMER_DELAY = 0xC102;
+ /**
+ * 2 = Normal
+ * 3 = Fine
+ * 5 = Superfine
+ */
+ public static final int TAG_CANON_STATE1_QUALITY = 0xC103;
+ /**
+ * 0 = Flash Not Fired
+ * 1 = Auto
+ * 2 = On
+ * 3 = Red Eye Reduction
+ * 4 = Slow Synchro
+ * 5 = Auto + Red Eye Reduction
+ * 6 = On + Red Eye Reduction
+ * 16 = External Flash
+ */
+ public static final int TAG_CANON_STATE1_FLASH_MODE = 0xC104;
+ /**
+ * 0 = Single Frame or Timer Mode
+ * 1 = Continuous
+ */
+ public static final int TAG_CANON_STATE1_CONTINUOUS_DRIVE_MODE = 0xC105;
+ public static final int TAG_CANON_STATE1_UNKNOWN_2 = 0xC106;
+ /**
+ * 0 = One-Shot
+ * 1 = AI Servo
+ * 2 = AI Focus
+ * 3 = Manual Focus
+ * 4 = Single
+ * 5 = Continuous
+ * 6 = Manual Focus
+ */
+ public static final int TAG_CANON_STATE1_FOCUS_MODE_1 = 0xC107;
+ public static final int TAG_CANON_STATE1_UNKNOWN_3 = 0xC108;
+ public static final int TAG_CANON_STATE1_UNKNOWN_4 = 0xC109;
+ /**
+ * 0 = Large
+ * 1 = Medium
+ * 2 = Small
+ */
+ public static final int TAG_CANON_STATE1_IMAGE_SIZE = 0xC10A;
+ /**
+ * 0 = Full Auto
+ * 1 = Manual
+ * 2 = Landscape
+ * 3 = Fast Shutter
+ * 4 = Slow Shutter
+ * 5 = Night
+ * 6 = Black & White
+ * 7 = Sepia
+ * 8 = Portrait
+ * 9 = Sports
+ * 10 = Macro / Close-Up
+ * 11 = Pan Focus
+ */
+ public static final int TAG_CANON_STATE1_EASY_SHOOTING_MODE = 0xC10B;
+ /**
+ * 0 = No Digital Zoom
+ * 1 = 2x
+ * 2 = 4x
+ */
+ public static final int TAG_CANON_STATE1_DIGITAL_ZOOM = 0xC10C;
+ /**
+ * 0 = Normal
+ * 1 = High
+ * 65535 = Low
+ */
+ public static final int TAG_CANON_STATE1_CONTRAST = 0xC10D;
+ /**
+ * 0 = Normal
+ * 1 = High
+ * 65535 = Low
+ */
+ public static final int TAG_CANON_STATE1_SATURATION = 0xC10E;
+ /**
+ * 0 = Normal
+ * 1 = High
+ * 65535 = Low
+ */
+ public static final int TAG_CANON_STATE1_SHARPNESS = 0xC10F;
+ /**
+ * 0 = Check ISOSpeedRatings EXIF tag for ISO Speed
+ * 15 = Auto ISO
+ * 16 = ISO 50
+ * 17 = ISO 100
+ * 18 = ISO 200
+ * 19 = ISO 400
+ */
+ public static final int TAG_CANON_STATE1_ISO = 0xC110;
+ /**
+ * 3 = Evaluative
+ * 4 = Partial
+ * 5 = Centre Weighted
+ */
+ public static final int TAG_CANON_STATE1_METERING_MODE = 0xC111;
+ /**
+ * 0 = Manual
+ * 1 = Auto
+ * 3 = Close-up (Macro)
+ * 8 = Locked (Pan Mode)
+ */
+ public static final int TAG_CANON_STATE1_FOCUS_TYPE = 0xC112;
+ /**
+ * 12288 = None (Manual Focus)
+ * 12289 = Auto Selected
+ * 12290 = Right
+ * 12291 = Centre
+ * 12292 = Left
+ */
+ public static final int TAG_CANON_STATE1_AF_POINT_SELECTED = 0xC113;
+ /**
+ * 0 = Easy Shooting (See Easy Shooting Mode)
+ * 1 = Program
+ * 2 = Tv-Priority
+ * 3 = Av-Priority
+ * 4 = Manual
+ * 5 = A-DEP
+ */
+ public static final int TAG_CANON_STATE1_EXPOSURE_MODE = 0xC114;
+ public static final int TAG_CANON_STATE1_UNKNOWN_7 = 0xC115;
+ public static final int TAG_CANON_STATE1_UNKNOWN_8 = 0xC116;
+ public static final int TAG_CANON_STATE1_LONG_FOCAL_LENGTH = 0xC117;
+ public static final int TAG_CANON_STATE1_SHORT_FOCAL_LENGTH = 0xC118;
+ public static final int TAG_CANON_STATE1_FOCAL_UNITS_PER_MM = 0xC119;
+ public static final int TAG_CANON_STATE1_UNKNOWN_9 = 0xC11A;
+ public static final int TAG_CANON_STATE1_UNKNOWN_10 = 0xC11B;
+ /**
+ * 0 = Flash Did Not Fire
+ * 1 = Flash Fired
+ */
+ public static final int TAG_CANON_STATE1_FLASH_ACTIVITY = 0xC11C;
+ public static final int TAG_CANON_STATE1_FLASH_DETAILS = 0xC11D;
+ public static final int TAG_CANON_STATE1_UNKNOWN_12 = 0xC11E;
+ public static final int TAG_CANON_STATE1_UNKNOWN_13 = 0xC11F;
+ /**
+ * 0 = Focus Mode: Single
+ * 1 = Focus Mode: Continuous
+ */
+ public static final int TAG_CANON_STATE1_FOCUS_MODE_2 = 0xC120;
+
+ /**
+ * 0 = Auto
+ * 1 = Sunny
+ * 2 = Cloudy
+ * 3 = Tungsten
+ * 4 = Flourescent
+ * 5 = Flash
+ * 6 = Custom
+ */
+ public static final int TAG_CANON_STATE2_WHITE_BALANCE = 0xC207;
+ public static final int TAG_CANON_STATE2_SEQUENCE_NUMBER = 0xC209;
+ public static final int TAG_CANON_STATE2_AF_POINT_USED = 0xC20E;
+ /**
+ * The value of this tag may be translated into a flash bias value, in EV.
+ *
+ * 0xffc0 = -2 EV
+ * 0xffcc = -1.67 EV
+ * 0xffd0 = -1.5 EV
+ * 0xffd4 = -1.33 EV
+ * 0xffe0 = -1 EV
+ * 0xffec = -0.67 EV
+ * 0xfff0 = -0.5 EV
+ * 0xfff4 = -0.33 EV
+ * 0x0000 = 0 EV
+ * 0x000c = 0.33 EV
+ * 0x0010 = 0.5 EV
+ * 0x0014 = 0.67 EV
+ * 0x0020 = 1 EV
+ * 0x002c = 1.33 EV
+ * 0x0030 = 1.5 EV
+ * 0x0034 = 1.67 EV
+ * 0x0040 = 2 EV
+ */
+ public static final int TAG_CANON_STATE2_FLASH_BIAS = 0xC20F;
+ public static final int TAG_CANON_STATE2_AUTO_EXPOSURE_BRACKETING = 0xC210;
+ public static final int TAG_CANON_STATE2_AEB_BRACKET_VALUE = 0xC211;
+ public static final int TAG_CANON_STATE2_SUBJECT_DISTANCE = 0xC213;
+
+ /**
+ * Long Exposure Noise Reduction
+ * 0 = Off
+ * 1 = On
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_LONG_EXPOSURE_NOISE_REDUCTION = 0xC301;
+
+ /**
+ * Shutter/Auto Exposure-lock buttons
+ * 0 = AF/AE lock
+ * 1 = AE lock/AF
+ * 2 = AF/AF lock
+ * 3 = AE+release/AE+AF
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_SHUTTER_AUTO_EXPOSURE_LOCK_BUTTONS = 0xC302;
+
+ /**
+ * Mirror lockup
+ * 0 = Disable
+ * 1 = Enable
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_MIRROR_LOCKUP = 0xC303;
+
+ /**
+ * Tv/Av and exposure level
+ * 0 = 1/2 stop
+ * 1 = 1/3 stop
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_TV_AV_AND_EXPOSURE_LEVEL = 0xC304;
+
+ /**
+ * AF-assist light
+ * 0 = On (Auto)
+ * 1 = Off
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_AF_ASSIST_LIGHT = 0xC305;
+
+ /**
+ * Shutter speed in Av mode
+ * 0 = Automatic
+ * 1 = 1/200 (fixed)
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_SHUTTER_SPEED_IN_AV_MODE = 0xC306;
+
+ /**
+ * Auto-Exposure Bracketting sequence/auto cancellation
+ * 0 = 0,-,+ / Enabled
+ * 1 = 0,-,+ / Disabled
+ * 2 = -,0,+ / Enabled
+ * 3 = -,0,+ / Disabled
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_BRACKETTING = 0xC307;
+
+ /**
+ * Shutter Curtain Sync
+ * 0 = 1st Curtain Sync
+ * 1 = 2nd Curtain Sync
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_SHUTTER_CURTAIN_SYNC = 0xC308;
+
+ /**
+ * Lens Auto-Focus stop button Function Switch
+ * 0 = AF stop
+ * 1 = Operate AF
+ * 2 = Lock AE and start timer
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_AF_STOP = 0xC309;
+
+ /**
+ * Auto reduction of fill flash
+ * 0 = Enable
+ * 1 = Disable
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_FILL_FLASH_REDUCTION = 0xC30A;
+
+ /**
+ * Menu button return position
+ * 0 = Top
+ * 1 = Previous (volatile)
+ * 2 = Previous
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_MENU_BUTTON_RETURN = 0xC30B;
+
+ /**
+ * SET button function when shooting
+ * 0 = Not Assigned
+ * 1 = Change Quality
+ * 2 = Change ISO Speed
+ * 3 = Select Parameters
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_SET_BUTTON_FUNCTION = 0xC30C;
+
+ /**
+ * Sensor cleaning
+ * 0 = Disable
+ * 1 = Enable
+ */
+ public static final int TAG_CANON_CUSTOM_FUNCTION_SENSOR_CLEANING = 0xC30D;
+
+ // 9 A B C D E F 10 11 12 13
+ // 9 10 11 12 13 14 15 16 17 18 19
+ protected static final HashMap _tagNameMap = new HashMap();
+
+ static
+ {
+ _tagNameMap.put(new Integer(TAG_CANON_FIRMWARE_VERSION), "Firmware Version");
+ _tagNameMap.put(new Integer(TAG_CANON_IMAGE_NUMBER), "Image Number");
+ _tagNameMap.put(new Integer(TAG_CANON_IMAGE_TYPE), "Image Type");
+ _tagNameMap.put(new Integer(TAG_CANON_OWNER_NAME), "Owner Name");
+ _tagNameMap.put(new Integer(TAG_CANON_UNKNOWN_1), "Makernote Unknown 1");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTIONS), "Custom Functions");
+ _tagNameMap.put(new Integer(TAG_CANON_SERIAL_NUMBER), "Camera Serial Number");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_AF_POINT_SELECTED), "AF Point Selected");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_CONTINUOUS_DRIVE_MODE), "Continuous Drive Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_CONTRAST), "Contrast");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_EASY_SHOOTING_MODE), "Easy Shooting Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_EXPOSURE_MODE), "Exposure Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FLASH_DETAILS), "Flash Details");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FLASH_MODE), "Flash Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FOCAL_UNITS_PER_MM), "Focal Units per mm");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FOCUS_MODE_1), "Focus Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FOCUS_MODE_2), "Focus Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_IMAGE_SIZE), "Image Size");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_ISO), "Iso");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_LONG_FOCAL_LENGTH), "Long Focal Length");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_MACRO_MODE), "Macro Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_METERING_MODE), "Metering Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_SATURATION), "Saturation");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_SELF_TIMER_DELAY), "Self Timer Delay");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_SHARPNESS), "Sharpness");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_SHORT_FOCAL_LENGTH), "Short Focal Length");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_QUALITY), "Quality");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_2), "Unknown Camera State 2");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_3), "Unknown Camera State 3");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_4), "Unknown Camera State 4");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_DIGITAL_ZOOM), "Digital Zoom");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FOCUS_TYPE), "Focus Type");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_7), "Unknown Camera State 7");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_8), "Unknown Camera State 8");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_9), "Unknown Camera State 9");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_10), "Unknown Camera State 10");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_FLASH_ACTIVITY), "Flash Activity");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_12), "Unknown Camera State 12");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE1_UNKNOWN_13), "Unknown Camera State 13");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_WHITE_BALANCE), "White Balance");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_SEQUENCE_NUMBER), "Sequence Number");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_AF_POINT_USED), "AF Point Used");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_FLASH_BIAS), "Flash Bias");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_AUTO_EXPOSURE_BRACKETING), "Auto Exposure Bracketing");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_AEB_BRACKET_VALUE), "AEB Bracket Value");
+ _tagNameMap.put(new Integer(TAG_CANON_STATE2_SUBJECT_DISTANCE), "Subject Distance");
+
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_LONG_EXPOSURE_NOISE_REDUCTION), "Long Exposure Noise Reduction");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_SHUTTER_AUTO_EXPOSURE_LOCK_BUTTONS), "Shutter/Auto Exposure-lock Buttons");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_MIRROR_LOCKUP), "Mirror Lockup");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_TV_AV_AND_EXPOSURE_LEVEL), "Tv/Av And Exposure Level");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_AF_ASSIST_LIGHT), "AF-Assist Light");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_SHUTTER_SPEED_IN_AV_MODE), "Shutter Speed in Av Mode");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_BRACKETTING), "Auto-Exposure Bracketting Sequence/Auto Cancellation");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_SHUTTER_CURTAIN_SYNC), "Shutter Curtain Sync");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_AF_STOP), "Lens Auto-Focus Stop Button Function Switch");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_FILL_FLASH_REDUCTION), "Auto Reduction of Fill Flash");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_MENU_BUTTON_RETURN), "Menu Button Return Position");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_SET_BUTTON_FUNCTION), "SET Button Function When Shooting");
+ _tagNameMap.put(new Integer(TAG_CANON_CUSTOM_FUNCTION_SENSOR_CLEANING), "Sensor Cleaning");
+ }
+
+ public CanonMakernoteDirectory()
+ {
+ this.setDescriptor(new CanonMakernoteDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Canon Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return _tagNameMap;
+ }
+
+ /**
+ * We need special handling for selected tags.
+ * @param tagType
+ * @param ints
+ */
+ public void setIntArray(int tagType, int[] ints)
+ {
+ if (tagType == TAG_CANON_CAMERA_STATE_1) {
+ // this single tag has multiple values within
+ int subTagTypeBase = 0xC100;
+ // we intentionally skip the first array member
+ for (int i = 1; i < ints.length; i++) {
+ setInt(subTagTypeBase + i, ints[i]);
+ }
+ } else if (tagType == TAG_CANON_CAMERA_STATE_2) {
+ // this single tag has multiple values within
+ int subTagTypeBase = 0xC200;
+ // we intentionally skip the first array member
+ for (int i = 1; i < ints.length; i++) {
+ setInt(subTagTypeBase + i, ints[i]);
+ }
+ } if (tagType == TAG_CANON_CUSTOM_FUNCTIONS) {
+ // this single tag has multiple values within
+ int subTagTypeBase = 0xC300;
+ // we intentionally skip the first array member
+ for (int i = 1; i < ints.length; i++) {
+ setInt(subTagTypeBase + i + 1, ints[i] & 0x0F);
+ }
+ } else {
+ // no special handling...
+ super.setIntArray(tagType, ints);
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,273 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:12:05 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ *
+ */
+public class CasioType1MakernoteDescriptor extends TagDescriptor
+{
+ public CasioType1MakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType) {
+ case CasioType1MakernoteDirectory.TAG_CASIO_RECORDING_MODE:
+ return getRecordingModeDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_QUALITY:
+ return getQualityDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_FOCUSING_MODE:
+ return getFocusingModeDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_FLASH_MODE:
+ return getFlashModeDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_FLASH_INTENSITY:
+ return getFlashIntensityDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_OBJECT_DISTANCE:
+ return getObjectDistanceDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_WHITE_BALANCE:
+ return getWhiteBalanceDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_DIGITAL_ZOOM:
+ return getDigitalZoomDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_SHARPNESS:
+ return getSharpnessDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_CONTRAST:
+ return getContrastDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_SATURATION:
+ return getSaturationDescription();
+ case CasioType1MakernoteDirectory.TAG_CASIO_CCD_SENSITIVITY:
+ return getCcdSensitivityDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getCcdSensitivityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_CCD_SENSITIVITY)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_CCD_SENSITIVITY);
+ switch (value) {
+ // these four for QV3000
+ case 64:
+ return "Normal";
+ case 125:
+ return "+1.0";
+ case 250:
+ return "+2.0";
+ case 244:
+ return "+3.0";
+ // these two for QV8000/2000
+ case 80:
+ return "Normal (ISO 80 equivalent)";
+ case 100:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSaturationDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_SATURATION)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_SATURATION);
+ switch (value) {
+ case 0:
+ return "Normal";
+ case 1:
+ return "Low";
+ case 2:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getContrastDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_CONTRAST)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_CONTRAST);
+ switch (value) {
+ case 0:
+ return "Normal";
+ case 1:
+ return "Low";
+ case 2:
+ return "High";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSharpnessDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_SHARPNESS)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_SHARPNESS);
+ switch (value) {
+ case 0:
+ return "Normal";
+ case 1:
+ return "Soft";
+ case 2:
+ return "Hard";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getDigitalZoomDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_DIGITAL_ZOOM)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_DIGITAL_ZOOM);
+ switch (value) {
+ case 0x10000:
+ return "No digital zoom";
+ case 0x10001:
+ return "2x digital zoom";
+ case 0x20000:
+ return "2x digital zoom";
+ case 0x40000:
+ return "4x digital zoom";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getWhiteBalanceDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_WHITE_BALANCE)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_WHITE_BALANCE);
+ switch (value) {
+ case 1:
+ return "Auto";
+ case 2:
+ return "Tungsten";
+ case 3:
+ return "Daylight";
+ case 4:
+ return "Flourescent";
+ case 5:
+ return "Shade";
+ case 129:
+ return "Manual";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getObjectDistanceDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_OBJECT_DISTANCE)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_OBJECT_DISTANCE);
+ return value + " mm";
+ }
+
+ public String getFlashIntensityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_FLASH_INTENSITY)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_FLASH_INTENSITY);
+ switch (value) {
+ case 11:
+ return "Weak";
+ case 13:
+ return "Normal";
+ case 15:
+ return "Strong";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_FLASH_MODE)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_FLASH_MODE);
+ switch (value) {
+ case 1:
+ return "Auto";
+ case 2:
+ return "On";
+ case 3:
+ return "Off";
+ case 4:
+ // this documented as additional value for off here:
+ // http://www.ozhiker.com/electronics/pjmt/jpeg_info/casio_mn.html
+ return "Red eye reduction";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFocusingModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_FOCUSING_MODE)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_FOCUSING_MODE);
+ switch (value) {
+ case 2:
+ return "Macro";
+ case 3:
+ return "Auto focus";
+ case 4:
+ return "Manual focus";
+ case 5:
+ return "Infinity";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getQualityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_QUALITY)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_QUALITY);
+ switch (value) {
+ case 1:
+ return "Economy";
+ case 2:
+ return "Normal";
+ case 3:
+ return "Fine";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getRecordingModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(CasioType1MakernoteDirectory.TAG_CASIO_RECORDING_MODE)) return null;
+ int value = _directory.getInt(CasioType1MakernoteDirectory.TAG_CASIO_RECORDING_MODE);
+ switch (value) {
+ case 1:
+ return "Single shutter";
+ case 2:
+ return "Panorama";
+ case 3:
+ return "Night scene";
+ case 4:
+ return "Portrait";
+ case 5:
+ return "Landscape";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/CasioType1MakernoteDirectory.java (revision 4231)
@@ -0,0 +1,90 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * A standard TIFF IFD directory but always uses Motorola (Big-Endian) Byte Alignment.
+ * Makernote data begins immediately (no header).
+ */
+public class CasioType1MakernoteDirectory extends Directory
+{
+ public static final int TAG_CASIO_RECORDING_MODE = 0x0001;
+ public static final int TAG_CASIO_QUALITY = 0x0002;
+ public static final int TAG_CASIO_FOCUSING_MODE = 0x0003;
+ public static final int TAG_CASIO_FLASH_MODE = 0x0004;
+ public static final int TAG_CASIO_FLASH_INTENSITY = 0x0005;
+ public static final int TAG_CASIO_OBJECT_DISTANCE = 0x0006;
+ public static final int TAG_CASIO_WHITE_BALANCE = 0x0007;
+ public static final int TAG_CASIO_UNKNOWN_1 = 0x0008;
+ public static final int TAG_CASIO_UNKNOWN_2 = 0x0009;
+ public static final int TAG_CASIO_DIGITAL_ZOOM = 0x000A;
+ public static final int TAG_CASIO_SHARPNESS = 0x000B;
+ public static final int TAG_CASIO_CONTRAST = 0x000C;
+ public static final int TAG_CASIO_SATURATION = 0x000D;
+ public static final int TAG_CASIO_UNKNOWN_3 = 0x000E;
+ public static final int TAG_CASIO_UNKNOWN_4 = 0x000F;
+ public static final int TAG_CASIO_UNKNOWN_5 = 0x0010;
+ public static final int TAG_CASIO_UNKNOWN_6 = 0x0011;
+ public static final int TAG_CASIO_UNKNOWN_7 = 0x0012;
+ public static final int TAG_CASIO_UNKNOWN_8 = 0x0013;
+ public static final int TAG_CASIO_CCD_SENSITIVITY = 0x0014;
+
+ protected static final HashMapnull 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);
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/ExifReader.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/ExifReader.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/ExifReader.java (revision 4231)
@@ -0,0 +1,668 @@
+/*
+ * 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
+ */
+public class NikonType1MakernoteDescriptor extends TagDescriptor
+{
+ public NikonType1MakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType) {
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_QUALITY:
+ return getQualityDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_COLOR_MODE:
+ return getColorModeDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_IMAGE_ADJUSTMENT:
+ return getImageAdjustmentDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CCD_SENSITIVITY:
+ return getCcdSensitivityDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_WHITE_BALANCE:
+ return getWhiteBalanceDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_FOCUS:
+ return getFocusDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_DIGITAL_ZOOM:
+ return getDigitalZoomDescription();
+ case NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CONVERTER:
+ return getConverterDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getConverterDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CONVERTER)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CONVERTER);
+ switch (value) {
+ case 0:
+ return "None";
+ case 1:
+ return "Fisheye converter";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getDigitalZoomDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_DIGITAL_ZOOM)) return null;
+ Rational value = _directory.getRational(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_DIGITAL_ZOOM);
+ if (value.getNumerator() == 0) {
+ return "No digital zoom";
+ }
+ return value.toSimpleString(true) + "x digital zoom";
+ }
+
+ public String getFocusDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_FOCUS)) return null;
+ Rational value = _directory.getRational(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_FOCUS);
+ if (value.getNumerator() == 1 && value.getDenominator() == 0) {
+ return "Infinite";
+ }
+ return value.toSimpleString(true);
+ }
+
+ public String getWhiteBalanceDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_WHITE_BALANCE)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_WHITE_BALANCE);
+ switch (value) {
+ case 0:
+ return "Auto";
+ case 1:
+ return "Preset";
+ case 2:
+ return "Daylight";
+ case 3:
+ return "Incandescense";
+ case 4:
+ return "Flourescence";
+ case 5:
+ return "Cloudy";
+ case 6:
+ return "SpeedLight";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getCcdSensitivityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CCD_SENSITIVITY)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_CCD_SENSITIVITY);
+ switch (value) {
+ case 0:
+ return "ISO80";
+ case 2:
+ return "ISO160";
+ case 4:
+ return "ISO320";
+ case 5:
+ return "ISO100";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getImageAdjustmentDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_IMAGE_ADJUSTMENT)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_IMAGE_ADJUSTMENT);
+ switch (value) {
+ case 0:
+ return "Normal";
+ case 1:
+ return "Bright +";
+ case 2:
+ return "Bright -";
+ case 3:
+ return "Contrast +";
+ case 4:
+ return "Contrast -";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getColorModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_COLOR_MODE)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_COLOR_MODE);
+ switch (value) {
+ case 1:
+ return "Color";
+ case 2:
+ return "Monochrome";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getQualityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_QUALITY)) return null;
+ int value = _directory.getInt(NikonType1MakernoteDirectory.TAG_NIKON_TYPE1_QUALITY);
+ switch (value) {
+ case 1:
+ return "VGA Basic";
+ case 2:
+ return "VGA Normal";
+ case 3:
+ return "VGA Fine";
+ case 4:
+ return "SXGA Basic";
+ case 5:
+ return "SXGA Normal";
+ case 6:
+ return "SXGA Fine";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/NikonType1MakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/NikonType1MakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/NikonType1MakernoteDirectory.java (revision 4231)
@@ -0,0 +1,80 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * Contains values specific to Nikon cameras. Type-1 is for E-Series cameras prior to (not including) E990.
+ *
+ * There are 3 formats of Nikon's MakerNote. MakerNote of E700/E800/E900/E900S/E910/E950
+ * starts from ASCII string "Nikon". Data format is the same as IFD, but it starts from
+ * offset 0x08. This is the same as Olympus except start string. Example of actual data
+ * structure is shown below.
+ *
+ * :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 ................
+ *
+ */
+public class NikonType1MakernoteDirectory extends Directory
+{
+ public static final int TAG_NIKON_TYPE1_UNKNOWN_1 = 0x0002;
+ public static final int TAG_NIKON_TYPE1_QUALITY = 0x0003;
+ public static final int TAG_NIKON_TYPE1_COLOR_MODE = 0x0004;
+ public static final int TAG_NIKON_TYPE1_IMAGE_ADJUSTMENT = 0x0005;
+ public static final int TAG_NIKON_TYPE1_CCD_SENSITIVITY = 0x0006;
+ public static final int TAG_NIKON_TYPE1_WHITE_BALANCE = 0x0007;
+ public static final int TAG_NIKON_TYPE1_FOCUS = 0x0008;
+ public static final int TAG_NIKON_TYPE1_UNKNOWN_2 = 0x0009;
+ public static final int TAG_NIKON_TYPE1_DIGITAL_ZOOM = 0x000A;
+ public static final int TAG_NIKON_TYPE1_CONVERTER = 0x000B;
+ public static final int TAG_NIKON_TYPE1_UNKNOWN_3 = 0x0F00;
+
+ protected static final HashMap _tagNameMap = new HashMap();
+
+ static
+ {
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_CCD_SENSITIVITY), "CCD Sensitivity");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_COLOR_MODE), "Color Mode");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_DIGITAL_ZOOM), "Digital Zoom");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_CONVERTER), "Fisheye Converter");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_FOCUS), "Focus");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_IMAGE_ADJUSTMENT), "Image Adjustment");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_QUALITY), "Quality");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_UNKNOWN_1), "Makernote Unknown 1");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_UNKNOWN_2), "Makernote Unknown 2");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_UNKNOWN_3), "Makernote Unknown 3");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE1_WHITE_BALANCE), "White Balance");
+ }
+
+ public NikonType1MakernoteDirectory()
+ {
+ this.setDescriptor(new NikonType1MakernoteDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Nikon Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return _tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,169 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.lang.Rational;
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+import java.text.DecimalFormat;
+
+/**
+ * Provides human-readable string versions of the tags stored in a NikonType2MakernoteDirectory.
+ * Type-2 applies to the E990 and D-series cameras such as the D1, D70 and D100.
+ */
+public class NikonType2MakernoteDescriptor extends TagDescriptor
+{
+ public NikonType2MakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ private NikonType2MakernoteDirectory getMakernoteDirectory()
+ {
+ return (NikonType2MakernoteDirectory)_directory;
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType)
+ {
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_LENS:
+ return getLensDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_HUE_ADJUSTMENT:
+ return getHueAdjustmentDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_COLOR_MODE:
+ return getColorModeDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AUTO_FLASH_COMPENSATION:
+ return getAutoFlashCompensationDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_ISO_1:
+ return getIsoSettingDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_DIGITAL_ZOOM:
+ return getDigitalZoomDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AF_FOCUS_POSITION:
+ return getAutoFocusPositionDescription();
+ case NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_FIRMWARE_VERSION:
+ return getAutoFirmwareVersionDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getAutoFocusPositionDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AF_FOCUS_POSITION)) return null;
+ int[] values = _directory.getIntArray(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AF_FOCUS_POSITION);
+ if (values.length != 4 || values[0] != 0 || values[2] != 0 || values[3] != 0) {
+ return "Unknown (" + _directory.getString(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AF_FOCUS_POSITION) + ")";
+ }
+ switch (values[1]) {
+ case 0:
+ return "Centre";
+ case 1:
+ return "Top";
+ case 2:
+ return "Bottom";
+ case 3:
+ return "Left";
+ case 4:
+ return "Right";
+ default:
+ return "Unknown (" + values[1] + ")";
+ }
+ }
+
+ public String getDigitalZoomDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_DIGITAL_ZOOM)) return null;
+ Rational rational = _directory.getRational(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_DIGITAL_ZOOM);
+ if (rational.intValue() == 1) {
+ return "No digital zoom";
+ }
+ return rational.toSimpleString(true) + "x digital zoom";
+ }
+
+ public String getIsoSettingDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_ISO_1)) return null;
+ int[] values = _directory.getIntArray(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_ISO_1);
+ if (values[0] != 0 || values[1] == 0) {
+ return "Unknown (" + _directory.getString(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_ISO_1) + ")";
+ }
+ return "ISO " + values[1];
+ }
+
+ public String getAutoFlashCompensationDescription() throws MetadataException
+ {
+ Rational ev = getMakernoteDirectory().getAutoFlashCompensation();
+
+ if (ev==null)
+ return "Unknown";
+
+ DecimalFormat decimalFormat = new DecimalFormat("0.##");
+ return decimalFormat.format(ev.floatValue()) + " EV";
+ }
+
+ public String getLensDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_LENS))
+ return null;
+
+ Rational[] lensValues = _directory.getRationalArray(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_LENS);
+
+ if (lensValues.length!=4)
+ return _directory.getString(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_LENS);
+
+ StringBuffer description = new StringBuffer();
+ description.append(lensValues[0].intValue());
+ description.append('-');
+ description.append(lensValues[1].intValue());
+ description.append("mm f/");
+ description.append(lensValues[2].floatValue());
+ description.append('-');
+ description.append(lensValues[3].floatValue());
+
+ return description.toString();
+ }
+
+ public String getHueAdjustmentDescription()
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_HUE_ADJUSTMENT))
+ return null;
+
+ return _directory.getString(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_HUE_ADJUSTMENT) + " degrees";
+ }
+
+ public String getColorModeDescription()
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_COLOR_MODE))
+ return null;
+
+ String raw = _directory.getString(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_CAMERA_COLOR_MODE);
+ if (raw.startsWith("MODE1"))
+ return "Mode I (sRGB)";
+
+ return raw;
+ }
+
+ public String getAutoFirmwareVersionDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_FIRMWARE_VERSION))
+ return null;
+
+ int[] ints = _directory.getIntArray(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_FIRMWARE_VERSION);
+ return ExifDescriptor.convertBytesToVersionString(ints);
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/NikonType2MakernoteDirectory.java (revision 4231)
@@ -0,0 +1,550 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 3-Oct-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.lang.Rational;
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+
+import java.util.HashMap;
+
+/**
+ * Contains values specific to Nikon cameras. Type-2 applies to the E990 and D-series cameras such as the E990, D1,
+ * D70 and D100.
+ *
+ * Thanks to Fabrizio Giudici for publishing his reverse-engineering of the D100 makernote data.
+ * http://www.timelesswanderings.net/equipment/D100/NEF.html
+ *
+ * Note that the camera implements image protection (locking images) via the file's 'readonly' attribute. Similarly
+ * image hiding uses the 'hidden' attribute (observed on the D70). Consequently, these values are not available here.
+ *
+ * Additional sample images have been observed, and their tag values recorded in javadoc comments for each tag's field.
+ * New tags have subsequently been added since Fabrizio's observations.
+ *
+ * In earlier models (such as the E990 and D1), this directory begins at the first byte of the makernote IFD. In
+ * later models, the IFD was given the standard prefix to indicate the camera models (most other manufacturers also
+ * provide this prefix to aid in software decoding).
+ */
+public class NikonType2MakernoteDirectory extends Directory
+{
+ /**
+ * Values observed
+ * - 0200 (D70)
+ * - 0200 (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_FIRMWARE_VERSION = 0x0001;
+
+ /**
+ * Values observed
+ * - 0 250
+ * - 0 400
+ */
+ public static final int TAG_NIKON_TYPE2_ISO_1 = 0x0002;
+
+ /**
+ * Values observed
+ * - COLOR (seen in the D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_COLOR_MODE = 0x0003;
+
+ /**
+ * Values observed
+ * - FILE
+ * - RAW
+ * - NORMAL
+ * - FINE
+ */
+ public static final int TAG_NIKON_TYPE2_QUALITY_AND_FILE_FORMAT = 0x0004;
+
+ /**
+ * The white balance as set in the camera.
+ *
+ * Values observed
+ * - AUTO
+ * - SUNNY (D70)
+ * - FLASH (D1X)
+ * (presumably also SHADOW / INCANDESCENT / FLUORESCENT / CLOUDY)
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE = 0x0005;
+
+ /**
+ * The sharpening as set in the camera.
+ *
+ * Values observed
+ * - AUTO
+ * - NORMAL (D70)
+ * - NONE (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_SHARPENING = 0x0006;
+
+ /**
+ * The auto-focus type used by the camera.
+ *
+ * Values observed
+ * - AF-S
+ * - AF-C
+ * - MANUAL
+ */
+ public static final int TAG_NIKON_TYPE2_AF_TYPE = 0x0007;
+
+ /**
+ * Values observed
+ * - NORMAL
+ * - RED-EYE
+ *
+ * Note: when TAG_NIKON_TYPE2_AUTO_FLASH_MODE is blank, Nikon Browser displays "Flash Sync Mode: Not Attached"
+ */
+ public static final int TAG_NIKON_TYPE2_FLASH_SYNC_MODE = 0x0008;
+
+ /**
+ * Values observed
+ * - Built-in,TTL
+ * - Optional,TTL (with speedlight SB800, flash sync mode as NORMAL. NikonBrowser reports Auto Flash Comp: 0 EV -- which tag is that?) (D70)
+ * - NEW_TTL (Nikon Browser interprets as "D-TTL")
+ * - (blank -- accompanied FlashSyncMode of NORMAL) (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_AUTO_FLASH_MODE = 0x0009;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_34 = 0x000A;
+
+ /**
+ * Values observed
+ * - 0
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE_FINE = 0x000B;
+
+ /**
+ * The first two numbers are coefficients to multiply red and blue channels according to white balance as set in the
+ * camera. The meaning of the third and the fourth numbers is unknown.
+ *
+ * Values observed
+ * - 2.25882352 1.76078431 0.0 0.0
+ * - 10242/1 34305/1 0/1 0/1
+ * - 234765625/100000000 1140625/1000000 1/1 1/1
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE_RB_COEFF = 0x000C;
+
+ /**
+ * Values observed
+ * - 0,1,6,0 (hex)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_1 = 0x000D;
+
+ /**
+ * Values observed
+ * - î
+
+ * - 0,1,c,0 (hex)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_2 = 0x000E;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_ISO_SELECTION = 0x000F;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_DATA_DUMP = 0x0010;
+
+ /**
+ * Values observed
+ * - 914
+ * - 1379 (D70)
+ * - 2781 (D1X)
+ * - 6942 (D100)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_3 = 0x0011;
+
+ /**
+ * Values observed
+ * - (no value -- blank)
+ */
+ public static final int TAG_NIKON_TYPE2_AUTO_FLASH_COMPENSATION = 0x0012;
+
+ /**
+ * Values observed
+ * - 0 250
+ * - 0 400
+ */
+ public static final int TAG_NIKON_TYPE2_ISO_2 = 0x0013;
+
+ /**
+ * Values observed
+ * - 0 0 49163 53255
+ * - 0 0 3008 2000 (the image dimensions were 3008x2000) (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_21 = 0x0016;
+
+ /**
+ * Values observed
+ * - (blank)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_22 = 0x0017;
+
+ /**
+ * Values observed
+ * - (blank)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_23 = 0x0018;
+
+ /**
+ * Values observed
+ * - 0
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_24 = 0x0019;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_IMAGE_ADJUSTMENT = 0x0080;
+
+ /**
+ * The tone compensation as set in the camera.
+ *
+ * Values observed
+ * - AUTO
+ * - NORMAL (D1X, D100)
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_TONE_COMPENSATION = 0x0081;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_ADAPTER = 0x0082;
+
+ /**
+ * Values observed
+ * - 6
+ * - 6 (D70)
+ * - 2 (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_4 = 0x0083;
+
+ /**
+ * A pair of focal/max-fstop values that describe the lens used.
+ *
+ * Values observed
+ * - 180.0,180.0,2.8,2.8 (D100)
+ * - 240/10 850/10 35/10 45/10
+ * - 18-70mm f/3.5-4.5 (D70)
+ * - 17-35mm f/2.8-2.8 (D1X)
+ * - 70-200mm f/2.8-2.8 (D70)
+ *
+ * Nikon Browser identifies the lens as "18-70mm F/3.5-4.5 G" which
+ * is identical to metadata extractor, except for the "G". This must
+ * be coming from another tag...
+ */
+ public static final int TAG_NIKON_TYPE2_LENS = 0x0084;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_MANUAL_FOCUS_DISTANCE = 0x0085;
+
+ /**
+ * Added during merge of Type2 & Type3. May apply to earlier models, such as E990 and D1.
+ */
+ public static final int TAG_NIKON_TYPE2_DIGITAL_ZOOM = 0x0086;
+
+ /**
+ * Values observed
+ * - 0
+ * - 9
+ * - 3 (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_5 = 0x0087;
+
+ /**
+ * Values observed
+ * -
+ */
+ public static final int TAG_NIKON_TYPE2_AF_FOCUS_POSITION = 0x0088;
+
+ /**
+ * Values observed
+ * - 0
+ * - 1
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_7 = 0x0089;
+
+ /**
+ * Values observed
+ * - 0
+ * - 0
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_20 = 0x008A;
+
+ /**
+ * Values observed
+ * - 48,1,c,0 (hex) (D100)
+ * - @
+
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_8 = 0x008B;
+
+ /**
+ * Unknown. Fabrizio believes this may be a lookup table for the user-defined curve.
+ *
+ * Values observed
+ * - (blank) (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_9 = 0x008C;
+
+ /**
+ * The color space as set in the camera.
+ *
+ * Values observed
+ * - MODE1
+ * - Mode I (sRGB) (D70)
+ * - MODE2 (D1X, D100)
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_COLOR_MODE = 0x008D;
+
+ /**
+ * Values observed
+ * - NATURAL
+ * - SPEEDLIGHT (D70, D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_LIGHT_SOURCE = 0x0090;
+
+ /**
+ * Values observed
+ * - 0100
+
+)
+ * - 0103 (D70)
+ * - 0100 (D1X)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_11 = 0x0091;
+
+ /**
+ * The hue adjustment as set in the camera.
+ *
+ * Values observed
+ * - 0
+ */
+ public static final int TAG_NIKON_TYPE2_CAMERA_HUE_ADJUSTMENT = 0x0092;
+
+ /**
+ * Values observed
+ * - OFF
+ */
+ public static final int TAG_NIKON_TYPE2_NOISE_REDUCTION = 0x0095;
+
+ /**
+ * Values observed
+ * - 0100
+'~e3
+ * - 0103
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_12 = 0x0097;
+
+ /**
+ * Values observed
+ * - 0100fht@7b,4x,D"Y
+ * - 01015
+ * - 0100w\cH+D$$h$î5
+Q (D1X)
+ * - 30,31,30,30,0,0,b,48,7c,7c,24,24,5,15,24,0,0,0,0,0 (hex) (D100)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_13 = 0x0098;
+
+ /**
+ * Values observed
+ * - 2014 662 (D1X)
+ * - 1517,1012 (D100)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_14 = 0x0099;
+
+ /**
+ * Values observed
+ * - 78/10 78/10
+ * - 78/10 78/10 (D70)
+ * - 59/10 59/5 (D1X)
+ * - 7.8,7.8 (D100)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_15 = 0x009A;
+
+ /**
+ * Values observed
+ * - NO= 00002539
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_25 = 0x00A0;
+
+ /**
+ * Values observed
+ * - 1564851
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_26 = 0x00A2;
+
+ /**
+ * Values observed
+ * - 0
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_27 = 0x00A3;
+
+ /**
+ * This appears to be a sequence number to indentify the exposure. This value seems to increment
+ * for consecutive exposures (observed on D70).
+ *
+ * Values observed
+ * - 5062
+ */
+ public static final int TAG_NIKON_TYPE2_EXPOSURE_SEQUENCE_NUMBER = 0x00A7;
+
+ /**
+ * Values observed
+ * - 0100 (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_32 = 0x00A8;
+
+ /**
+ * Values observed
+ * - NORMAL (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_33 = 0x00A9;
+
+ /**
+ * Nikon Browser suggests this value represents Saturation...
+ * Values observed
+ * - NORMAL (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_29 = 0x00AA;
+
+ /**
+ * Values observed
+ * - AUTO (D70)
+ * - (blank) (D70)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_30 = 0x00AB;
+
+ /**
+ * Data about changes set by Nikon Capture Editor.
+ *
+ * Values observed
+ */
+ public static final int TAG_NIKON_TYPE2_CAPTURE_EDITOR_DATA = 0x0E01;
+
+ /**
+ * Values observed
+ * - 1473
+ * - 7036 (D100)
+ */
+ public static final int TAG_NIKON_TYPE2_UNKNOWN_16 = 0x0E10;
+
+ protected static final HashMap _tagNameMap = new HashMap();
+
+ static
+ {
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_FIRMWARE_VERSION), "Firmware Version");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_ISO_1), "ISO");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_QUALITY_AND_FILE_FORMAT), "Quality & File Format");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE), "White Balance");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_SHARPENING), "Sharpening");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_AF_TYPE), "AF Type");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE_FINE), "White Balance Fine");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_WHITE_BALANCE_RB_COEFF), "White Balance RB Coefficients");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_ISO_2), "ISO");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_ISO_SELECTION), "ISO Selection");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_DATA_DUMP), "Data Dump");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_IMAGE_ADJUSTMENT), "Image Adjustment");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_TONE_COMPENSATION), "Tone Compensation");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_ADAPTER), "Adapter");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_LENS), "Lens");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_MANUAL_FOCUS_DISTANCE), "Manual Focus Distance");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_DIGITAL_ZOOM), "Digital Zoom");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_COLOR_MODE), "Colour Mode");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAMERA_HUE_ADJUSTMENT), "Camera Hue Adjustment");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_NOISE_REDUCTION), "Noise Reduction");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_CAPTURE_EDITOR_DATA), "Capture Editor Data");
+
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_1), "Unknown 01");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_2), "Unknown 02");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_3), "Unknown 03");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_4), "Unknown 04");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_5), "Unknown 05");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_AF_FOCUS_POSITION), "AF Focus Position");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_7), "Unknown 07");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_8), "Unknown 08");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_9), "Unknown 09");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_LIGHT_SOURCE), "Light source");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_11), "Unknown 11");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_12), "Unknown 12");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_13), "Unknown 13");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_14), "Unknown 14");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_15), "Unknown 15");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_16), "Unknown 16");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_FLASH_SYNC_MODE), "Flash Sync Mode");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_AUTO_FLASH_MODE), "Auto Flash Mode");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_AUTO_FLASH_COMPENSATION), "Auto Flash Compensation");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_EXPOSURE_SEQUENCE_NUMBER), "Exposure Sequence Number");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_COLOR_MODE), "Color Mode");
+
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_20), "Unknown 20");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_21), "Unknown 21");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_22), "Unknown 22");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_23), "Unknown 23");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_24), "Unknown 24");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_25), "Unknown 25");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_26), "Unknown 26");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_27), "Unknown 27");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_29), "Unknown 29");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_30), "Unknown 30");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_32), "Unknown 32");
+ _tagNameMap.put(new Integer(TAG_NIKON_TYPE2_UNKNOWN_33), "Unknown 33");
+ }
+
+ public NikonType2MakernoteDirectory()
+ {
+ this.setDescriptor(new NikonType2MakernoteDescriptor(this));
+ }
+
+ public Rational getAutoFlashCompensation() throws MetadataException
+ {
+ if (!containsTag(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AUTO_FLASH_COMPENSATION))
+ return null;
+
+ byte[] bytes = getByteArray(NikonType2MakernoteDirectory.TAG_NIKON_TYPE2_AUTO_FLASH_COMPENSATION);
+ return CalculateFlashCompensationFromBytes(bytes);
+ }
+
+ public static Rational CalculateFlashCompensationFromBytes(byte[] bytes)
+ {
+ if (bytes.length==3)
+ {
+ byte denominator = bytes[2];
+ int numerator = (int)bytes[0] * bytes[1];
+ return new Rational(numerator, denominator);
+ }
+ return null;
+ }
+
+ public String getName()
+ {
+ return "Nikon Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return _tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/OlympusMakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/OlympusMakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/OlympusMakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,148 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ * Provides human-readable string versions of the tags stored in an OlympusMakernoteDirectory.
+ */
+public class OlympusMakernoteDescriptor extends TagDescriptor
+{
+ public OlympusMakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType) {
+ case OlympusMakernoteDirectory.TAG_OLYMPUS_SPECIAL_MODE:
+ return getSpecialModeDescription();
+ case OlympusMakernoteDirectory.TAG_OLYMPUS_JPEG_QUALITY:
+ return getJpegQualityDescription();
+ case OlympusMakernoteDirectory.TAG_OLYMPUS_MACRO_MODE:
+ return getMacroModeDescription();
+ case OlympusMakernoteDirectory.TAG_OLYMPUS_DIGI_ZOOM_RATIO:
+ return getDigiZoomRatioDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getDigiZoomRatioDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(OlympusMakernoteDirectory.TAG_OLYMPUS_DIGI_ZOOM_RATIO)) return null;
+ int value = _directory.getInt(OlympusMakernoteDirectory.TAG_OLYMPUS_DIGI_ZOOM_RATIO);
+ switch (value) {
+ case 0:
+ return "Normal";
+ case 2:
+ return "Digital 2x Zoom";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getMacroModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(OlympusMakernoteDirectory.TAG_OLYMPUS_MACRO_MODE)) return null;
+ int value = _directory.getInt(OlympusMakernoteDirectory.TAG_OLYMPUS_MACRO_MODE);
+ switch (value) {
+ case 0:
+ return "Normal (no macro)";
+ case 1:
+ return "Macro";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getJpegQualityDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(OlympusMakernoteDirectory.TAG_OLYMPUS_JPEG_QUALITY)) return null;
+ int value = _directory.getInt(OlympusMakernoteDirectory.TAG_OLYMPUS_JPEG_QUALITY);
+ switch (value) {
+ case 1:
+ return "SQ";
+ case 2:
+ return "HQ";
+ case 3:
+ return "SHQ";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSpecialModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(OlympusMakernoteDirectory.TAG_OLYMPUS_SPECIAL_MODE)) return null;
+ int[] values = _directory.getIntArray(OlympusMakernoteDirectory.TAG_OLYMPUS_SPECIAL_MODE);
+ StringBuffer desc = new StringBuffer();
+ switch (values[0]) {
+ case 0:
+ desc.append("Normal picture taking mode");
+ break;
+ case 1:
+ desc.append("Unknown picture taking mode");
+ break;
+ case 2:
+ desc.append("Fast picture taking mode");
+ break;
+ case 3:
+ desc.append("Panorama picture taking mode");
+ break;
+ default:
+ desc.append("Unknown picture taking mode");
+ break;
+ }
+ desc.append(" - ");
+ switch (values[1]) {
+ case 0:
+ desc.append("Unknown sequence number");
+ break;
+ case 1:
+ desc.append("1st in a sequnce");
+ break;
+ case 2:
+ desc.append("2nd in a sequence");
+ break;
+ case 3:
+ desc.append("3rd in a sequence");
+ break;
+ default:
+ desc.append(values[1]);
+ desc.append("th in a sequence");
+ break;
+ }
+ switch (values[2]) {
+ case 1:
+ desc.append("Left to right panorama direction");
+ break;
+ case 2:
+ desc.append("Right to left panorama direction");
+ break;
+ case 3:
+ desc.append("Bottom to top panorama direction");
+ break;
+ case 4:
+ desc.append("Top to bottom panorama direction");
+ break;
+ }
+ return desc.toString();
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/OlympusMakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/OlympusMakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/OlympusMakernoteDirectory.java (revision 4231)
@@ -0,0 +1,360 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * The Olympus makernote is used by many manufacturers, and as such contains some tags that appear specific to
+ * those manufacturers. Other users include Konica, Minolta and Epson.
+ */
+public class OlympusMakernoteDirectory extends Directory
+{
+ /**
+ * Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_MAKERNOTE_VERSION = 0x0000;
+
+ /**
+ * Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_CAMERA_SETTINGS_1 = 0x0001;
+
+ /**
+ * Alternate Camera Settings Tag. Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_CAMERA_SETTINGS_2 = 0x0003;
+
+ /**
+ * Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_COMPRESSED_IMAGE_SIZE = 0x0040;
+
+ /**
+ * Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_MINOLTA_THUMBNAIL_OFFSET_1 = 0x0081;
+
+ /**
+ * Alternate Thumbnail Offset. Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_MINOLTA_THUMBNAIL_OFFSET_2 = 0x0088;
+
+ /**
+ * Length of thumbnail in bytes. Used by Konica / Minolta cameras.
+ */
+ public static final int TAG_OLYMPUS_MINOLTA_THUMBNAIL_LENGTH = 0x0089;
+
+ /**
+ * Used by Konica / Minolta cameras
+ * 0 = Natural Colour
+ * 1 = Black & White
+ * 2 = Vivid colour
+ * 3 = Solarization
+ * 4 = AdobeRGB
+ */
+ public static final int TAG_OLYMPUS_COLOUR_MODE = 0x0101;
+
+ /**
+ * Used by Konica / Minolta cameras.
+ * 0 = Raw
+ * 1 = Super Fine
+ * 2 = Fine
+ * 3 = Standard
+ * 4 = Extra Fine
+ */
+ public static final int TAG_OLYMPUS_IMAGE_QUALITY_1 = 0x0102;
+
+ /**
+ * Not 100% sure about this tag.
+ *
+ * Used by Konica / Minolta cameras.
+ * 0 = Raw
+ * 1 = Super Fine
+ * 2 = Fine
+ * 3 = Standard
+ * 4 = Extra Fine
+ */
+ public static final int TAG_OLYMPUS_IMAGE_QUALITY_2 = 0x0103;
+
+
+ /**
+ * Three values:
+ * Value 1: 0=Normal, 2=Fast, 3=Panorama
+ * Value 2: Sequence Number Value 3:
+ * 1 = Panorama Direction: Left to Right
+ * 2 = Panorama Direction: Right to Left
+ * 3 = Panorama Direction: Bottom to Top
+ * 4 = Panorama Direction: Top to Bottom
+ */
+ public static final int TAG_OLYMPUS_SPECIAL_MODE = 0x0200;
+
+ /**
+ * 1 = Standard Quality
+ * 2 = High Quality
+ * 3 = Super High Quality
+ */
+ public static final int TAG_OLYMPUS_JPEG_QUALITY = 0x0201;
+
+ /**
+ * 0 = Normal (Not Macro)
+ * 1 = Macro
+ */
+ public static final int TAG_OLYMPUS_MACRO_MODE = 0x0202;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_UNKNOWN_1 = 0x0203;
+
+ /**
+ * Zoom Factor (0 or 1 = normal)
+ */
+ public static final int TAG_OLYMPUS_DIGI_ZOOM_RATIO = 0x0204;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_UNKNOWN_2 = 0x0205;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_UNKNOWN_3 = 0x0206;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FIRMWARE_VERSION = 0x0207;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_PICT_INFO = 0x0208;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_CAMERA_ID = 0x0209;
+
+ /**
+ * Used by Epson cameras
+ * Units = pixels
+ */
+ public static final int TAG_OLYMPUS_IMAGE_WIDTH = 0x020B;
+
+ /**
+ * Used by Epson cameras
+ * Units = pixels
+ */
+ public static final int TAG_OLYMPUS_IMAGE_HEIGHT = 0x020C;
+
+ /**
+ * A string. Used by Epson cameras.
+ */
+ public static final int TAG_OLYMPUS_ORIGINAL_MANUFACTURER_MODEL = 0x020D;
+
+ /**
+ * See the PIM specification here:
+ * http://www.ozhiker.com/electronics/pjmt/jpeg_info/pim.html
+ */
+ public static final int TAG_OLYMPUS_PRINT_IMAGE_MATCHING_INFO = 0x0E00;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_DATA_DUMP = 0x0F00;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FLASH_MODE = 0x1004;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_BRACKET = 0x1006;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FOCUS_MODE = 0x100B;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FOCUS_DISTANCE = 0x100C;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_ZOOM = 0x100D;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_MACRO_FOCUS = 0x100E;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_SHARPNESS = 0x100F;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_COLOUR_MATRIX = 0x1011;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_BLACK_LEVEL = 0x1012;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_WHITE_BALANCE = 0x1015;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_RED_BIAS = 0x1017;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_BLUE_BIAS = 0x1018;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_SERIAL_NUMBER = 0x101A;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FLASH_BIAS = 0x1023;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_CONTRAST = 0x1029;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_SHARPNESS_FACTOR = 0x102A;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_COLOUR_CONTROL = 0x102B;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_VALID_BITS = 0x102C;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_CORING_FILTER = 0x102D;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FINAL_WIDTH = 0x102E;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_FINAL_HEIGHT = 0x102F;
+
+ /**
+ *
+ */
+ public static final int TAG_OLYMPUS_COMPRESSION_RATIO = 0x1034;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static
+ {
+ tagNameMap.put(new Integer(TAG_OLYMPUS_SPECIAL_MODE), "Special Mode");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_JPEG_QUALITY), "Jpeg Quality");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MACRO_MODE), "Macro");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_UNKNOWN_1), "Makernote Unknown 1");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_DIGI_ZOOM_RATIO), "DigiZoom Ratio");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_UNKNOWN_2), "Makernote Unknown 2");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_UNKNOWN_3), "Makernote Unknown 3");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FIRMWARE_VERSION), "Firmware Version");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_PICT_INFO), "Pict Info");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_CAMERA_ID), "Camera Id");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_DATA_DUMP), "Data Dump");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MAKERNOTE_VERSION), "Makernote Version");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_CAMERA_SETTINGS_1), "Camera Settings");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_CAMERA_SETTINGS_2), "Camera Settings");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_COMPRESSED_IMAGE_SIZE), "Compressed Image Size");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MINOLTA_THUMBNAIL_OFFSET_1), "Thumbnail Offset");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MINOLTA_THUMBNAIL_OFFSET_2), "Thumbnail Offset");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MINOLTA_THUMBNAIL_LENGTH), "Thumbnail Length");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_COLOUR_MODE), "Colour Mode");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_IMAGE_QUALITY_1), "Image Quality");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_IMAGE_QUALITY_2), "Image Quality");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_IMAGE_HEIGHT), "Image Height");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_ORIGINAL_MANUFACTURER_MODEL), "Original Manufacturer Model");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_PRINT_IMAGE_MATCHING_INFO), "Print Image Matching (PIM) Info");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FLASH_MODE), "Flash Mode");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_BRACKET), "Bracket");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FOCUS_MODE), "Focus Mode");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FOCUS_DISTANCE), "Focus Distance");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_ZOOM), "Zoom");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_MACRO_FOCUS), "Macro Focus");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_SHARPNESS), "Sharpness");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_COLOUR_MATRIX), "Colour Matrix");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_BLACK_LEVEL), "Black Level");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_WHITE_BALANCE), "White Balance");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_RED_BIAS), "Red Bias");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_BLUE_BIAS), "Blue Bias");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_SERIAL_NUMBER), "Serial Number");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FLASH_BIAS), "Flash Bias");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_CONTRAST), "Contrast");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_SHARPNESS_FACTOR), "Sharpness Factor");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_COLOUR_CONTROL), "Colour Control");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_VALID_BITS), "Valid Bits");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_CORING_FILTER), "Coring Filter");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FINAL_WIDTH), "Final Width");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_FINAL_HEIGHT), "Final Height");
+ tagNameMap.put(new Integer(TAG_OLYMPUS_COMPRESSION_RATIO), "Compression Ratio");
+ }
+
+ public OlympusMakernoteDirectory()
+ {
+ this.setDescriptor(new OlympusMakernoteDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Olympus Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,85 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ * Provides human-readable string versions of the tags stored in a PanasonicMakernoteDirectory.
+ *
+ * Some information about this makernote taken from here:
+ * http://www.ozhiker.com/electronics/pjmt/jpeg_info/panasonic_mn.html
+ */
+public class PanasonicMakernoteDescriptor extends TagDescriptor
+{
+ public PanasonicMakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType)
+ {
+ case PanasonicMakernoteDirectory.TAG_PANASONIC_MACRO_MODE:
+ return getMacroModeDescription();
+ case PanasonicMakernoteDirectory.TAG_PANASONIC_RECORD_MODE:
+ return getRecordModeDescription();
+ case PanasonicMakernoteDirectory.TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO:
+ return getPrintImageMatchingInfoDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getPrintImageMatchingInfoDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PanasonicMakernoteDirectory.TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO)) return null;
+ byte[] bytes = _directory.getByteArray(PanasonicMakernoteDirectory.TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO);
+ return "(" + bytes.length + " bytes)";
+ }
+
+ public String getMacroModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PanasonicMakernoteDirectory.TAG_PANASONIC_MACRO_MODE)) return null;
+ int value = _directory.getInt(PanasonicMakernoteDirectory.TAG_PANASONIC_MACRO_MODE);
+ switch (value) {
+ case 1:
+ return "On";
+ case 2:
+ return "Off";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getRecordModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PanasonicMakernoteDirectory.TAG_PANASONIC_RECORD_MODE)) return null;
+ int value = _directory.getInt(PanasonicMakernoteDirectory.TAG_PANASONIC_RECORD_MODE);
+ switch (value) {
+ case 1:
+ return "Normal";
+ case 2:
+ return "Portrait";
+ case 9:
+ return "Macro";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/PanasonicMakernoteDirectory.java (revision 4231)
@@ -0,0 +1,68 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ *
+ */
+public class PanasonicMakernoteDirectory extends Directory
+{
+ public static final int TAG_PANASONIC_QUALITY_MODE = 0x0001;
+ public static final int TAG_PANASONIC_VERSION = 0x0002;
+ /**
+ * 1 = On
+ * 2 = Off
+ */
+ public static final int TAG_PANASONIC_MACRO_MODE = 0x001C;
+ /**
+ * 1 = Normal
+ * 2 = Portrait
+ * 9 = Macro
+ */
+ public static final int TAG_PANASONIC_RECORD_MODE = 0x001F;
+ public static final int TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO = 0x0E00;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static
+ {
+ tagNameMap.put(new Integer(TAG_PANASONIC_QUALITY_MODE), "Quality Mode");
+ tagNameMap.put(new Integer(TAG_PANASONIC_VERSION), "Version");
+ tagNameMap.put(new Integer(TAG_PANASONIC_MACRO_MODE), "Macro Mode");
+ tagNameMap.put(new Integer(TAG_PANASONIC_RECORD_MODE), "Record Mode");
+ tagNameMap.put(new Integer(TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO), "Print Image Matching (PIM) Info");
+ }
+
+ public PanasonicMakernoteDirectory()
+ {
+ this.setDescriptor(new PanasonicMakernoteDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Panasonic Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/PentaxMakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/PentaxMakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/PentaxMakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,248 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ * Provides human-readable string versions of the tags stored in PentaxMakernoteDirectory.
+ *
+ * Some information about this makernote taken from here:
+ * http://www.ozhiker.com/electronics/pjmt/jpeg_info/pentax_mn.html
+ */
+public class PentaxMakernoteDescriptor extends TagDescriptor
+{
+ public PentaxMakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType)
+ {
+ case PentaxMakernoteDirectory.TAG_PENTAX_CAPTURE_MODE:
+ return getCaptureModeDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_QUALITY_LEVEL:
+ return getQualityLevelDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_FOCUS_MODE:
+ return getFocusModeDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_FLASH_MODE:
+ return getFlashModeDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_WHITE_BALANCE:
+ return getWhiteBalanceDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_DIGITAL_ZOOM:
+ return getDigitalZoomDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_SHARPNESS:
+ return getSharpnessDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_CONTRAST:
+ return getContrastDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_SATURATION:
+ return getSaturationDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_ISO_SPEED:
+ return getIsoSpeedDescription();
+ case PentaxMakernoteDirectory.TAG_PENTAX_COLOUR:
+ return getColourDescription();
+ default:
+ return _directory.getString(tagType);
+ }
+ }
+
+ public String getColourDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_COLOUR)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_COLOUR);
+ switch (value)
+ {
+ case 1: return "Normal";
+ case 2: return "Black & White";
+ case 3: return "Sepia";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getIsoSpeedDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_ISO_SPEED)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_ISO_SPEED);
+ switch (value)
+ {
+ // TODO there must be other values which aren't catered for here
+ case 10: return "ISO 100";
+ case 16: return "ISO 200";
+ case 100: return "ISO 100";
+ case 200: return "ISO 200";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSaturationDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_SATURATION)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_SATURATION);
+ switch (value)
+ {
+ case 0: return "Normal";
+ case 1: return "Low";
+ case 2: return "High";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getContrastDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_CONTRAST)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_CONTRAST);
+ switch (value)
+ {
+ case 0: return "Normal";
+ case 1: return "Low";
+ case 2: return "High";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getSharpnessDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_SHARPNESS)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_SHARPNESS);
+ switch (value)
+ {
+ case 0: return "Normal";
+ case 1: return "Soft";
+ case 2: return "Hard";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getDigitalZoomDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_DIGITAL_ZOOM)) return null;
+ float value = _directory.getFloat(PentaxMakernoteDirectory.TAG_PENTAX_DIGITAL_ZOOM);
+ if (value==0)
+ return "Off";
+ return Float.toString(value);
+ }
+
+ public String getWhiteBalanceDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_WHITE_BALANCE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_WHITE_BALANCE);
+ switch (value)
+ {
+ case 0: return "Auto";
+ case 1: return "Daylight";
+ case 2: return "Shade";
+ case 3: return "Tungsten";
+ case 4: return "Fluorescent";
+ case 5: return "Manual";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFlashModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_FLASH_MODE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_FLASH_MODE);
+ switch (value)
+ {
+ case 1: return "Auto";
+ case 2: return "Flash On";
+ case 4: return "Flash Off";
+ case 6: return "Red-eye Reduction";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getFocusModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_FOCUS_MODE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_FOCUS_MODE);
+ switch (value)
+ {
+ case 2: return "Custom";
+ case 3: return "Auto";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getQualityLevelDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_QUALITY_LEVEL)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_QUALITY_LEVEL);
+ switch (value)
+ {
+ case 0: return "Good";
+ case 1: return "Better";
+ case 2: return "Best";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getCaptureModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PENTAX_CAPTURE_MODE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PENTAX_CAPTURE_MODE);
+ switch (value)
+ {
+ case 1: return "Auto";
+ case 2: return "Night-scene";
+ case 3: return "Manual";
+ case 4: return "Multiple";
+ default: return "Unknown (" + value + ")";
+ }
+ }
+
+/*
+ public String getPrintImageMatchingInfoDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO)) return null;
+ byte[] bytes = _directory.getByteArray(PentaxMakernoteDirectory.TAG_PANASONIC_PRINT_IMAGE_MATCHING_INFO);
+ return "(" + bytes.length + " bytes)";
+ }
+
+ public String getMacroModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PANASONIC_MACRO_MODE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PANASONIC_MACRO_MODE);
+ switch (value) {
+ case 1:
+ return "On";
+ case 2:
+ return "Off";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+
+ public String getRecordModeDescription() throws MetadataException
+ {
+ if (!_directory.containsTag(PentaxMakernoteDirectory.TAG_PANASONIC_RECORD_MODE)) return null;
+ int value = _directory.getInt(PentaxMakernoteDirectory.TAG_PANASONIC_RECORD_MODE);
+ switch (value) {
+ case 1:
+ return "Normal";
+ case 2:
+ return "Portrait";
+ case 9:
+ return "Macro";
+ default:
+ return "Unknown (" + value + ")";
+ }
+ }
+*/
+}
Index: /trunk/src/com/drew/metadata/exif/PentaxMakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/PentaxMakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/PentaxMakernoteDirectory.java (revision 4231)
@@ -0,0 +1,158 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 27-Nov-2002 10:10:47 using IntelliJ IDEA.
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * Directory for metadata specific to Pentax and Asahi cameras.
+ */
+public class PentaxMakernoteDirectory extends Directory
+{
+ /**
+ * 0 = Auto
+ * 1 = Night-scene
+ * 2 = Manual
+ * 4 = Multiple
+ */
+ public static final int TAG_PENTAX_CAPTURE_MODE = 0x0001;
+
+ /**
+ * 0 = Good
+ * 1 = Better
+ * 2 = Best
+ */
+ public static final int TAG_PENTAX_QUALITY_LEVEL = 0x0002;
+
+ /**
+ * 2 = Custom
+ * 3 = Auto
+ */
+ public static final int TAG_PENTAX_FOCUS_MODE = 0x0003;
+
+ /**
+ * 1 = Auto
+ * 2 = Flash on
+ * 4 = Flash off
+ * 6 = Red-eye Reduction
+ */
+ public static final int TAG_PENTAX_FLASH_MODE = 0x0004;
+
+ /**
+ * 0 = Auto
+ * 1 = Daylight
+ * 2 = Shade
+ * 3 = Tungsten
+ * 4 = Fluorescent
+ * 5 = Manual
+ */
+ public static final int TAG_PENTAX_WHITE_BALANCE = 0x0007;
+
+ /**
+ * (0 = Off)
+ */
+ public static final int TAG_PENTAX_DIGITAL_ZOOM = 0x000A;
+
+ /**
+ * 0 = Normal
+ * 1 = Soft
+ * 2 = Hard
+ */
+ public static final int TAG_PENTAX_SHARPNESS = 0x000B;
+
+ /**
+ * 0 = Normal
+ * 1 = Low
+ * 2 = High
+ */
+ public static final int TAG_PENTAX_CONTRAST = 0x000C;
+
+ /**
+ * 0 = Normal
+ * 1 = Low
+ * 2 = High
+ */
+ public static final int TAG_PENTAX_SATURATION = 0x000D;
+
+ /**
+ * 10 = ISO 100
+ * 16 = ISO 200
+ * 100 = ISO 100
+ * 200 = ISO 200
+ */
+ public static final int TAG_PENTAX_ISO_SPEED = 0x0014;
+
+ /**
+ * 1 = Normal
+ * 2 = Black & White
+ * 3 = Sepia
+ */
+ public static final int TAG_PENTAX_COLOUR = 0x0017;
+
+ /**
+ * See Print Image Matching for specification.
+ * http://www.ozhiker.com/electronics/pjmt/jpeg_info/pim.html
+ */
+ public static final int TAG_PENTAX_PRINT_IMAGE_MATCHING_INFO = 0x0E00;
+
+ /**
+ * (String).
+ */
+ public static final int TAG_PENTAX_TIME_ZONE = 0x1000;
+
+ /**
+ * (String).
+ */
+ public static final int TAG_PENTAX_DAYLIGHT_SAVINGS = 0x1001;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static
+ {
+ tagNameMap.put(new Integer(TAG_PENTAX_CAPTURE_MODE), "Capture Mode");
+ tagNameMap.put(new Integer(TAG_PENTAX_QUALITY_LEVEL), "Quality Level");
+ tagNameMap.put(new Integer(TAG_PENTAX_FOCUS_MODE), "Focus Mode");
+ tagNameMap.put(new Integer(TAG_PENTAX_FLASH_MODE), "Flash Mode");
+ tagNameMap.put(new Integer(TAG_PENTAX_WHITE_BALANCE), "White Balance");
+ tagNameMap.put(new Integer(TAG_PENTAX_DIGITAL_ZOOM), "Digital Zoom");
+ tagNameMap.put(new Integer(TAG_PENTAX_SHARPNESS), "Sharpness");
+ tagNameMap.put(new Integer(TAG_PENTAX_CONTRAST), "Contrast");
+ tagNameMap.put(new Integer(TAG_PENTAX_SATURATION), "Saturation");
+ tagNameMap.put(new Integer(TAG_PENTAX_ISO_SPEED), "ISO Speed");
+ tagNameMap.put(new Integer(TAG_PENTAX_COLOUR), "Colour");
+ tagNameMap.put(new Integer(TAG_PENTAX_PRINT_IMAGE_MATCHING_INFO), "Print Image Matching (PIM) Info");
+ tagNameMap.put(new Integer(TAG_PENTAX_TIME_ZONE), "Time Zone");
+ tagNameMap.put(new Integer(TAG_PENTAX_DAYLIGHT_SAVINGS), "Daylight Savings");
+ }
+
+ public PentaxMakernoteDirectory()
+ {
+ this.setDescriptor(new PentaxMakernoteDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Pentax Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/SonyMakernoteDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/SonyMakernoteDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/SonyMakernoteDescriptor.java (revision 4231)
@@ -0,0 +1,36 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ * Provides human-readable string versions of the tags stored in a SonyMakernoteDirectory.
+ * Thanks to David Carson for the initial version of this class.
+ */
+public class SonyMakernoteDescriptor extends TagDescriptor
+{
+ public SonyMakernoteDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ return _directory.getString(tagType);
+ }
+}
Index: /trunk/src/com/drew/metadata/exif/SonyMakernoteDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/exif/SonyMakernoteDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/exif/SonyMakernoteDirectory.java (revision 4231)
@@ -0,0 +1,37 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.exif;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ * Describes tags specific to Sony cameras.
+ */
+public class SonyMakernoteDirectory extends Directory
+{
+ protected static final HashMap _tagNameMap = new HashMap();
+
+ public String getName()
+ {
+ return "Sony Makernote";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return _tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/iptc/IptcDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/iptc/IptcDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/iptc/IptcDescriptor.java (revision 4231)
@@ -0,0 +1,36 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 21-Nov-2002 17:58:19 using IntelliJ IDEA.
+ */
+package com.drew.metadata.iptc;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ *
+ */
+public class IptcDescriptor extends TagDescriptor
+{
+ public IptcDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType)
+ {
+ return _directory.getString(tagType);
+ }
+}
Index: /trunk/src/com/drew/metadata/iptc/IptcDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/iptc/IptcDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/iptc/IptcDirectory.java (revision 4231)
@@ -0,0 +1,97 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 26-Nov-2002 01:26:39 using IntelliJ IDEA.
+ */
+package com.drew.metadata.iptc;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ *
+ */
+public class IptcDirectory extends Directory
+{
+ public static final int TAG_RECORD_VERSION = 0x0200;
+ public static final int TAG_CAPTION = 0x0278;
+ public static final int TAG_WRITER = 0x027a;
+ public static final int TAG_HEADLINE = 0x0269;
+ public static final int TAG_SPECIAL_INSTRUCTIONS = 0x0228;
+ public static final int TAG_BY_LINE = 0x0250;
+ public static final int TAG_BY_LINE_TITLE = 0x0255;
+ public static final int TAG_CREDIT = 0x026e;
+ public static final int TAG_SOURCE = 0x0273;
+ public static final int TAG_OBJECT_NAME = 0x0205;
+ public static final int TAG_DATE_CREATED = 0x0237;
+ public static final int TAG_CITY = 0x025a;
+ public static final int TAG_PROVINCE_OR_STATE = 0x025f;
+ public static final int TAG_COUNTRY_OR_PRIMARY_LOCATION = 0x0265;
+ public static final int TAG_ORIGINAL_TRANSMISSION_REFERENCE = 0x0267;
+ public static final int TAG_CATEGORY = 0x020f;
+ public static final int TAG_SUPPLEMENTAL_CATEGORIES = 0x0214;
+ public static final int TAG_URGENCY = 0x0200 | 10;
+ public static final int TAG_KEYWORDS = 0x0200 | 25;
+ public static final int TAG_COPYRIGHT_NOTICE = 0x0274;
+ public static final int TAG_RELEASE_DATE = 0x0200 | 30;
+ public static final int TAG_RELEASE_TIME = 0x0200 | 35;
+ public static final int TAG_TIME_CREATED = 0x0200 | 60;
+ public static final int TAG_ORIGINATING_PROGRAM = 0x0200 | 65;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static
+ {
+ tagNameMap.put(new Integer(TAG_RECORD_VERSION), "Directory Version");
+ tagNameMap.put(new Integer(TAG_CAPTION), "Caption/Abstract");
+ tagNameMap.put(new Integer(TAG_WRITER), "Writer/Editor");
+ tagNameMap.put(new Integer(TAG_HEADLINE), "Headline");
+ tagNameMap.put(new Integer(TAG_SPECIAL_INSTRUCTIONS), "Special Instructions");
+ tagNameMap.put(new Integer(TAG_BY_LINE), "By-line");
+ tagNameMap.put(new Integer(TAG_BY_LINE_TITLE), "By-line Title");
+ tagNameMap.put(new Integer(TAG_CREDIT), "Credit");
+ tagNameMap.put(new Integer(TAG_SOURCE), "Source");
+ tagNameMap.put(new Integer(TAG_OBJECT_NAME), "Object Name");
+ tagNameMap.put(new Integer(TAG_DATE_CREATED), "Date Created");
+ tagNameMap.put(new Integer(TAG_CITY), "City");
+ tagNameMap.put(new Integer(TAG_PROVINCE_OR_STATE), "Province/State");
+ tagNameMap.put(new Integer(TAG_COUNTRY_OR_PRIMARY_LOCATION), "Country/Primary Location");
+ tagNameMap.put(new Integer(TAG_ORIGINAL_TRANSMISSION_REFERENCE), "Original Transmission Reference");
+ tagNameMap.put(new Integer(TAG_CATEGORY), "Category");
+ tagNameMap.put(new Integer(TAG_SUPPLEMENTAL_CATEGORIES), "Supplemental Category(s)");
+ tagNameMap.put(new Integer(TAG_URGENCY), "Urgency");
+ tagNameMap.put(new Integer(TAG_KEYWORDS), "Keywords");
+ tagNameMap.put(new Integer(TAG_COPYRIGHT_NOTICE), "Copyright Notice");
+ tagNameMap.put(new Integer(TAG_RELEASE_DATE), "Release Date");
+ tagNameMap.put(new Integer(TAG_RELEASE_TIME), "Release Time");
+ tagNameMap.put(new Integer(TAG_TIME_CREATED), "Time Created");
+ tagNameMap.put(new Integer(TAG_ORIGINATING_PROGRAM), "Originating Program");
+ }
+
+ public IptcDirectory()
+ {
+ this.setDescriptor(new IptcDescriptor(this));
+ }
+
+ public String getName()
+ {
+ return "Iptc";
+ }
+
+ protected HashMap getTagNameMap()
+ {
+ return tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/iptc/IptcProcessingException.java
===================================================================
--- /trunk/src/com/drew/metadata/iptc/IptcProcessingException.java (revision 4231)
+++ /trunk/src/com/drew/metadata/iptc/IptcProcessingException.java (revision 4231)
@@ -0,0 +1,51 @@
+/*
+ * ExifProcessingException.java
+ *
+ * This class 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created on 29 April 2002, 00:33
+ */
+
+package com.drew.metadata.iptc;
+
+import com.drew.metadata.MetadataException;
+
+/**
+ * The exception type raised during reading of Iptc data in the instance of
+ * unexpected data conditions.
+ * @author Drew Noakes http://drewnoakes.com
+ */
+public class IptcProcessingException extends MetadataException
+{
+ /**
+ * Constructs an instance of
+ * :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 ................
+ * ExifProcessingException with the
+ * specified detail message.
+ * @param message the detail message
+ */
+ public IptcProcessingException(String message)
+ {
+ super(message);
+ }
+
+ /**
+ * Constructs an instance of IptcProcessingException with the
+ * specified detail message and inner exception.
+ * @param message the detail message
+ * @param cause an inner exception
+ */
+ public IptcProcessingException(String message, Throwable cause)
+ {
+ super(message, cause);
+ }
+}
Index: /trunk/src/com/drew/metadata/iptc/IptcReader.java
===================================================================
--- /trunk/src/com/drew/metadata/iptc/IptcReader.java (revision 4231)
+++ /trunk/src/com/drew/metadata/iptc/IptcReader.java (revision 4231)
@@ -0,0 +1,225 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on 12-Nov-2002 19:00:03 using IntelliJ IDEA.
+ */
+package com.drew.metadata.iptc;
+
+import com.drew.imaging.jpeg.JpegProcessingException;
+import com.drew.imaging.jpeg.JpegSegmentReader;
+import com.drew.metadata.Directory;
+import com.drew.metadata.Metadata;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.MetadataReader;
+
+import java.io.File;
+import java.io.InputStream;
+import java.util.Date;
+
+/**
+ *
+ */
+public class IptcReader implements MetadataReader
+{
+/*
+ public static final int DIRECTORY_IPTC = 2;
+
+ public static final int ENVELOPE_RECORD = 1;
+ public static final int APPLICATION_RECORD_2 = 2;
+ public static final int APPLICATION_RECORD_3 = 3;
+ public static final int APPLICATION_RECORD_4 = 4;
+ public static final int APPLICATION_RECORD_5 = 5;
+ public static final int APPLICATION_RECORD_6 = 6;
+ public static final int PRE_DATA_RECORD = 7;
+ public static final int DATA_RECORD = 8;
+ public static final int POST_DATA_RECORD = 9;
+*/
+ /**
+ * The Iptc data segment.
+ */
+ private final byte[] _data;
+
+ /**
+ * Creates a new IptcReader for the specified Jpeg jpegFile.
+ */
+ public IptcReader(File jpegFile) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(jpegFile).readSegment(JpegSegmentReader.SEGMENT_APPD));
+ }
+
+ /** Creates an IptcReader for a JPEG stream.
+ *
+ * @param is JPEG stream. Stream will be closed.
+ */
+ public IptcReader(InputStream is) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(is).readSegment(JpegSegmentReader.SEGMENT_APPD));
+ }
+
+ public IptcReader(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)
+ {
+ if (_data == null) {
+ return metadata;
+ }
+
+ Directory directory = metadata.getDirectory(IptcDirectory.class);
+
+ // find start of data
+ int offset = 0;
+ try {
+ while (offset < _data.length - 1 && get32Bits(offset) != 0x1c02) {
+ offset++;
+ }
+ } catch (MetadataException e) {
+ directory.addError("Couldn't find start of Iptc data (invalid segment)");
+ return metadata;
+ }
+
+ // for each tag
+ while (offset < _data.length) {
+ // identifies start of a tag
+ if (_data[offset] != 0x1c) {
+ break;
+ }
+ // we need at least five bytes left to read a tag
+ if ((offset + 5) >= _data.length) {
+ break;
+ }
+
+ offset++;
+
+ int directoryType;
+ int tagType;
+ int tagByteCount;
+ try {
+ directoryType = _data[offset++];
+ tagType = _data[offset++];
+ tagByteCount = get32Bits(offset);
+ } catch (MetadataException e) {
+ directory.addError("Iptc data segment ended mid-way through tag descriptor");
+ return metadata;
+ }
+ offset += 2;
+ if ((offset + tagByteCount) > _data.length) {
+ directory.addError("data for tag extends beyond end of iptc segment");
+ break;
+ }
+
+ processTag(directory, directoryType, tagType, offset, tagByteCount);
+ offset += tagByteCount;
+ }
+
+ return metadata;
+ }
+
+ /**
+ * Returns an int calculated from two bytes of data at the specified offset (MSB, LSB).
+ * @param offset position within the data buffer to read first byte
+ * @return the 32 bit int value, between 0x0000 and 0xFFFF
+ */
+ private int get32Bits(int offset) throws MetadataException
+ {
+ if (offset >= _data.length) {
+ throw new MetadataException("Attempt to read bytes from outside Iptc data buffer");
+ }
+ return ((_data[offset] & 255) << 8) | (_data[offset + 1] & 255);
+ }
+
+ /**
+ * This method serves as marsheller of objects for dataset. It converts from IPTC
+ * octets to relevant java object.
+ */
+ private void processTag(Directory directory, int directoryType, int tagType, int offset, int tagByteCount)
+ {
+ int tagIdentifier = tagType | (directoryType << 8);
+
+ switch (tagIdentifier) {
+ case IptcDirectory.TAG_RECORD_VERSION:
+ // short
+ short shortValue = (short)((_data[offset] << 8) | _data[offset + 1]);
+ directory.setInt(tagIdentifier, shortValue);
+ return;
+ case IptcDirectory.TAG_URGENCY:
+ // byte
+ directory.setInt(tagIdentifier, _data[offset]);
+ return;
+ case IptcDirectory.TAG_RELEASE_DATE:
+ case IptcDirectory.TAG_DATE_CREATED:
+ // Date object
+ if (tagByteCount >= 8) {
+ String dateStr = new String(_data, offset, tagByteCount);
+ try {
+ int year = Integer.parseInt(dateStr.substring(0, 4));
+ int month = Integer.parseInt(dateStr.substring(4, 6)) - 1;
+ int day = Integer.parseInt(dateStr.substring(6, 8));
+ Date date = (new java.util.GregorianCalendar(year, month, day)).getTime();
+ directory.setDate(tagIdentifier, date);
+ return;
+ } catch (NumberFormatException e) {
+ // fall through and we'll store whatever was there as a String
+ }
+ }
+ case IptcDirectory.TAG_RELEASE_TIME:
+ case IptcDirectory.TAG_TIME_CREATED:
+ // time...
+ default:
+ // fall through
+ }
+ // If no special handling by now, treat it as a string
+ String str;
+ if (tagByteCount < 1) {
+ str = "";
+ } else {
+ str = new String(_data, offset, tagByteCount);
+ }
+ if (directory.containsTag(tagIdentifier)) {
+ String[] oldStrings;
+ String[] newStrings;
+ try {
+ oldStrings = directory.getStringArray(tagIdentifier);
+ } catch (MetadataException e) {
+ oldStrings = null;
+ }
+ if (oldStrings == null) {
+ newStrings = new String[1];
+ } else {
+ newStrings = new String[oldStrings.length + 1];
+ for (int i = 0; i < oldStrings.length; i++) {
+ newStrings[i] = oldStrings[i];
+ }
+ }
+ newStrings[newStrings.length - 1] = str;
+ directory.setStringArray(tagIdentifier, newStrings);
+ } else {
+ directory.setString(tagIdentifier, str);
+ }
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegCommentDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegCommentDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegCommentDescriptor.java (revision 4231)
@@ -0,0 +1,37 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on Oct 10, 2003 using IntelliJ IDEA.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ *
+ * @author Drew Noakes http://drewnoakes.com
+ */
+public class JpegCommentDescriptor extends TagDescriptor
+{
+ public JpegCommentDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType)
+ {
+ return _directory.getString(tagType);
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegCommentDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegCommentDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegCommentDirectory.java (revision 4231)
@@ -0,0 +1,49 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on Oct 10, 2003 using IntelliJ IDEA.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.metadata.Directory;
+
+import java.util.HashMap;
+
+/**
+ *
+ * @author Drew Noakes http://drewnoakes.com
+ */
+public class JpegCommentDirectory extends Directory {
+
+ /** This is in bits/sample, usually 8 (12 and 16 not supported by most software). */
+ public static final int TAG_JPEG_COMMENT = 0;
+
+ protected static final HashMap tagNameMap = new HashMap();
+
+ static {
+ tagNameMap.put(new Integer(TAG_JPEG_COMMENT), "Jpeg Comment");
+ }
+
+ public JpegCommentDirectory() {
+ this.setDescriptor(new JpegCommentDescriptor(this));
+ }
+
+ public String getName() {
+ return "JpegComment";
+ }
+
+ protected HashMap getTagNameMap() {
+ return tagNameMap;
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegCommentReader.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegCommentReader.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegCommentReader.java (revision 4231)
@@ -0,0 +1,84 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on Oct 10, 2003 using IntelliJ IDEA.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.imaging.jpeg.JpegProcessingException;
+import com.drew.imaging.jpeg.JpegSegmentReader;
+import com.drew.metadata.Metadata;
+import com.drew.metadata.MetadataReader;
+
+import java.io.File;
+import java.io.InputStream;
+
+/**
+ *
+ * @author Drew Noakes http://drewnoakes.com
+ */
+public class JpegCommentReader implements MetadataReader
+{
+ /**
+ * The COM data segment.
+ */
+ private final byte[] _data;
+
+ /**
+ * Creates a new JpegReader for the specified Jpeg jpegFile.
+ */
+ public JpegCommentReader(File jpegFile) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(jpegFile).readSegment(JpegSegmentReader.SEGMENT_COM));
+ }
+
+ /** Creates a JpegCommentReader for a JPEG stream.
+ *
+ * @param is JPEG stream. Stream will be closed.
+ */
+ public JpegCommentReader(InputStream is) throws JpegProcessingException
+ {
+ this(new JpegSegmentReader(is).readSegment(JpegSegmentReader.SEGMENT_APPD));
+ }
+
+ public JpegCommentReader(byte[] data)
+ {
+ _data = data;
+ }
+
+ /**
+ * Performs the Jpeg data extraction, returning a new instance of Metadata.
+ */
+ public Metadata extract()
+ {
+ return extract(new Metadata());
+ }
+
+ /**
+ * Performs the Jpeg data extraction, adding found values to the specified
+ * instance of Metadata.
+ */
+ public Metadata extract(Metadata metadata)
+ {
+ if (_data==null) {
+ return metadata;
+ }
+
+ JpegCommentDirectory directory = (JpegCommentDirectory)metadata.getDirectory(JpegCommentDirectory.class);
+
+ directory.setString(JpegCommentDirectory.TAG_JPEG_COMMENT, new String(_data));
+
+ return metadata;
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegComponent.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegComponent.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegComponent.java (revision 4231)
@@ -0,0 +1,81 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created by dnoakes on Oct 9, 17:04:07 using IntelliJ IDEA.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.metadata.MetadataException;
+
+import java.io.Serializable;
+
+/**
+ * Created by IntelliJ IDEA.
+ * User: dnoakes
+ * Date: 09-Oct-2003
+ * Time: 17:04:07
+ * To change this template use Options | File Templates.
+ */
+public class JpegComponent implements Serializable
+{
+ private final int _componentId;
+ private final int _samplingFactorByte;
+ private final int _quantizationTableNumber;
+
+ public JpegComponent(int componentId, int samplingFactorByte, int quantizationTableNumber)
+ {
+ _componentId = componentId;
+ _samplingFactorByte = samplingFactorByte;
+ _quantizationTableNumber = quantizationTableNumber;
+ }
+
+ public int getComponentId()
+ {
+ return _componentId;
+ }
+
+ public String getComponentName() throws MetadataException
+ {
+ switch (_componentId)
+ {
+ case 1:
+ return "Y";
+ case 2:
+ return "Cb";
+ case 3:
+ return "Cr";
+ case 4:
+ return "I";
+ case 5:
+ return "Q";
+ }
+
+ throw new MetadataException("Unsupported component id: " + _componentId);
+ }
+
+ public int getQuantizationTableNumber()
+ {
+ return _quantizationTableNumber;
+ }
+
+ public int getHorizontalSamplingFactor()
+ {
+ return _samplingFactorByte & 0x0F;
+ }
+
+ public int getVerticalSamplingFactor()
+ {
+ return (_samplingFactorByte>>4) & 0x0F;
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegDescriptor.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegDescriptor.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegDescriptor.java (revision 4231)
@@ -0,0 +1,88 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+import com.drew.metadata.TagDescriptor;
+
+/**
+ * Provides human-readable string versions of the tags stored in a JpegDirectory.
+ * Thanks to Darrell Silver (www.darrellsilver.com) for the initial version of this class.
+ */
+public class JpegDescriptor extends TagDescriptor
+{
+ public JpegDescriptor(Directory directory)
+ {
+ super(directory);
+ }
+
+ public String getDescription(int tagType) throws MetadataException
+ {
+ switch (tagType)
+ {
+ case JpegDirectory.TAG_JPEG_COMPONENT_DATA_1:
+ return getComponentDataDescription(0);
+ case JpegDirectory.TAG_JPEG_COMPONENT_DATA_2:
+ return getComponentDataDescription(1);
+ case JpegDirectory.TAG_JPEG_COMPONENT_DATA_3:
+ return getComponentDataDescription(2);
+ case JpegDirectory.TAG_JPEG_COMPONENT_DATA_4:
+ return getComponentDataDescription(3);
+ case JpegDirectory.TAG_JPEG_DATA_PRECISION:
+ return getDataPrecisionDescription();
+ case JpegDirectory.TAG_JPEG_IMAGE_HEIGHT:
+ return getImageHeightDescription();
+ case JpegDirectory.TAG_JPEG_IMAGE_WIDTH:
+ return getImageWidthDescription();
+ }
+
+ return _directory.getString(tagType);
+ }
+
+ public String getImageWidthDescription()
+ {
+ return _directory.getString(JpegDirectory.TAG_JPEG_IMAGE_WIDTH) + " pixels";
+ }
+
+ public String getImageHeightDescription()
+ {
+ return _directory.getString(JpegDirectory.TAG_JPEG_IMAGE_HEIGHT) + " pixels";
+ }
+
+ public String getDataPrecisionDescription()
+ {
+ return _directory.getString(JpegDirectory.TAG_JPEG_DATA_PRECISION) + " bits";
+ }
+
+ public String getComponentDataDescription(int componentNumber) throws MetadataException
+ {
+ JpegComponent component = ((JpegDirectory)_directory).getComponent(componentNumber);
+
+ if (component==null)
+ throw new MetadataException("No Jpeg component exists with number " + componentNumber);
+
+ StringBuffer sb = new StringBuffer();
+ sb.append(component.getComponentName());
+ sb.append(" component: Quantization table ");
+ sb.append(component.getQuantizationTableNumber());
+ sb.append(", Sampling factors ");
+ sb.append(component.getHorizontalSamplingFactor());
+ sb.append(" horiz/");
+ sb.append(component.getVerticalSamplingFactor());
+ sb.append(" vert");
+ return sb.toString();
+ }
+}
Index: /trunk/src/com/drew/metadata/jpeg/JpegDirectory.java
===================================================================
--- /trunk/src/com/drew/metadata/jpeg/JpegDirectory.java (revision 4231)
+++ /trunk/src/com/drew/metadata/jpeg/JpegDirectory.java (revision 4231)
@@ -0,0 +1,111 @@
+/*
+ * This 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. 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.
+ *
+ * If you make use of this code, I'd appreciate hearing about it.
+ * drew@drewnoakes.com
+ * Latest version of this software kept at
+ * http://drewnoakes.com/
+ *
+ * Created on Aug 2, 2003.
+ */
+package com.drew.metadata.jpeg;
+
+import com.drew.metadata.Directory;
+import com.drew.metadata.MetadataException;
+
+import java.util.HashMap;
+
+/**
+ * Directory of tags and values for the SOF0 Jpeg segment. This segment holds basic metadata about the image.
+ * @author Darrell Silver http://www.darrellsilver.com and Drew Noakes
+ */
+public class JpegDirectory extends Directory {
+
+ /** This is in bits/sample, usually 8 (12 and 16 not supported by most software). */
+ public static final int TAG_JPEG_DATA_PRECISION = 0;
+ /** The image's height. Necessary for decoding the image, so it should always be there. */
+ public static final int TAG_JPEG_IMAGE_HEIGHT = 1;
+ /** The image's width. Necessary for decoding the image, so it should always be there. */
+ public static final int TAG_JPEG_IMAGE_WIDTH = 3;
+ /** Usually 1 = grey scaled, 3 = color YcbCr or YIQ, 4 = color CMYK
+ * Each component TAG_COMPONENT_DATA_[1-4], has the following meaning:
+ * component Id(1byte)(1 = Y, 2 = Cb, 3 = Cr, 4 = I, 5 = Q),
+ * sampling factors (1byte) (bit 0-3 vertical., 4-7 horizontal.),
+ * quantization table number (1 byte).
+ * Metadata.
+ */
+ public Metadata extract()
+ {
+ return extract(new Metadata());
+ }
+
+ /**
+ * Performs the Jpeg data extraction, adding found values to the specified
+ * instance of Metadata.
+ */
+ public Metadata extract(Metadata metadata)
+ {
+ if (_data==null) {
+ return metadata;
+ }
+
+ JpegDirectory directory = (JpegDirectory)metadata.getDirectory(JpegDirectory.class);
+
+ try {
+ // data precision
+ int dataPrecision = get16Bits(JpegDirectory.TAG_JPEG_DATA_PRECISION);
+ directory.setInt(JpegDirectory.TAG_JPEG_DATA_PRECISION, dataPrecision);
+
+ // process height
+ int height = get32Bits(JpegDirectory.TAG_JPEG_IMAGE_HEIGHT);
+ directory.setInt(JpegDirectory.TAG_JPEG_IMAGE_HEIGHT, height);
+
+ // process width
+ int width = get32Bits(JpegDirectory.TAG_JPEG_IMAGE_WIDTH);
+ directory.setInt(JpegDirectory.TAG_JPEG_IMAGE_WIDTH, width);
+
+ // number of components
+ int numberOfComponents = get16Bits(JpegDirectory.TAG_JPEG_NUMBER_OF_COMPONENTS);
+ directory.setInt(JpegDirectory.TAG_JPEG_NUMBER_OF_COMPONENTS, numberOfComponents);
+
+ // for each component, there are three bytes of data:
+ // 1 - Component ID: 1 = Y, 2 = Cb, 3 = Cr, 4 = I, 5 = Q
+ // 2 - Sampling factors: bit 0-3 vertical, 4-7 horizontal
+ // 3 - Quantization table number
+ int offset = 6;
+ for (int i=0; i
+ *
+ *
+ * @param string the literal string to be escaped
+ * @return the escaped form of {@code string}
+ * @throws NullPointerException if {@code string} is null
+ * @throws IllegalArgumentException if {@code string} contains badly formed
+ * UTF-16 or cannot be escaped for any other reason
+ */
+ public String escape(String string);
+
+ /**
+ * Returns an {@code Appendable} instance which automatically escapes all
+ * text appended to it before passing the resulting text to an underlying
+ * {@code Appendable}.
+ *
+ *
+ *
+ *
+ * @param out the underlying {@code Appendable} to append escaped output to
+ * @return an {@code Appendable} which passes text to {@code out} after
+ * escaping it.
+ */
+ public Appendable escape(Appendable out);
+}
Index: /trunk/src/com/google/gdata/util/common/base/PercentEscaper.java
===================================================================
--- /trunk/src/com/google/gdata/util/common/base/PercentEscaper.java (revision 4231)
+++ /trunk/src/com/google/gdata/util/common/base/PercentEscaper.java (revision 4231)
@@ -0,0 +1,275 @@
+/* Copyright (c) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+package com.google.gdata.util.common.base;
+
+/**
+ * A {@code UnicodeEscaper} that escapes some set of Java characters using
+ * the URI percent encoding scheme. The set of safe characters (those which
+ * remain unescaped) can be specified on construction.
+ *
+ *
+ *
+ *
+ *
+ * "URI producers and normalizers should use uppercase hexadecimal digits
+ * for all percent-encodings."
+ *
+ *
+ */
+public class PercentEscaper extends UnicodeEscaper {
+ /**
+ * A string of safe characters that mimics the behavior of
+ * {@link java.net.URLEncoder}.
+ *
+ */
+ public static final String SAFECHARS_URLENCODER = "-_.*";
+
+ /**
+ * A string of characters that do not need to be encoded when used in URI
+ * path segments, as specified in RFC 3986. Note that some of these
+ * characters do need to be escaped when used in other parts of the URI.
+ */
+ public static final String SAFEPATHCHARS_URLENCODER = "-_.!~*'()@:$&,;=";
+
+ /**
+ * A string of characters that do not need to be encoded when used in URI
+ * query strings, as specified in RFC 3986. Note that some of these
+ * characters do need to be escaped when used in other parts of the URI.
+ */
+ public static final String SAFEQUERYSTRINGCHARS_URLENCODER
+ = "-_.!~*'()@:$,;/?:";
+
+ // In some uri escapers spaces are escaped to '+'
+ private static final char[] URI_ESCAPED_SPACE = { '+' };
+
+ private static final char[] UPPER_HEX_DIGITS =
+ "0123456789ABCDEF".toCharArray();
+
+ /**
+ * If true we should convert space to the {@code +} character.
+ */
+ private final boolean plusForSpace;
+
+ /**
+ * An array of flags where for any {@code char c} if {@code safeOctets[c]} is
+ * true then {@code c} should remain unmodified in the output. If
+ * {@code c > safeOctets.length} then it should be escaped.
+ */
+ private final boolean[] safeOctets;
+
+ /**
+ * Constructs a URI escaper with the specified safe characters and optional
+ * handling of the space character.
+ *
+ * @param safeChars a non null string specifying additional safe characters
+ * for this escaper (the ranges 0..9, a..z and A..Z are always safe and
+ * should not be specified here)
+ * @param plusForSpace true if ASCII space should be escaped to {@code +}
+ * rather than {@code %20}
+ * @throws IllegalArgumentException if any of the parameters were invalid
+ */
+ public PercentEscaper(String safeChars, boolean plusForSpace) {
+ // Avoid any misunderstandings about the behavior of this escaper
+ if (safeChars.matches(".*[0-9A-Za-z].*")) {
+ throw new IllegalArgumentException(
+ "Alphanumeric characters are always 'safe' and should not be " +
+ "explicitly specified");
+ }
+ // Avoid ambiguous parameters. Safe characters are never modified so if
+ // space is a safe character then setting plusForSpace is meaningless.
+ if (plusForSpace && safeChars.contains(" ")) {
+ throw new IllegalArgumentException(
+ "plusForSpace cannot be specified when space is a 'safe' character");
+ }
+ if (safeChars.contains("%")) {
+ throw new IllegalArgumentException(
+ "The '%' character cannot be specified as 'safe'");
+ }
+ this.plusForSpace = plusForSpace;
+ this.safeOctets = createSafeOctets(safeChars);
+ }
+
+ /**
+ * Creates a boolean[] with entries corresponding to the character values
+ * for 0-9, A-Z, a-z and those specified in safeChars set to true. The array
+ * is as small as is required to hold the given character information.
+ */
+ private static boolean[] createSafeOctets(String safeChars) {
+ int maxChar = 'z';
+ char[] safeCharArray = safeChars.toCharArray();
+ for (char c : safeCharArray) {
+ maxChar = Math.max(c, maxChar);
+ }
+ boolean[] octets = new boolean[maxChar + 1];
+ for (int c = '0'; c <= '9'; c++) {
+ octets[c] = true;
+ }
+ for (int c = 'A'; c <= 'Z'; c++) {
+ octets[c] = true;
+ }
+ for (int c = 'a'; c <= 'z'; c++) {
+ octets[c] = true;
+ }
+ for (char c : safeCharArray) {
+ octets[c] = true;
+ }
+ return octets;
+ }
+
+ /*
+ * Overridden for performance. For unescaped strings this improved the
+ * performance of the uri escaper from ~760ns to ~400ns as measured by
+ * {@link CharEscapersBenchmark}.
+ */
+ @Override
+ protected int nextEscapeIndex(CharSequence csq, int index, int end) {
+ for (; index < end; index++) {
+ char c = csq.charAt(index);
+ if (c >= safeOctets.length || !safeOctets[c]) {
+ break;
+ }
+ }
+ return index;
+ }
+
+ /*
+ * Overridden for performance. For unescaped strings this improved the
+ * performance of the uri escaper from ~400ns to ~170ns as measured by
+ * {@link CharEscapersBenchmark}.
+ */
+ @Override
+ public String escape(String s) {
+ int slen = s.length();
+ for (int index = 0; index < slen; index++) {
+ char c = s.charAt(index);
+ if (c >= safeOctets.length || !safeOctets[c]) {
+ return escapeSlow(s, index);
+ }
+ }
+ return s;
+ }
+
+ /**
+ * Escapes the given Unicode code point in UTF-8.
+ */
+ @Override
+ protected char[] escape(int cp) {
+ // We should never get negative values here but if we do it will throw an
+ // IndexOutOfBoundsException, so at least it will get spotted.
+ if (cp < safeOctets.length && safeOctets[cp]) {
+ return null;
+ } else if (cp == ' ' && plusForSpace) {
+ return URI_ESCAPED_SPACE;
+ } else if (cp <= 0x7F) {
+ // Single byte UTF-8 characters
+ // Start with "%--" and fill in the blanks
+ char[] dest = new char[3];
+ dest[0] = '%';
+ dest[2] = UPPER_HEX_DIGITS[cp & 0xF];
+ dest[1] = UPPER_HEX_DIGITS[cp >>> 4];
+ return dest;
+ } else if (cp <= 0x7ff) {
+ // Two byte UTF-8 characters [cp >= 0x80 && cp <= 0x7ff]
+ // Start with "%--%--" and fill in the blanks
+ char[] dest = new char[6];
+ dest[0] = '%';
+ dest[3] = '%';
+ dest[5] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[2] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[1] = UPPER_HEX_DIGITS[0xC | cp];
+ return dest;
+ } else if (cp <= 0xffff) {
+ // Three byte UTF-8 characters [cp >= 0x800 && cp <= 0xffff]
+ // Start with "%E-%--%--" and fill in the blanks
+ char[] dest = new char[9];
+ dest[0] = '%';
+ dest[1] = 'E';
+ dest[3] = '%';
+ dest[6] = '%';
+ dest[8] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[7] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[5] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[2] = UPPER_HEX_DIGITS[cp];
+ return dest;
+ } else if (cp <= 0x10ffff) {
+ char[] dest = new char[12];
+ // Four byte UTF-8 characters [cp >= 0xffff && cp <= 0x10ffff]
+ // Start with "%F-%--%--%--" and fill in the blanks
+ dest[0] = '%';
+ dest[1] = 'F';
+ dest[3] = '%';
+ dest[6] = '%';
+ dest[9] = '%';
+ dest[11] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[10] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[8] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[7] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[5] = UPPER_HEX_DIGITS[cp & 0xF];
+ cp >>>= 4;
+ dest[4] = UPPER_HEX_DIGITS[0x8 | (cp & 0x3)];
+ cp >>>= 2;
+ dest[2] = UPPER_HEX_DIGITS[cp & 0x7];
+ return dest;
+ } else {
+ // If this ever happens it is due to bug in UnicodeEscaper, not bad input.
+ throw new IllegalArgumentException(
+ "Invalid unicode character value " + cp);
+ }
+ }
+}
Index: /trunk/src/com/google/gdata/util/common/base/Preconditions.java
===================================================================
--- /trunk/src/com/google/gdata/util/common/base/Preconditions.java (revision 4231)
+++ /trunk/src/com/google/gdata/util/common/base/Preconditions.java (revision 4231)
@@ -0,0 +1,465 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.gdata.util.common.base;
+
+import java.util.Collection;
+import java.util.NoSuchElementException;
+
+/**
+ * Simple static methods to be called at the start of your own methods to verify
+ * correct arguments and state. This allows constructs such as
+ *
+ * if (count <= 0) {
+ * throw new IllegalArgumentException("must be positive: " + count);
+ * }
+ *
+ * to be replaced with the more compact
+ *
+ * checkArgument(count > 0, "must be positive: %s", count);
+ *
+ * Note that the sense of the expression is inverted; with {@code Preconditions}
+ * you declare what you expect to be true, just as you do with an
+ *
+ * {@code assert} or a JUnit {@code assertTrue()} call.
+ *
+ * {@code
+ *
+ * StringBuilder sb = new StringBuilder();
+ * escaper.escape(sb).append(string);
+ * return sb.toString();}
+ *
+ * @param out the underlying {@code Appendable} to append escaped output to
+ * @return an {@code Appendable} which passes text to {@code out} after
+ * escaping it
+ * @throws NullPointerException if {@code out} is null
+ * @throws IllegalArgumentException if invalid surrogate characters are
+ * encountered
+ *
+ */
+ public Appendable escape(final Appendable out) {
+ checkNotNull(out);
+
+ return new Appendable() {
+ int pendingHighSurrogate = -1;
+ char[] decodedChars = new char[2];
+
+ public Appendable append(CharSequence csq) throws IOException {
+ return append(csq, 0, csq.length());
+ }
+
+ public Appendable append(CharSequence csq, int start, int end)
+ throws IOException {
+ int index = start;
+ if (index < end) {
+ // This is a little subtle: index must never reference the middle of a
+ // surrogate pair but unescapedChunkStart can. The first time we enter
+ // the loop below it is possible that index != unescapedChunkStart.
+ int unescapedChunkStart = index;
+ if (pendingHighSurrogate != -1) {
+ // Our last append operation ended halfway through a surrogate pair
+ // so we have to do some extra work first.
+ char c = csq.charAt(index++);
+ if (!Character.isLowSurrogate(c)) {
+ throw new IllegalArgumentException(
+ "Expected low surrogate character but got " + c);
+ }
+ char[] escaped =
+ escape(Character.toCodePoint((char) pendingHighSurrogate, c));
+ if (escaped != null) {
+ // Emit the escaped character and adjust unescapedChunkStart to
+ // skip the low surrogate we have consumed.
+ outputChars(escaped, escaped.length);
+ unescapedChunkStart += 1;
+ } else {
+ // Emit pending high surrogate (unescaped) but do not modify
+ // unescapedChunkStart as we must still emit the low surrogate.
+ out.append((char) pendingHighSurrogate);
+ }
+ pendingHighSurrogate = -1;
+ }
+ while (true) {
+ // Find and append the next subsequence of unescaped characters.
+ index = nextEscapeIndex(csq, index, end);
+ if (index > unescapedChunkStart) {
+ out.append(csq, unescapedChunkStart, index);
+ }
+ if (index == end) {
+ break;
+ }
+ // If we are not finished, calculate the next code point.
+ int cp = codePointAt(csq, index, end);
+ if (cp < 0) {
+ // Our sequence ended half way through a surrogate pair so just
+ // record the state and exit.
+ pendingHighSurrogate = -cp;
+ break;
+ }
+ // Escape the code point and output the characters.
+ char[] escaped = escape(cp);
+ if (escaped != null) {
+ outputChars(escaped, escaped.length);
+ } else {
+ // This shouldn't really happen if nextEscapeIndex is correct but
+ // we should cope with false positives.
+ int len = Character.toChars(cp, decodedChars, 0);
+ outputChars(decodedChars, len);
+ }
+ // Update our index past the escaped character and continue.
+ index += (Character.isSupplementaryCodePoint(cp) ? 2 : 1);
+ unescapedChunkStart = index;
+ }
+ }
+ return this;
+ }
+
+ public Appendable append(char c) throws IOException {
+ if (pendingHighSurrogate != -1) {
+ // Our last append operation ended halfway through a surrogate pair
+ // so we have to do some extra work first.
+ if (!Character.isLowSurrogate(c)) {
+ throw new IllegalArgumentException(
+ "Expected low surrogate character but got '" + c +
+ "' with value " + (int) c);
+ }
+ char[] escaped =
+ escape(Character.toCodePoint((char) pendingHighSurrogate, c));
+ if (escaped != null) {
+ outputChars(escaped, escaped.length);
+ } else {
+ out.append((char) pendingHighSurrogate);
+ out.append(c);
+ }
+ pendingHighSurrogate = -1;
+ } else if (Character.isHighSurrogate(c)) {
+ // This is the start of a (split) surrogate pair.
+ pendingHighSurrogate = c;
+ } else {
+ if (Character.isLowSurrogate(c)) {
+ throw new IllegalArgumentException(
+ "Unexpected low surrogate character '" + c +
+ "' with value " + (int) c);
+ }
+ // This is a normal (non surrogate) char.
+ char[] escaped = escape(c);
+ if (escaped != null) {
+ outputChars(escaped, escaped.length);
+ } else {
+ out.append(c);
+ }
+ }
+ return this;
+ }
+
+ private void outputChars(char[] chars, int len) throws IOException {
+ for (int n = 0; n < len; n++) {
+ out.append(chars[n]);
+ }
+ }
+ };
+ }
+
+ /**
+ * Returns the Unicode code point of the character at the given index.
+ *
+ *
+ *
+ *
+ * @param seq the sequence of characters from which to decode the code point
+ * @param index the index of the first character to decode
+ * @param end the index beyond the last valid character to decode
+ * @return the Unicode code point for the given index or the negated value of
+ * the trailing high surrogate character at the end of the sequence
+ */
+ protected static final int codePointAt(CharSequence seq, int index, int end) {
+ if (index < end) {
+ char c1 = seq.charAt(index++);
+ if (c1 < Character.MIN_HIGH_SURROGATE ||
+ c1 > Character.MAX_LOW_SURROGATE) {
+ // Fast path (first test is probably all we need to do)
+ return c1;
+ } else if (c1 <= Character.MAX_HIGH_SURROGATE) {
+ // If the high surrogate was the last character, return its inverse
+ if (index == end) {
+ return -c1;
+ }
+ // Otherwise look for the low surrogate following it
+ char c2 = seq.charAt(index);
+ if (Character.isLowSurrogate(c2)) {
+ return Character.toCodePoint(c1, c2);
+ }
+ throw new IllegalArgumentException(
+ "Expected low surrogate but got char '" + c2 +
+ "' with value " + (int) c2 + " at index " + index);
+ } else {
+ throw new IllegalArgumentException(
+ "Unexpected low surrogate character '" + c1 +
+ "' with value " + (int) c1 + " at index " + (index - 1));
+ }
+ }
+ throw new IndexOutOfBoundsException("Index exceeds specified range");
+ }
+
+ /**
+ * Helper method to grow the character buffer as needed, this only happens
+ * once in a while so it's ok if it's in a method call. If the index passed
+ * in is 0 then no copying will be done.
+ */
+ private static final char[] growBuffer(char[] dest, int index, int size) {
+ char[] copy = new char[size];
+ if (index > 0) {
+ System.arraycopy(dest, 0, copy, 0, index);
+ }
+ return copy;
+ }
+
+ /**
+ * A thread-local destination buffer to keep us from creating new buffers.
+ * The starting size is 1024 characters. If we grow past this we don't
+ * put it back in the threadlocal, we just keep going and grow as needed.
+ */
+ private static final ThreadLocal
+ *
+ *
+ *
+ *
+ * String url = OAuth.addQueryParameters("http://example.com?a=1", b, 2, c, 3);
+ *
+ *
+ * which yields:
+ *
+ *
+ * http://example.com?a=1&b=2&c=3
+ *
+ *
+ * All parameters will be encoded according to OAuth's percent encoding
+ * rules.
+ *
+ * @param url
+ * the URL
+ * @param kvPairs
+ * the list of key/value pairs
+ * @return
+ */
+ public static String addQueryParameters(String url, String... kvPairs) {
+ String queryDelim = url.contains("?") ? "&" : "?";
+ StringBuilder sb = new StringBuilder(url + queryDelim);
+ for (int i = 0; i < kvPairs.length; i += 2) {
+ if (i > 0) {
+ sb.append("&");
+ }
+ sb.append(OAuth.percentEncode(kvPairs[i]) + "="
+ + OAuth.percentEncode(kvPairs[i + 1]));
+ }
+ return sb.toString();
+ }
+
+ public static String addQueryParameters(String url, Map
+ * String authHeader = OAuth.prepareOAuthHeader("realm", "http://example.com", "oauth_token", "x%y");
+ *
+ *
+ * which yields:
+ *
+ *
+ * OAuth realm="http://example.com", oauth_token="x%25y"
+ *
+ *
+ * @param kvPairs
+ * the list of key/value pairs
+ * @return a string eligible to be used as an OAuth HTTP Authorization
+ * header.
+ */
+ public static String prepareOAuthHeader(String... kvPairs) {
+ StringBuilder sb = new StringBuilder("OAuth ");
+ for (int i = 0; i < kvPairs.length; i += 2) {
+ if (i > 0) {
+ sb.append(", ");
+ }
+ String value = kvPairs[i].startsWith("oauth_") ? OAuth
+ .percentEncode(kvPairs[i + 1]) : kvPairs[i + 1];
+ sb.append(OAuth.percentEncode(kvPairs[i]) + "=\"" + value + "\"");
+ }
+ return sb.toString();
+ }
+
+ public static HttpParameters oauthHeaderToParamsMap(String oauthHeader) {
+ HttpParameters params = new HttpParameters();
+ if (oauthHeader == null || !oauthHeader.startsWith("OAuth ")) {
+ return params;
+ }
+ oauthHeader = oauthHeader.substring("OAuth ".length());
+ String[] elements = oauthHeader.split(",");
+ for (String keyValuePair : elements) {
+ String[] keyValue = keyValuePair.split("=");
+ params.put(keyValue[0].trim(), keyValue[1].replace("\"", "").trim());
+ }
+ return params;
+ }
+
+ /**
+ * Helper method to concatenate a parameter and its value to a pair that can
+ * be used in an HTTP header. This method percent encodes both parts before
+ * joining them.
+ *
+ * @param name
+ * the OAuth parameter name, e.g. oauth_token
+ * @param value
+ * the OAuth parameter value, e.g. 'hello oauth'
+ * @return a name/value pair, e.g. oauth_token="hello%20oauth"
+ */
+ public static String toHeaderElement(String name, String value) {
+ return OAuth.percentEncode(name) + "=\"" + OAuth.percentEncode(value) + "\"";
+ }
+
+ public static void debugOut(String key, String value) {
+ if (System.getProperty("debug") != null) {
+ System.out.println("[SIGNPOST] " + key + ": " + value);
+ }
+ }
+}
Index: /trunk/src/oauth/signpost/OAuthConsumer.java
===================================================================
--- /trunk/src/oauth/signpost/OAuthConsumer.java (revision 4231)
+++ /trunk/src/oauth/signpost/OAuthConsumer.java (revision 4231)
@@ -0,0 +1,193 @@
+/* Copyright (c) 2009 Matthias Kaeppler
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package oauth.signpost;
+
+import java.io.Serializable;
+
+import oauth.signpost.exception.OAuthCommunicationException;
+import oauth.signpost.exception.OAuthExpectationFailedException;
+import oauth.signpost.exception.OAuthMessageSignerException;
+import oauth.signpost.http.HttpParameters;
+import oauth.signpost.http.HttpRequest;
+import oauth.signpost.signature.AuthorizationHeaderSigningStrategy;
+import oauth.signpost.signature.HmacSha1MessageSigner;
+import oauth.signpost.signature.OAuthMessageSigner;
+import oauth.signpost.signature.PlainTextMessageSigner;
+import oauth.signpost.signature.QueryStringSigningStrategy;
+import oauth.signpost.signature.SigningStrategy;
+
+/**
+ *
+ * // exchange the arguments with the actual token/secret pair
+ * OAuthConsumer consumer = new DefaultOAuthConsumer("1234", "5678");
+ *
+ * URL url = new URL("http://example.com/protected.xml");
+ * HttpURLConnection request = (HttpURLConnection) url.openConnection();
+ *
+ * consumer.sign(request);
+ *
+ * request.connect();
+ *
+ *
+ *
+ * OAuthProvider provider = new DefaultOAuthProvider("http://twitter.com/oauth/request_token",
+ * "http://twitter.com/oauth/access_token", "http://twitter.com/oauth/authorize");
+ *
+ *
+ * String url = provider.retrieveRequestToken(consumer, "http://www.example.com/callback");
+ *
+ *
+ *
+ * provider.retrieveAccessToken(consumer, nullOrVerifierCode);
+ *
+ *
+ *
+ * where nullOrVerifierCode is either null if your provided a callback URL in + * the previous step, or the pin code issued by the service provider to the user + * if the request was out-of-band (cf. {@link OAuth#OUT_OF_BAND}. + *
+ *+ * The consumer used during token handshakes is now ready for signing. + *
+ * + * @see DefaultOAuthProvider + * @see DefaultOAuthConsumer + * @see OAuthProviderListener + */ +public interface OAuthProvider extends Serializable { + + /** + * Queries the service provider for a request token. + *+ * Pre-conditions: the given {@link OAuthConsumer} must have a valid + * consumer key and consumer secret already set. + *
+ *+ * Post-conditions: the given {@link OAuthConsumer} will have an + * unauthorized request token and token secret set. + *
+ * + * @param consumer + * the {@link OAuthConsumer} that should be used to sign the request + * @param callbackUrl + * Pass an actual URL if your app can receive callbacks and you want + * to get informed about the result of the authorization process. + * Pass {@link OAuth.OUT_OF_BAND} if the service provider implements + * OAuth 1.0a and your app cannot receive callbacks. Pass null if the + * service provider implements OAuth 1.0 and your app cannot receive + * callbacks. Please note that some services (among them Twitter) + * will fail authorization if you pass a callback URL but register + * your application as a desktop app (which would only be able to + * handle OOB requests). + * @return The URL to which the user must be sent in order to authorize the + * consumer. It includes the unauthorized request token (and in the + * case of OAuth 1.0, the callback URL -- 1.0a clients send along + * with the token request). + * @throws OAuthMessageSignerException + * if signing the request failed + * @throws OAuthNotAuthorizedException + * if the service provider rejected the consumer + * @throws OAuthExpectationFailedException + * if required parameters were not correctly set by the consumer or + * service provider + * @throws OAuthCommunicationException + * if server communication failed + */ + public String retrieveRequestToken(OAuthConsumer consumer, String callbackUrl) + throws OAuthMessageSignerException, OAuthNotAuthorizedException, + OAuthExpectationFailedException, OAuthCommunicationException; + + /** + * Queries the service provider for an access token. + *+ * Pre-conditions: the given {@link OAuthConsumer} must have a valid + * consumer key, consumer secret, authorized request token and token secret + * already set. + *
+ *+ * Post-conditions: the given {@link OAuthConsumer} will have an + * access token and token secret set. + *
+ * + * @param consumer + * the {@link OAuthConsumer} that should be used to sign the request + * @param oauthVerifier + * NOTE: Only applies to service providers implementing OAuth + * 1.0a. Set to null if the service provider is still using OAuth + * 1.0. The verification code issued by the service provider + * after the the user has granted the consumer authorization. If the + * callback method provided in the previous step was + * {@link OAuth.OUT_OF_BAND}, then you must ask the user for this + * value. If your app has received a callback, the verfication code + * was passed as part of that request instead. + * @throws OAuthMessageSignerException + * if signing the request failed + * @throws OAuthNotAuthorizedException + * if the service provider rejected the consumer + * @throws OAuthExpectationFailedException + * if required parameters were not correctly set by the consumer or + * service provider + * @throws OAuthCommunicationException + * if server communication failed + */ + public void retrieveAccessToken(OAuthConsumer consumer, String oauthVerifier) + throws OAuthMessageSignerException, OAuthNotAuthorizedException, + OAuthExpectationFailedException, OAuthCommunicationException; + + /** + * Any additional non-OAuth parameters returned in the response body of a + * token request can be obtained through this method. These parameters will + * be preserved until the next token request is issued. The return value is + * never null. + */ + public HttpParameters getResponseParameters(); + + /** + * Subclasses must use this setter to preserve any non-OAuth query + * parameters contained in the server response. It's the caller's + * responsibility that any OAuth parameters be removed beforehand. + * + * @param parameters + * the map of query parameters served by the service provider in the + * token response + */ + public void setResponseParameters(HttpParameters parameters); + + /** + * Use this method to set custom HTTP headers to be used for the requests + * which are sent to retrieve tokens. @deprecated THIS METHOD HAS BEEN + * DEPRECATED. Use {@link OAuthProviderListener} to customize requests. + * + * @param header + * The header name (e.g. 'WWW-Authenticate') + * @param value + * The header value (e.g. 'realm=www.example.com') + */ + @Deprecated + public void setRequestHeader(String header, String value); + + /** + * @deprecated THIS METHOD HAS BEEN DEPRECATED. Use + * {@link OAuthProviderListener} to customize requests. + * @return all request headers set via {@link #setRequestHeader} + */ + @Deprecated + public Map+ * Defines how an OAuth signature string is written to a request. + *
+ *+ * Unlike {@link OAuthMessageSigner}, which is concerned with how to + * generate a signature, this class is concered with where to write it + * (e.g. HTTP header or query string). + *
+ * + * @author Matthias Kaeppler + */ +public interface SigningStrategy extends Serializable { + + /** + * Writes an OAuth signature and all remaining required parameters to an + * HTTP message. + * + * @param signature + * the signature to write + * @param request + * the request to sign + * @param requestParameters + * the request parameters + * @return whatever has been written to the request, e.g. an Authorization + * header field + */ + String writeSignature(String signature, HttpRequest request, HttpParameters requestParameters); + +}