1 /*

     2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package javax.imageio.plugins.tiff;

    26 

    27 import java.util.StringTokenizer;

    28 import org.w3c.dom.NamedNodeMap;

    29 import org.w3c.dom.Node;

    30 import com.sun.imageio.plugins.tiff.TIFFFieldNode;

    31 import com.sun.imageio.plugins.tiff.TIFFIFD;

    32 

    33 /**

    34  * A class representing a field in a TIFF 6.0 Image File Directory.

    35  *

    36  * <p> A field in a TIFF Image File Directory (IFD) is defined as a

    37  * tag number accompanied by a sequence of values of identical data type.

    38  * TIFF 6.0 defines 12 data types; a 13th type <code>IFD</code> is

    39  * defined in TIFF Tech Note 1 of TIFF Specification Supplement 1. These

    40  * TIFF data types are referred to by Java constants and mapped internally

    41  * onto Java language data types and type names as follows:

    42  *

    43  * <br>

    44  * <br>

    45  * <table border="1">

    46  * <caption>TIFF Data Type to Java Data Type Mapping</caption>

    47  *

    48  * <tr>

    49  * <th>

    50  * <b>TIFF Data Type</b>

    51  * </th>

    52  * <th>

    53  * <b>Java Constant</b>

    54  * </th>

    55  * <th>

    56  * <b>Java Data Type</b>

    57  * </th>

    58  * <th>

    59  * <b>Java Type Name</b>

    60  * </th>

    61  * </tr>

    62  *

    63  * <tr>

    64  * <td>

    65  * <tt>BYTE</tt>

    66  * </td>

    67  * <td>

    68  * {@link TIFFTag#TIFF_BYTE}

    69  * </td>

    70  * <td>

    71  * <code>byte</code>

    72  * </td>

    73  * <td>

    74  * <code>"Byte"</code>

    75  * </td>

    76  * </tr>

    77  *

    78  * <tr>

    79  * <td>

    80  * <tt>ASCII</tt>

    81  * </td>

    82  * <td>

    83  * {@link TIFFTag#TIFF_ASCII}

    84  * </td>

    85  * <td>

    86  * <code>String</code>

    87  * </td>

    88  * <td>

    89  * <code>"Ascii"</code>

    90  * </td>

    91  * </tr>

    92  *

    93  * <tr>

    94  * <td>

    95  * <tt>SHORT</tt>

    96  * </td>

    97  * <td>

    98  * {@link TIFFTag#TIFF_SHORT}

    99  * </td>

   100  * <td>

   101  * <code>char</code>

   102  * </td>

   103  * <td>

   104  * <code>"Short"</code>

   105  * </td>

   106  * </tr>

   107  *

   108  * <tr>

   109  * <td>

   110  * <tt>LONG</tt>

   111  * </td>

   112  * <td>

   113  * {@link TIFFTag#TIFF_LONG}

   114  * </td>

   115  * <td>

   116  * <code>long</code>

   117  * </td>

   118  * <td>

   119  * <code>"Long"</code>

   120  * </td>

   121  * </tr>

   122  *

   123  * <tr>

   124  * <td>

   125  * <tt>RATIONAL</tt>

   126  * </td>

   127  * <td>

   128  * {@link TIFFTag#TIFF_RATIONAL}

   129  * </td>

   130  * <td>

   131  * <code>long[2]</code> {numerator, denominator}

   132  * </td>

   133  * <td>

   134  * <code>"Rational"</code>

   135  * </td>

   136  * </tr>

   137  *

   138  * <tr>

   139  * <td>

   140  * <tt>SBYTE</tt>

   141  * </td>

   142  * <td>

   143  * {@link TIFFTag#TIFF_SBYTE}

   144  * </td>

   145  * <td>

   146  * <code>byte</code>

   147  * </td>

   148  * <td>

   149  * <code>"SByte"</code>

   150  * </td>

   151  * </tr>

   152  *

   153  * <tr>

   154  * <td>

   155  * <tt>UNDEFINED</tt>

   156  * </td>

   157  * <td>

   158  * {@link TIFFTag#TIFF_UNDEFINED}

   159  * </td>

   160  * <td>

   161  * <code>byte</code>

   162  * </td>

   163  * <td>

   164  * <code>"Undefined"</code>

   165  * </td>

   166  * </tr>

   167  *

   168  * <tr>

   169  * <td>

   170  * <tt>SSHORT</tt>

   171  * </td>

   172  * <td>

   173  * {@link TIFFTag#TIFF_SSHORT}

   174  * </td>

   175  * <td>

   176  * <code>short</code>

   177  * </td>

   178  * <td>

   179  * <code>"SShort"</code>

   180  * </td>

   181  * </tr>

   182  *

   183  * <tr>

   184  * <td>

   185  * <tt>SLONG</tt>

   186  * </td>

   187  * <td>

   188  * {@link TIFFTag#TIFF_SLONG}

   189  * </td>

   190  * <td>

   191  * <code>int</code>

   192  * </td>

   193  * <td>

   194  * <code>"SLong"</code>

   195  * </td>

   196  * </tr>

   197  *

   198  * <tr>

   199  * <td>

   200  * <tt>SRATIONAL</tt>

   201  * </td>

   202  * <td>

   203  * {@link TIFFTag#TIFF_SRATIONAL}

   204  * </td>

   205  * <td>

   206  * <code>int[2]</code> {numerator, denominator}

   207  * </td>

   208  * <td>

   209  * <code>"SRational"</code>

   210  * </td>

   211  * </tr>

   212  *

   213  * <tr>

   214  * <td>

   215  * <tt>FLOAT</tt>

   216  * </td>

   217  * <td>

   218  * {@link TIFFTag#TIFF_FLOAT}

   219  * </td>

   220  * <td>

   221  * <code>float</code>

   222  * </td>

   223  * <td>

   224  * <code>"Float"</code>

   225  * </td>

   226  * </tr>

   227  *

   228  * <tr>

   229  * <td>

   230  * <tt>DOUBLE</tt>

   231  * </td>

   232  * <td>

   233  * {@link TIFFTag#TIFF_DOUBLE}

   234  * </td>

   235  * <td>

   236  * <code>double</code>

   237  * </td>

   238  * <td>

   239  * <code>"Double"</code>

   240  * </td>

   241  * </tr>

   242  *

   243  * <tr>

   244  * <td>

   245  * <tt>IFD</tt>

   246  * </td>

   247  * <td>

   248  * {@link TIFFTag#TIFF_IFD_POINTER}

   249  * </td>

   250  * <td>

   251  * <code>long</code>

   252  * </td>

   253  * <td>

   254  * <code>"IFDPointer"</code>

   255  * </td>

   256  * </tr>

   257  *

   258  * </table>

   259  *

   260  * @since 1.9

   261  * @see   TIFFDirectory

   262  * @see   TIFFTag

   263  */

   264 public class TIFFField implements Cloneable {

   265 

   266     private static final String[] typeNames = {

   267         null,

   268         "Byte", "Ascii", "Short", "Long", "Rational",

   269         "SByte", "Undefined", "SShort", "SLong", "SRational",

   270         "Float", "Double", "IFDPointer"

   271     };

   272 

   273     private static final boolean[] isIntegral = {

   274         false,

   275         true, false, true, true, false,

   276         true, true, true, true, false,

   277         false, false, false

   278     };

   279 

   280     /** The tag. */

   281     private TIFFTag tag;

   282 

   283     /** The tag number. */

   284     private int tagNumber;

   285 

   286     /** The tag type. */

   287     private int type;

   288 

   289     /** The number of data items present in the field. */

   290     private int count;

   291 

   292     /** The field data. */

   293     private Object data;

   294 

   295     /** The IFD contents if available. This will usually be a TIFFIFD. */

   296     private TIFFDirectory dir;

   297 

   298     /** The default constructor. */

   299     private TIFFField() {}

   300 

   301     private static String getAttribute(Node node, String attrName) {

   302         NamedNodeMap attrs = node.getAttributes();

   303         return attrs.getNamedItem(attrName).getNodeValue();

   304     }

   305 

   306     private static void initData(Node node,

   307                                  int[] otype, int[] ocount, Object[] odata) {

   308         int type;

   309         int count;

   310         Object data = null;

   311 

   312         String typeName = node.getNodeName();

   313         typeName = typeName.substring(4);

   314         typeName = typeName.substring(0, typeName.length() - 1);

   315         type = TIFFField.getTypeByName(typeName);

   316         if (type == -1) {

   317             throw new IllegalArgumentException("typeName = " + typeName);

   318         }

   319 

   320         Node child = node.getFirstChild();

   321 

   322         count = 0;

   323         while (child != null) {

   324             String childTypeName = child.getNodeName().substring(4);

   325             if (!typeName.equals(childTypeName)) {

   326                 // warning

   327             }

   328 

   329             ++count;

   330             child = child.getNextSibling();

   331         }

   332 

   333         if (count > 0) {

   334             data = createArrayForType(type, count);

   335             child = node.getFirstChild();

   336             int idx = 0;

   337             while (child != null) {

   338                 String value = getAttribute(child, "value");

   339 

   340                 String numerator, denominator;

   341                 int slashPos;

   342 

   343                 switch (type) {

   344                 case TIFFTag.TIFF_ASCII:

   345                     ((String[])data)[idx] = value;

   346                     break;

   347                 case TIFFTag.TIFF_BYTE:

   348                 case TIFFTag.TIFF_SBYTE:

   349                     ((byte[])data)[idx] =

   350                         (byte)Integer.parseInt(value);

   351                     break;

   352                 case TIFFTag.TIFF_SHORT:

   353                     ((char[])data)[idx] =

   354                         (char)Integer.parseInt(value);

   355                     break;

   356                 case TIFFTag.TIFF_SSHORT:

   357                     ((short[])data)[idx] =

   358                         (short)Integer.parseInt(value);

   359                     break;

   360                 case TIFFTag.TIFF_SLONG:

   361                     ((int[])data)[idx] =

   362                         Integer.parseInt(value);

   363                     break;

   364                 case TIFFTag.TIFF_LONG:

   365                 case TIFFTag.TIFF_IFD_POINTER:

   366                     ((long[])data)[idx] =

   367                         Long.parseLong(value);

   368                     break;

   369                 case TIFFTag.TIFF_FLOAT:

   370                     ((float[])data)[idx] =

   371                         Float.parseFloat(value);

   372                     break;

   373                 case TIFFTag.TIFF_DOUBLE:

   374                     ((double[])data)[idx] =

   375                         Double.parseDouble(value);

   376                     break;

   377                 case TIFFTag.TIFF_SRATIONAL:

   378                     slashPos = value.indexOf("/");

   379                     numerator = value.substring(0, slashPos);

   380                     denominator = value.substring(slashPos + 1);

   381 

   382                     ((int[][])data)[idx] = new int[2];

   383                     ((int[][])data)[idx][0] =

   384                         Integer.parseInt(numerator);

   385                     ((int[][])data)[idx][1] =

   386                         Integer.parseInt(denominator);

   387                     break;

   388                 case TIFFTag.TIFF_RATIONAL:

   389                     slashPos = value.indexOf("/");

   390                     numerator = value.substring(0, slashPos);

   391                     denominator = value.substring(slashPos + 1);

   392 

   393                     ((long[][])data)[idx] = new long[2];

   394                     ((long[][])data)[idx][0] =

   395                         Long.parseLong(numerator);

   396                     ((long[][])data)[idx][1] =

   397                         Long.parseLong(denominator);

   398                     break;

   399                 default:

   400                     // error

   401                 }

   402 

   403                 idx++;

   404                 child = child.getNextSibling();

   405             }

   406         }

   407 

   408         otype[0] = type;

   409         ocount[0] = count;

   410         odata[0] = data;

   411     }

   412 

   413     /**

   414      * Creates a <code>TIFFField</code> from a TIFF native image

   415      * metadata node. If the value of the <tt>"tagNumber"</tt> attribute

   416      * of the node is not found in <code>tagSet</code> then a new

   417      * <code>TIFFTag</code> with name <code>TIFFTag.UNKNOWN_TAG_NAME</code>

   418      * will be created and assigned to the field.

   419      *

   420      * @param tagSet The <code>TIFFTagSet</code> to which the

   421      * <code>TIFFTag</code> of the field belongs.

   422      * @param node A native TIFF image metadata <code>TIFFField</code> node.

   423      * @throws NullPointerException if <code>node</code> is

   424      * <code>null</code>.

   425      * @throws IllegalArgumentException if the name of the node is not

   426      * <code>"TIFFField"</code>.

   427      * @return A new {@code TIFFField}.

   428      */

   429     public static TIFFField createFromMetadataNode(TIFFTagSet tagSet,

   430                                                    Node node) {

   431         if (node == null) {

   432             throw new NullPointerException("node == null!");

   433         }

   434         String name = node.getNodeName();

   435         if (!name.equals("TIFFField")) {

   436             throw new IllegalArgumentException("!name.equals(\"TIFFField\")");

   437         }

   438 

   439         int tagNumber = Integer.parseInt(getAttribute(node, "number"));

   440         TIFFTag tag = null;

   441         if (tagSet != null) {

   442             tag = tagSet.getTag(tagNumber);

   443         }

   444 

   445         int type = TIFFTag.TIFF_UNDEFINED;

   446         int count = 0;

   447         Object data = null;

   448 

   449         Node child = node.getFirstChild();

   450         if (child != null) {

   451             String typeName = child.getNodeName();

   452             if (typeName.equals("TIFFUndefined")) {

   453                 String values = getAttribute(child, "value");

   454                 StringTokenizer st = new StringTokenizer(values, ",");

   455                 count = st.countTokens();

   456 

   457                 byte[] bdata = new byte[count];

   458                 for (int i = 0; i < count; i++) {

   459                     bdata[i] = (byte)Integer.parseInt(st.nextToken());

   460                 }

   461 

   462                 type = TIFFTag.TIFF_UNDEFINED;

   463                 data = bdata;

   464             } else {

   465                 int[] otype = new int[1];

   466                 int[] ocount = new int[1];

   467                 Object[] odata = new Object[1];

   468 

   469                 initData(node.getFirstChild(), otype, ocount, odata);

   470                 type = otype[0];

   471                 count = ocount[0];

   472                 data = odata[0];

   473             }

   474         } else if (tag != null) {

   475             int t = TIFFTag.MAX_DATATYPE;

   476             while(t >= TIFFTag.MIN_DATATYPE && !tag.isDataTypeOK(t)) {

   477                 t--;

   478             }

   479             type = t;

   480         }

   481 

   482         if (tag == null) {

   483             tag = new TIFFTag(TIFFTag.UNKNOWN_TAG_NAME, tagNumber, 1 << type);

   484         }

   485 

   486         return new TIFFField(tag, type, count, data);

   487     }

   488 

   489     /**

   490      * Constructs a <code>TIFFField</code> with arbitrary data. The

   491      * <code>type</code> parameter must be a value for which

   492      * {@link TIFFTag#isDataTypeOK tag.isDataTypeOK()}

   493      * returns <code>true</code>. The <code>data</code> parameter must

   494      * be an array of a Java type appropriate for the type of the TIFF

   495      * field.

   496      *

   497      * <p>Note that the value (data) of the <code>TIFFField</code>

   498      * will always be the actual field value regardless of the number of

   499      * bytes required for that value. This is the case despite the fact

   500      * that the TIFF <i>IFD Entry</i> corresponding to the field may

   501      * actually contain the offset to the value of the field rather than

   502      * the value itself (the latter occurring if and only if the

   503      * value fits into 4 bytes). In other words, the value of the

   504      * field will already have been read from the TIFF stream. (An exception

   505      * to this case may occur when the field represents the contents of a

   506      * non-baseline IFD. In that case the data will be a <code>long[]</code>

   507      * containing the offset to the IFD and the <code>TIFFDirectory</code>

   508      * returned by {@link #getDirectory()} will be its contents.)

   509      *

   510      * @param tag The tag to associated with this field.

   511      * @param type One of the <code>TIFFTag.TIFF_*</code> constants

   512      * indicating the data type of the field as written to the TIFF stream.

   513      * @param count The number of data values.

   514      * @param data The actual data content of the field.

   515      *

   516      * @throws NullPointerException if <code>tag&nbsp;==&nbsp;null</code>.

   517      * @throws IllegalArgumentException if <code>type</code> is not

   518      * one of the <code>TIFFTag.TIFF_*</code> data type constants.

   519      * @throws IllegalArgumentException if <code>type</code> is an unacceptable

   520      * data type for the supplied <code>TIFFTag</code>.

   521      * @throws IllegalArgumentException if <code>count&nbsp;&lt;&nbsp;0</code>.

   522      * @throws NullPointerException if <code>data&nbsp;==&nbsp;null</code>.

   523      * @throws IllegalArgumentException if <code>data</code> is an instance of

   524      * a class incompatible with the specified type.

   525      * @throws IllegalArgumentException if the size of the data array is wrong.

   526      */

   527     public TIFFField(TIFFTag tag, int type, int count, Object data) {

   528         if(tag == null) {

   529             throw new NullPointerException("tag == null!");

   530         } else if(type < TIFFTag.MIN_DATATYPE || type > TIFFTag.MAX_DATATYPE) {

   531             throw new IllegalArgumentException("Unknown data type "+type);

   532         } else if(!tag.isDataTypeOK(type)) {

   533             throw new IllegalArgumentException("Illegal data type " + type

   534                 + " for " + tag.getName() + " tag");

   535         } else if(count < 0) {

   536             throw new IllegalArgumentException("count < 0!");

   537         } else if(data == null) {

   538             throw new NullPointerException("data == null!");

   539         }

   540 

   541         boolean isDataArrayCorrect = false;

   542 

   543         switch (type) {

   544         case TIFFTag.TIFF_BYTE:

   545         case TIFFTag.TIFF_SBYTE:

   546         case TIFFTag.TIFF_UNDEFINED:

   547             isDataArrayCorrect = data instanceof byte[]

   548                 && ((byte[])data).length == count;

   549             break;

   550         case TIFFTag.TIFF_ASCII:

   551             isDataArrayCorrect = data instanceof String[]

   552                 && ((String[])data).length == count;

   553             break;

   554         case TIFFTag.TIFF_SHORT:

   555             isDataArrayCorrect = data instanceof char[]

   556                 && ((char[])data).length == count;

   557             break;

   558         case TIFFTag.TIFF_LONG:

   559             isDataArrayCorrect = data instanceof long[]

   560                 && ((long[])data).length == count;

   561             break;

   562         case TIFFTag.TIFF_IFD_POINTER:

   563             isDataArrayCorrect = data instanceof long[]

   564                 && ((long[])data).length == 1;

   565             break;

   566         case TIFFTag.TIFF_RATIONAL:

   567             isDataArrayCorrect = data instanceof long[][]

   568                 && ((long[][])data).length == count

   569                 && ((long[][])data)[0].length == 2;

   570             break;

   571         case TIFFTag.TIFF_SSHORT:

   572             isDataArrayCorrect = data instanceof short[]

   573                 && ((short[])data).length == count;

   574             break;

   575         case TIFFTag.TIFF_SLONG:

   576             isDataArrayCorrect = data instanceof int[]

   577                 && ((int[])data).length == count;

   578             break;

   579         case TIFFTag.TIFF_SRATIONAL:

   580             isDataArrayCorrect = data instanceof int[][]

   581                 && ((int[][])data).length == count

   582                 && ((int[][])data)[0].length == 2;

   583             break;

   584         case TIFFTag.TIFF_FLOAT:

   585             isDataArrayCorrect = data instanceof float[]

   586                 && ((float[])data).length == count;

   587             break;

   588         case TIFFTag.TIFF_DOUBLE:

   589             isDataArrayCorrect = data instanceof double[]

   590                 && ((double[])data).length == count;

   591             break;

   592         default:

   593             throw new IllegalArgumentException("Unknown data type "+type);

   594         }

   595 

   596         if (!isDataArrayCorrect) {

   597             throw new IllegalArgumentException

   598                 ("Illegal class or length for data array");

   599         }

   600 

   601         this.tag = tag;

   602         this.tagNumber = tag.getNumber();

   603         this.type = type;

   604         this.count = count;

   605         this.data = data;

   606     }

   607 

   608     /**

   609      * Constructs a data array using {@link #createArrayForType

   610      * createArrayForType()} and invokes

   611      * {@link #TIFFField(TIFFTag,int,int,Object)} with the supplied

   612      * parameters and the created array.

   613      *

   614      * @param tag The tag to associated with this field.

   615      * @param type One of the <code>TIFFTag.TIFF_*</code> constants

   616      * indicating the data type of the field as written to the TIFF stream.

   617      * @param count The number of data values.

   618      * @throws NullPointerException if <code>tag&nbsp;==&nbsp;null</code>.

   619      * @throws IllegalArgumentException if <code>type</code> is not

   620      * one of the <code>TIFFTag.TIFF_*</code> data type constants.

   621      * @throws IllegalArgumentException if <code>type</code> is an unacceptable

   622      * data type for the supplied <code>TIFFTag</code>.

   623      * @throws IllegalArgumentException if <code>count&nbsp;&lt;&nbsp;0</code>.

   624      * @see #TIFFField(TIFFTag,int,int,Object)

   625      */

   626     public TIFFField(TIFFTag tag, int type, int count) {

   627         this(tag, type, count, createArrayForType(type, count));

   628     }

   629 

   630     /**

   631      * Constructs a <code>TIFFField</code> with a single non-negative integral

   632      * value.

   633      * The field will have type

   634      * {@link TIFFTag#TIFF_SHORT  TIFF_SHORT} if

   635      * <code>val&nbsp;&lt;&nbsp;65536</code> and type

   636      * {@link TIFFTag#TIFF_LONG TIFF_LONG} otherwise.  The count

   637      * of the field will be unity.

   638      *

   639      * @param tag The tag to associate with this field.

   640      * @param value The value to associate with this field.

   641      * @throws NullPointerException if <code>tag&nbsp;==&nbsp;null</code>.

   642      * @throws IllegalArgumentException if the derived type is unacceptable

   643      * for the supplied <code>TIFFTag</code>.

   644      * @throws IllegalArgumentException if <code>value&nbsp;&lt;&nbsp;0</code>.

   645      */

   646     public TIFFField(TIFFTag tag, int value) {

   647         if(tag == null) {

   648             throw new NullPointerException("tag == null!");

   649         }

   650         if (value < 0) {

   651             throw new IllegalArgumentException("value < 0!");

   652         }

   653 

   654         this.tag = tag;

   655         this.tagNumber = tag.getNumber();

   656         this.count = 1;

   657 

   658         if (value < 65536) {

   659             if (!tag.isDataTypeOK(TIFFTag.TIFF_SHORT)) {

   660                 throw new IllegalArgumentException("Illegal data type "

   661                     + TIFFTag.TIFF_SHORT + " for " + tag.getName() + " tag");

   662             }

   663             this.type = TIFFTag.TIFF_SHORT;

   664             char[] cdata = new char[1];

   665             cdata[0] = (char)value;

   666             this.data = cdata;

   667         } else {

   668             if (!tag.isDataTypeOK(TIFFTag.TIFF_LONG)) {

   669                 throw new IllegalArgumentException("Illegal data type "

   670                     + TIFFTag.TIFF_LONG + " for " + tag.getName() + " tag");

   671             }

   672             this.type = TIFFTag.TIFF_LONG;

   673             long[] ldata = new long[1];

   674             ldata[0] = value;

   675             this.data = ldata;

   676         }

   677     }

   678 

   679     /**

   680      * Constructs a <code>TIFFField</code> with an IFD offset and contents.

   681      * The offset will be stored as the data of this field as

   682      * <code>long[] {offset}</code>. The directory will not be cloned. The count

   683      * of the field will be unity.

   684      *

   685      * @param tag The tag to associated with this field.

   686      * @param type One of the constants <code>TIFFTag.TIFF_LONG</code> or

   687      * <code>TIFFTag.TIFF_IFD_POINTER</code>.

   688      * @param offset The IFD offset.

   689      * @param dir The directory.

   690      *

   691      * @throws NullPointerException if <code>tag&nbsp;==&nbsp;null</code>.

   692      * @throws IllegalArgumentException if <code>type</code> is neither

   693      * <code>TIFFTag.TIFF_LONG</code> nor <code>TIFFTag.TIFF_IFD_POINTER</code>.

   694      * @throws IllegalArgumentException if <code>type</code> is an unacceptable

   695      * data type for the supplied <code>TIFFTag</code>.

   696      * @throws IllegalArgumentException if <code>offset</code> is non-positive.

   697      * @throws NullPointerException if <code>dir&nbsp;==&nbsp;null</code>.

   698      *

   699      * @see #TIFFField(TIFFTag,int,int,Object)

   700      */

   701     public TIFFField(TIFFTag tag, int type, long offset, TIFFDirectory dir) {

   702         this(tag, type, 1, new long[] {offset});

   703         if (type != TIFFTag.TIFF_LONG && type != TIFFTag.TIFF_IFD_POINTER) {

   704             throw new IllegalArgumentException("type " + type

   705                 + " is neither TIFFTag.TIFF_LONG nor TIFFTag.TIFF_IFD_POINTER");

   706         } else if (offset <= 0) {

   707             throw new IllegalArgumentException("offset " + offset

   708                 + " is non-positive");

   709         } else if (dir == null) {

   710             throw new NullPointerException("dir == null");

   711         }

   712         this.dir = dir;

   713     }

   714 

   715     /**

   716      * Retrieves the tag associated with this field.

   717      *

   718      * @return The associated <code>TIFFTag</code>.

   719      */

   720     public TIFFTag getTag() {

   721         return tag;

   722     }

   723 

   724     /**

   725      * Retrieves the tag number in the range <code>[0,&nbsp;65535]</code>.

   726      *

   727      * @return The tag number.

   728      */

   729     public int getTagNumber() {

   730         return tagNumber;

   731     }

   732 

   733     /**

   734      * Returns the type of the data stored in the field.  For a TIFF 6.0

   735      * stream, the value will equal one of the <code>TIFFTag.TIFF_*</code>

   736      * constants. For future revisions of TIFF, higher values are possible.

   737      *

   738      * @return The data type of the field value.

   739      */

   740     public int getType() {

   741         return type;

   742     }

   743 

   744     /**

   745      * Returns the name of the supplied data type constant.

   746      *

   747      * @param dataType One of the <code>TIFFTag.TIFF_*</code> constants

   748      * indicating the data type of the field as written to the TIFF stream.

   749      * @return The type name corresponding to the supplied type constant.

   750      * @throws IllegalArgumentException if <code>dataType</code> is not

   751      * one of the <code>TIFFTag.TIFF_*</code> data type constants.

   752      */

   753     public static String getTypeName(int dataType) {

   754         if (dataType < TIFFTag.MIN_DATATYPE ||

   755             dataType > TIFFTag.MAX_DATATYPE) {

   756             throw new IllegalArgumentException("Unknown data type "+dataType);

   757         }

   758 

   759         return typeNames[dataType];

   760     }

   761 

   762     /**

   763      * Returns the data type constant corresponding to the supplied data

   764      * type name. If the name is unknown <code>-1</code> will be returned.

   765      *

   766      * @param typeName The type name.

   767      * @return One of the <code>TIFFTag.TIFF_*</code> constants or

   768      * <code>-1</code> if the name is not recognized.

   769      */

   770     public static int getTypeByName(String typeName) {

   771         for (int i = TIFFTag.MIN_DATATYPE; i <= TIFFTag.MAX_DATATYPE; i++) {

   772             if (typeName.equals(typeNames[i])) {

   773                 return i;

   774             }

   775         }

   776 

   777         return -1;

   778     }

   779 

   780     /**

   781      * Creates an array appropriate for the indicated data type.

   782      *

   783      * @param dataType One of the <code>TIFFTag.TIFF_*</code> data type

   784      * constants.

   785      * @param count The number of values in the array.

   786      * @return An array appropriate for the specified data type.

   787      *

   788      * @throws IllegalArgumentException if <code>dataType</code> is not

   789      * one of the <code>TIFFTag.TIFF_*</code> data type constants.

   790      * @throws IllegalArgumentException if <code>count&nbsp;&lt;&nbsp;0</code>.

   791      */

   792     public static Object createArrayForType(int dataType, int count) {

   793         if(count < 0) {

   794             throw new IllegalArgumentException("count < 0!");

   795         }

   796         switch (dataType) {

   797         case TIFFTag.TIFF_BYTE:

   798         case TIFFTag.TIFF_SBYTE:

   799         case TIFFTag.TIFF_UNDEFINED:

   800             return new byte[count];

   801         case TIFFTag.TIFF_ASCII:

   802             return new String[count];

   803         case TIFFTag.TIFF_SHORT:

   804             return new char[count];

   805         case TIFFTag.TIFF_LONG:

   806         case TIFFTag.TIFF_IFD_POINTER:

   807             return new long[count];

   808         case TIFFTag.TIFF_RATIONAL:

   809             return new long[count][2];

   810         case TIFFTag.TIFF_SSHORT:

   811             return new short[count];

   812         case TIFFTag.TIFF_SLONG:

   813             return new int[count];

   814         case TIFFTag.TIFF_SRATIONAL:

   815             return new int[count][2];

   816         case TIFFTag.TIFF_FLOAT:

   817             return new float[count];

   818         case TIFFTag.TIFF_DOUBLE:

   819             return new double[count];

   820         default:

   821             throw new IllegalArgumentException("Unknown data type "+dataType);

   822         }

   823     }

   824 

   825     /**

   826      * Returns the <code>TIFFField</code> as a node named either

   827      * <tt>"TIFFField"</tt> or <tt>"TIFFIFD"</tt> as described in the

   828      * TIFF native image metadata specification. The node will be named

   829      * <tt>"TIFFIFD"</tt> if and only if the field's data object is an

   830      * instance of {@link TIFFDirectory} or equivalently

   831      * {@link TIFFTag#isIFDPointer getTag.isIFDPointer()} returns

   832      * <code>true</code>.

   833      *

   834      * @return a <code>Node</code> named <tt>"TIFFField"</tt> or

   835      * <tt>"TIFFIFD"</tt>.

   836      */

   837     public Node getAsNativeNode() {

   838         return new TIFFFieldNode(this);

   839     }

   840 

   841     /**

   842      * Indicates whether the value associated with the field is of

   843      * integral data type.

   844      *

   845      * @return Whether the field type is integral.

   846      */

   847     public boolean isIntegral() {

   848         return isIntegral[type];

   849     }

   850 

   851     /**

   852      * Returns the number of data items present in the field.  For

   853      * <code>TIFFTag.TIFF_ASCII</code> fields, the value returned is the

   854      * number of <code>String</code>s, not the total length of the

   855      * data as in the file representation.

   856      *

   857      * @return The number of data items present in the field.

   858      */

   859     public int getCount() {

   860         return count;

   861     }

   862 

   863     /**

   864      * Returns a reference to the data object associated with the field.

   865      *

   866      * @return The data object of the field.

   867      */

   868     public Object getData() {

   869         return data;

   870     }

   871 

   872     /**

   873      * Returns the data as an uninterpreted array of

   874      * <code>byte</code>s.  The type of the field must be one of

   875      * <code>TIFFTag.TIFF_BYTE</code>, <code>TIFF_SBYTE</code>, or

   876      * <code>TIFF_UNDEFINED</code>.

   877      *

   878      * <p> For data in <code>TIFFTag.TIFF_BYTE</code> format, the application

   879      * must take care when promoting the data to longer integral types

   880      * to avoid sign extension.

   881      *

   882      * @throws ClassCastException if the field is not of type

   883      * <code>TIFF_BYTE</code>, <code>TIFF_SBYTE</code>, or

   884      * <code>TIFF_UNDEFINED</code>.

   885      * @return The data as an uninterpreted array of bytes.

   886      */

   887     public byte[] getAsBytes() {

   888         return (byte[])data;

   889     }

   890 

   891     /**

   892      * Returns <code>TIFFTag.TIFF_SHORT</code> data as an array of

   893      * <code>char</code>s (unsigned 16-bit integers).

   894      *

   895      * @throws ClassCastException if the field is not of type

   896      * <code>TIFF_SHORT</code>.

   897      * @return The data as an array of {@code char}s.

   898      */

   899     public char[] getAsChars() {

   900         return (char[])data;

   901     }

   902 

   903     /**

   904      * Returns <code>TIFFTag.TIFF_SSHORT</code> data as an array of

   905      * <code>short</code>s (signed 16-bit integers).

   906      *

   907      * @throws ClassCastException if the field is not of type

   908      * <code>TIFF_SSHORT</code>.

   909      * @return The data as an array of {@code short}s.

   910      */

   911     public short[] getAsShorts() {

   912         return (short[])data;

   913     }

   914 

   915     /**

   916      * Returns <code>TIFFTag.TIFF_SLONG</code> data as an array of

   917      * <code>int</code>s (signed 32-bit integers).

   918      *

   919      * @throws ClassCastException if the field is not of type

   920      * <code>TIFF_SHORT</code>, <code>TIFF_SSHORT</code>, or

   921      * <code>TIFF_SLONG</code>.

   922      * @return The data as an array of {@code int}s.

   923      */

   924     public int[] getAsInts() {

   925         if (data instanceof int[]) {

   926             return (int[])data;

   927         } else if (data instanceof char[]){

   928             char[] cdata = (char[])data;

   929             int[] idata = new int[cdata.length];

   930             for (int i = 0; i < cdata.length; i++) {

   931                 idata[i] = cdata[i] & 0xffff;

   932             }

   933             return idata;

   934         } else if (data instanceof short[]){

   935             short[] sdata = (short[])data;

   936             int[] idata = new int[sdata.length];

   937             for (int i = 0; i < sdata.length; i++) {

   938                 idata[i] = (int)sdata[i];

   939             }

   940             return idata;

   941         } else {

   942             throw new ClassCastException("Data not char[], short[], or int[]!");

   943         }

   944     }

   945 

   946     /**

   947      * Returns <code>TIFFTag.TIFF_LONG</code> or

   948      * <code>TIFF_IFD_POINTER</code> data as an array of

   949      * <code>long</code>s (signed 64-bit integers).

   950      *

   951      * @throws ClassCastException if the field is not of type

   952      * <code>TIFF_LONG</code> or <code>TIFF_IFD_POINTER</code>.

   953      * @return The data as an array of {@code long}s.

   954      */

   955     public long[] getAsLongs() {

   956         return (long[])data;

   957     }

   958 

   959     /**

   960      * Returns <code>TIFFTag.TIFF_FLOAT</code> data as an array of

   961      * <code>float</code>s (32-bit floating-point values).

   962      *

   963      * @throws ClassCastException if the field is not of type

   964      * <code>TIFF_FLOAT</code>.

   965      * @return The data as an array of {@code float}s.

   966      */

   967     public float[] getAsFloats() {

   968         return (float[])data;

   969     }

   970 

   971     /**

   972      * Returns <code>TIFFTag.TIFF_DOUBLE</code> data as an array of

   973      * <code>double</code>s (64-bit floating-point values).

   974      *

   975      * @throws ClassCastException if the field is not of type

   976      * <code>TIFF_DOUBLE</code>.

   977      * @return The data as an array of {@code double}s.

   978      */

   979     public double[] getAsDoubles() {

   980         return (double[])data;

   981     }

   982 

   983     /**

   984      * Returns <code>TIFFTag.TIFF_SRATIONAL</code> data as an array of

   985      * 2-element arrays of <code>int</code>s.

   986      *

   987      * @throws ClassCastException if the field is not of type

   988      * <code>TIFF_SRATIONAL</code>.

   989      * @return The data as an array of signed rationals.

   990      */

   991     public int[][] getAsSRationals() {

   992         return (int[][])data;

   993     }

   994 

   995     /**

   996      * Returns <code>TIFFTag.TIFF_RATIONAL</code> data as an array of

   997      * 2-element arrays of <code>long</code>s.

   998      *

   999      * @throws ClassCastException if the field is not of type

  1000      * <code>TIFF_RATIONAL</code>.

  1001      * @return The data as an array of unsigned rationals.

  1002      */

  1003     public long[][] getAsRationals() {

  1004         return (long[][])data;

  1005     }

  1006 

  1007     /**

  1008      * Returns data in any format as an <code>int</code>.

  1009      *

  1010      * <p> <code>TIFFTag.TIFF_BYTE</code> values are treated as unsigned; that

  1011      * is, no sign extension will take place and the returned value

  1012      * will be in the range [0, 255].  <code>TIFF_SBYTE</code> data

  1013      * will be returned in the range [-128, 127].

  1014      *

  1015      * <p> A <code>TIFF_UNDEFINED</code> value is treated as though

  1016      * it were a <code>TIFF_BYTE</code>.

  1017      *

  1018      * <p> Data in <code>TIFF_SLONG</code>, <code>TIFF_LONG</code>,

  1019      * <code>TIFF_FLOAT</code>, <code>TIFF_DOUBLE</code> or

  1020      * <code>TIFF_IFD_POINTER</code> format are simply cast to

  1021      * <code>int</code> and may suffer from truncation.

  1022      *

  1023      * <p> Data in <code>TIFF_SRATIONAL</code> or

  1024      * <code>TIFF_RATIONAL</code> format are evaluated by dividing the

  1025      * numerator into the denominator using double-precision

  1026      * arithmetic and then casting to <code>int</code>.  Loss of

  1027      * precision and truncation may occur.

  1028      *

  1029      * <p> Data in <code>TIFF_ASCII</code> format will be parsed as by

  1030      * the <code>Double.parseDouble</code> method, with the result

  1031      * case to <code>int</code>.

  1032      *

  1033      * @param index The index of the data.

  1034      * @return The data at the given index as an {@code int}.

  1035      */

  1036     public int getAsInt(int index) {

  1037         switch (type) {

  1038         case TIFFTag.TIFF_BYTE:

  1039         case TIFFTag.TIFF_UNDEFINED:

  1040             return ((byte[])data)[index] & 0xff;

  1041         case TIFFTag.TIFF_SBYTE:

  1042             return ((byte[])data)[index];

  1043         case TIFFTag.TIFF_SHORT:

  1044             return ((char[])data)[index] & 0xffff;

  1045         case TIFFTag.TIFF_SSHORT:

  1046             return ((short[])data)[index];

  1047         case TIFFTag.TIFF_SLONG:

  1048             return ((int[])data)[index];

  1049         case TIFFTag.TIFF_LONG:

  1050         case TIFFTag.TIFF_IFD_POINTER:

  1051             return (int)((long[])data)[index];

  1052         case TIFFTag.TIFF_FLOAT:

  1053             return (int)((float[])data)[index];

  1054         case TIFFTag.TIFF_DOUBLE:

  1055             return (int)((double[])data)[index];

  1056         case TIFFTag.TIFF_SRATIONAL:

  1057             int[] ivalue = getAsSRational(index);

  1058             return (int)((double)ivalue[0]/ivalue[1]);

  1059         case TIFFTag.TIFF_RATIONAL:

  1060             long[] lvalue = getAsRational(index);

  1061             return (int)((double)lvalue[0]/lvalue[1]);

  1062         case TIFFTag.TIFF_ASCII:

  1063              String s = ((String[])data)[index];

  1064              return (int)Double.parseDouble(s);

  1065         default:

  1066             throw new ClassCastException(); // should never happen

  1067         }

  1068     }

  1069 

  1070     /**

  1071      * Returns data in any format as a <code>long</code>.

  1072      *

  1073      * <p> <code>TIFFTag.TIFF_BYTE</code> and <code>TIFF_UNDEFINED</code> data

  1074      * are treated as unsigned; that is, no sign extension will take

  1075      * place and the returned value will be in the range [0, 255].

  1076      * <code>TIFF_SBYTE</code> data will be returned in the range

  1077      * [-128, 127].

  1078      *

  1079      * <p> Data in <code>TIFF_ASCII</code> format will be parsed as by

  1080      * the <code>Double.parseDouble</code> method, with the result

  1081      * cast to <code>long</code>.

  1082      *

  1083      * @param index The index of the data.

  1084      * @return The data at the given index as a {@code long}.

  1085      */

  1086     public long getAsLong(int index) {

  1087         switch (type) {

  1088         case TIFFTag.TIFF_BYTE:

  1089         case TIFFTag.TIFF_UNDEFINED:

  1090             return ((byte[])data)[index] & 0xff;

  1091         case TIFFTag.TIFF_SBYTE:

  1092             return ((byte[])data)[index];

  1093         case TIFFTag.TIFF_SHORT:

  1094             return ((char[])data)[index] & 0xffff;

  1095         case TIFFTag.TIFF_SSHORT:

  1096             return ((short[])data)[index];

  1097         case TIFFTag.TIFF_SLONG:

  1098             return ((int[])data)[index];

  1099         case TIFFTag.TIFF_LONG:

  1100         case TIFFTag.TIFF_IFD_POINTER:

  1101             return ((long[])data)[index];

  1102         case TIFFTag.TIFF_SRATIONAL:

  1103             int[] ivalue = getAsSRational(index);

  1104             return (long)((double)ivalue[0]/ivalue[1]);

  1105         case TIFFTag.TIFF_RATIONAL:

  1106             long[] lvalue = getAsRational(index);

  1107             return (long)((double)lvalue[0]/lvalue[1]);

  1108         case TIFFTag.TIFF_ASCII:

  1109              String s = ((String[])data)[index];

  1110              return (long)Double.parseDouble(s);

  1111         default:

  1112             throw new ClassCastException(); // should never happen

  1113         }

  1114     }

  1115 

  1116     /**

  1117      * Returns data in any format as a <code>float</code>.

  1118      *

  1119      * <p> <code>TIFFTag.TIFF_BYTE</code> and <code>TIFF_UNDEFINED</code> data

  1120      * are treated as unsigned; that is, no sign extension will take

  1121      * place and the returned value will be in the range [0, 255].

  1122      * <code>TIFF_SBYTE</code> data will be returned in the range

  1123      * [-128, 127].

  1124      *

  1125      * <p> Data in <code>TIFF_SLONG</code>, <code>TIFF_LONG</code>,

  1126      * <code>TIFF_DOUBLE</code>, or <code>TIFF_IFD_POINTER</code> format are

  1127      * simply cast to <code>float</code> and may suffer from

  1128      * truncation.

  1129      *

  1130      * <p> Data in <code>TIFF_SRATIONAL</code> or

  1131      * <code>TIFF_RATIONAL</code> format are evaluated by dividing the

  1132      * numerator into the denominator using double-precision

  1133      * arithmetic and then casting to <code>float</code>.

  1134      *

  1135      * <p> Data in <code>TIFF_ASCII</code> format will be parsed as by