488 lines
17 KiB
C#
488 lines
17 KiB
C#
using System;
|
|
/*
|
|
* Copyright 2003-2008 by Paulo Soares.
|
|
*
|
|
* This code was originally released in 2001 by SUN (see class
|
|
* com.sun.media.imageio.plugins.tiff.TIFFField.java)
|
|
* using the BSD license in a specific wording. In a mail dating from
|
|
* January 23, 2008, Brian Burkhalter (@sun.com) gave us permission
|
|
* to use the code under the following version of the BSD license:
|
|
*
|
|
* Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* - Redistribution of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* - Redistribution in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* Neither the name of Sun Microsystems, Inc. or the names of
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* This software is provided "AS IS," without a warranty of any
|
|
* kind. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
|
|
* WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY
|
|
* EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL
|
|
* NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF
|
|
* USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
|
|
* DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR
|
|
* ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL,
|
|
* CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND
|
|
* REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF OR
|
|
* INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
*
|
|
* You acknowledge that this software is not designed or intended for
|
|
* use in the design, construction, operation or maintenance of any
|
|
* nuclear facility.
|
|
*/
|
|
|
|
namespace iTextSharp.text.pdf.codec {
|
|
/**
|
|
* A class representing a field in a TIFF 6.0 Image File Directory.
|
|
*
|
|
* <p> The TIFF file format is described in more detail in the
|
|
* comments for the TIFFDescriptor class.
|
|
*
|
|
* <p> A field in a TIFF Image File Directory (IFD). A field is defined
|
|
* as a sequence of values of identical data type. TIFF 6.0 defines
|
|
* 12 data types, which are mapped internally onto the Java datatypes
|
|
* byte, int, long, float, and double.
|
|
*
|
|
* <p><b> This class is not a committed part of the JAI API. It may
|
|
* be removed or changed in future releases of JAI.</b>
|
|
*
|
|
* @see TIFFDirectory
|
|
*/
|
|
public class TIFFField : IComparable {
|
|
|
|
/** Flag for 8 bit unsigned integers. */
|
|
public const int TIFF_BYTE = 1;
|
|
|
|
/** Flag for null-terminated ASCII strings. */
|
|
public const int TIFF_ASCII = 2;
|
|
|
|
/** Flag for 16 bit unsigned integers. */
|
|
public const int TIFF_SHORT = 3;
|
|
|
|
/** Flag for 32 bit unsigned integers. */
|
|
public const int TIFF_LONG = 4;
|
|
|
|
/** Flag for pairs of 32 bit unsigned integers. */
|
|
public const int TIFF_RATIONAL = 5;
|
|
|
|
/** Flag for 8 bit signed integers. */
|
|
public const int TIFF_SBYTE = 6;
|
|
|
|
/** Flag for 8 bit uninterpreted bytes. */
|
|
public const int TIFF_UNDEFINED = 7;
|
|
|
|
/** Flag for 16 bit signed integers. */
|
|
public const int TIFF_SSHORT = 8;
|
|
|
|
/** Flag for 32 bit signed integers. */
|
|
public const int TIFF_SLONG = 9;
|
|
|
|
/** Flag for pairs of 32 bit signed integers. */
|
|
public const int TIFF_SRATIONAL = 10;
|
|
|
|
/** Flag for 32 bit IEEE floats. */
|
|
public const int TIFF_FLOAT = 11;
|
|
|
|
/** Flag for 64 bit IEEE doubles. */
|
|
public const int TIFF_DOUBLE = 12;
|
|
|
|
/** The tag number. */
|
|
int tag;
|
|
|
|
/** The tag type. */
|
|
int type;
|
|
|
|
/** The number of data items present in the field. */
|
|
int count;
|
|
|
|
/** The field data. */
|
|
Object data;
|
|
|
|
/** The default constructor. */
|
|
internal TIFFField() {}
|
|
|
|
/**
|
|
* Constructs a TIFFField with arbitrary data. The data
|
|
* parameter must be an array of a Java type appropriate for the
|
|
* type of the TIFF field. Since there is no available 32-bit
|
|
* unsigned datatype, long is used. The mapping between types is
|
|
* as follows:
|
|
*
|
|
* <table border=1>
|
|
* <tr>
|
|
* <th> TIFF type </th> <th> Java type </th>
|
|
* <tr>
|
|
* <td><tt>TIFF_BYTE</tt></td> <td><tt>byte</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_ASCII</tt></td> <td><tt>String</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_SHORT</tt></td> <td><tt>char</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_LONG</tt></td> <td><tt>long</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_RATIONAL</tt></td> <td><tt>long[2]</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_SBYTE</tt></td> <td><tt>byte</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_UNDEFINED</tt></td> <td><tt>byte</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_SSHORT</tt></td> <td><tt>short</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_SLONG</tt></td> <td><tt>int</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_SRATIONAL</tt></td> <td><tt>int[2]</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_FLOAT</tt></td> <td><tt>float</tt></td>
|
|
* <tr>
|
|
* <td><tt>TIFF_DOUBLE</tt></td> <td><tt>double</tt></td>
|
|
* </table>
|
|
*/
|
|
public TIFFField(int tag, int type, int count, Object data) {
|
|
this.tag = tag;
|
|
this.type = type;
|
|
this.count = count;
|
|
this.data = data;
|
|
}
|
|
|
|
/**
|
|
* Returns the tag number, between 0 and 65535.
|
|
*/
|
|
public int GetTag() {
|
|
return tag;
|
|
}
|
|
|
|
/**
|
|
* Returns the type of the data stored in the IFD.
|
|
* For a TIFF6.0 file, the value will equal one of the
|
|
* TIFF_ constants defined in this class. For future
|
|
* revisions of TIFF, higher values are possible.
|
|
*
|
|
*/
|
|
public new int GetType() {
|
|
return type;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of elements in the IFD.
|
|
*/
|
|
public int GetCount() {
|
|
return count;
|
|
}
|
|
|
|
/**
|
|
* Returns the data as an uninterpreted array of bytes.
|
|
* The type of the field must be one of TIFF_BYTE, TIFF_SBYTE,
|
|
* or TIFF_UNDEFINED;
|
|
*
|
|
* <p> For data in TIFF_BYTE format, the application must take
|
|
* care when promoting the data to longer integral types
|
|
* to avoid sign extension.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_BYTE, TIFF_SBYTE, or TIFF_UNDEFINED.
|
|
*/
|
|
public byte[] GetAsBytes() {
|
|
return (byte[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_SHORT data as an array of chars (unsigned 16-bit
|
|
* integers).
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_SHORT.
|
|
*/
|
|
public char[] GetAsChars() {
|
|
return (char[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_SSHORT data as an array of shorts (signed 16-bit
|
|
* integers).
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_SSHORT.
|
|
*/
|
|
public short[] GetAsShorts() {
|
|
return (short[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_SLONG data as an array of ints (signed 32-bit
|
|
* integers).
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_SLONG.
|
|
*/
|
|
public int[] GetAsInts() {
|
|
return (int[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_LONG data as an array of longs (signed 64-bit
|
|
* integers).
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_LONG.
|
|
*/
|
|
public long[] GetAsLongs() {
|
|
return (long[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_FLOAT data as an array of floats.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_FLOAT.
|
|
*/
|
|
public float[] GetAsFloats() {
|
|
return (float[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_DOUBLE data as an array of doubles.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_DOUBLE.
|
|
*/
|
|
public double[] GetAsDoubles() {
|
|
return (double[])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_SRATIONAL data as an array of 2-element arrays of ints.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_SRATIONAL.
|
|
*/
|
|
public int[][] GetAsSRationals() {
|
|
return (int[][])data;
|
|
}
|
|
|
|
/**
|
|
* Returns TIFF_RATIONAL data as an array of 2-element arrays of longs.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_RATTIONAL.
|
|
*/
|
|
public long[][] GetAsRationals() {
|
|
return (long[][])data;
|
|
}
|
|
|
|
/**
|
|
* Returns data in TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
|
|
* TIFF_SSHORT, or TIFF_SLONG format as an int.
|
|
*
|
|
* <p> TIFF_BYTE and TIFF_UNDEFINED data are treated as unsigned;
|
|
* that is, no sign extension will take place and the returned
|
|
* value will be in the range [0, 255]. TIFF_SBYTE data will
|
|
* be returned in the range [-128, 127].
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not of
|
|
* type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
|
|
* TIFF_SSHORT, or TIFF_SLONG.
|
|
*/
|
|
public int GetAsInt(int index) {
|
|
switch (type) {
|
|
case TIFF_BYTE: case TIFF_UNDEFINED:
|
|
return ((byte[])data)[index] & 0xff;
|
|
case TIFF_SBYTE:
|
|
return ((byte[])data)[index];
|
|
case TIFF_SHORT:
|
|
return ((char[])data)[index] & 0xffff;
|
|
case TIFF_SSHORT:
|
|
return ((short[])data)[index];
|
|
case TIFF_SLONG:
|
|
return ((int[])data)[index];
|
|
default:
|
|
throw new InvalidCastException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns data in TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
|
|
* TIFF_SSHORT, TIFF_SLONG, or TIFF_LONG format as a long.
|
|
*
|
|
* <p> TIFF_BYTE and TIFF_UNDEFINED data are treated as unsigned;
|
|
* that is, no sign extension will take place and the returned
|
|
* value will be in the range [0, 255]. TIFF_SBYTE data will
|
|
* be returned in the range [-128, 127].
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not of
|
|
* type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED, TIFF_SHORT,
|
|
* TIFF_SSHORT, TIFF_SLONG, or TIFF_LONG.
|
|
*/
|
|
public long GetAsLong(int index) {
|
|
switch (type) {
|
|
case TIFF_BYTE: case TIFF_UNDEFINED:
|
|
return ((byte[])data)[index] & 0xff;
|
|
case TIFF_SBYTE:
|
|
return ((byte[])data)[index];
|
|
case TIFF_SHORT:
|
|
return ((char[])data)[index] & 0xffff;
|
|
case TIFF_SSHORT:
|
|
return ((short[])data)[index];
|
|
case TIFF_SLONG:
|
|
return ((int[])data)[index];
|
|
case TIFF_LONG:
|
|
return ((long[])data)[index];
|
|
default:
|
|
throw new InvalidCastException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns data in any numerical format as a float. Data in
|
|
* TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated by
|
|
* dividing the numerator into the denominator using
|
|
* double-precision arithmetic and then truncating to single
|
|
* precision. Data in TIFF_SLONG, TIFF_LONG, or TIFF_DOUBLE
|
|
* format may suffer from truncation.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is
|
|
* of type TIFF_UNDEFINED or TIFF_ASCII.
|
|
*/
|
|
public float GetAsFloat(int index) {
|
|
switch (type) {
|
|
case TIFF_BYTE:
|
|
return ((byte[])data)[index] & 0xff;
|
|
case TIFF_SBYTE:
|
|
return ((byte[])data)[index];
|
|
case TIFF_SHORT:
|
|
return ((char[])data)[index] & 0xffff;
|
|
case TIFF_SSHORT:
|
|
return ((short[])data)[index];
|
|
case TIFF_SLONG:
|
|
return ((int[])data)[index];
|
|
case TIFF_LONG:
|
|
return ((long[])data)[index];
|
|
case TIFF_FLOAT:
|
|
return ((float[])data)[index];
|
|
case TIFF_DOUBLE:
|
|
return (float)((double[])data)[index];
|
|
case TIFF_SRATIONAL:
|
|
int[] ivalue = GetAsSRational(index);
|
|
return (float)((double)ivalue[0]/ivalue[1]);
|
|
case TIFF_RATIONAL:
|
|
long[] lvalue = GetAsRational(index);
|
|
return (float)((double)lvalue[0]/lvalue[1]);
|
|
default:
|
|
throw new InvalidCastException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns data in any numerical format as a float. Data in
|
|
* TIFF_SRATIONAL or TIFF_RATIONAL format are evaluated by
|
|
* dividing the numerator into the denominator using
|
|
* double-precision arithmetic.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is of
|
|
* type TIFF_UNDEFINED or TIFF_ASCII.
|
|
*/
|
|
public double GetAsDouble(int index) {
|
|
switch (type) {
|
|
case TIFF_BYTE:
|
|
return ((byte[])data)[index] & 0xff;
|
|
case TIFF_SBYTE:
|
|
return ((byte[])data)[index];
|
|
case TIFF_SHORT:
|
|
return ((char[])data)[index] & 0xffff;
|
|
case TIFF_SSHORT:
|
|
return ((short[])data)[index];
|
|
case TIFF_SLONG:
|
|
return ((int[])data)[index];
|
|
case TIFF_LONG:
|
|
return ((long[])data)[index];
|
|
case TIFF_FLOAT:
|
|
return ((float[])data)[index];
|
|
case TIFF_DOUBLE:
|
|
return ((double[])data)[index];
|
|
case TIFF_SRATIONAL:
|
|
int[] ivalue = GetAsSRational(index);
|
|
return (double)ivalue[0]/ivalue[1];
|
|
case TIFF_RATIONAL:
|
|
long[] lvalue = GetAsRational(index);
|
|
return (double)lvalue[0]/lvalue[1];
|
|
default:
|
|
throw new InvalidCastException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a TIFF_ASCII data item as a String.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_ASCII.
|
|
*/
|
|
public String GetAsString(int index) {
|
|
return ((String[])data)[index];
|
|
}
|
|
|
|
/**
|
|
* Returns a TIFF_SRATIONAL data item as a two-element array
|
|
* of ints.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_SRATIONAL.
|
|
*/
|
|
public int[] GetAsSRational(int index) {
|
|
return ((int[][])data)[index];
|
|
}
|
|
|
|
/**
|
|
* Returns a TIFF_RATIONAL data item as a two-element array
|
|
* of ints.
|
|
*
|
|
* <p> A ClassCastException will be thrown if the field is not
|
|
* of type TIFF_RATIONAL.
|
|
*/
|
|
public long[] GetAsRational(int index) {
|
|
if (type == TIFF_LONG)
|
|
return GetAsLongs();
|
|
return ((long[][])data)[index];
|
|
}
|
|
|
|
/**
|
|
* Compares this <code>TIFFField</code> with another
|
|
* <code>TIFFField</code> by comparing the tags.
|
|
*
|
|
* <p><b>Note: this class has a natural ordering that is inconsistent
|
|
* with <code>equals()</code>.</b>
|
|
*
|
|
* @throws IllegalArgumentException if the parameter is <code>null</code>.
|
|
* @throws ClassCastException if the parameter is not a
|
|
* <code>TIFFField</code>.
|
|
*/
|
|
public int CompareTo(Object o) {
|
|
if (o == null) {
|
|
throw new ArgumentException();
|
|
}
|
|
|
|
int oTag = ((TIFFField)o).GetTag();
|
|
|
|
if (tag < oTag) {
|
|
return -1;
|
|
} else if (tag > oTag) {
|
|
return 1;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|