incubator-flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cframp...@apache.org
Subject svn commit: r1402274 [15/31] - in /incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext: ./ awt/ awt/color/ awt/font/ awt/g2d/ awt/geom/ awt/image/ awt/image/codec/ awt/image/codec/jpeg/ awt/image/codec/p...
Date Thu, 25 Oct 2012 19:01:49 GMT
Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFDirectory.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFDirectory.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFDirectory.java
(added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFDirectory.java
Thu Oct 25 19:01:43 2012
@@ -0,0 +1,629 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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 org.apache.flex.forks.batik.ext.awt.image.codec.tiff;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Iterator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.List;
+import java.util.ArrayList;
+
+import org.apache.flex.forks.batik.ext.awt.image.codec.util.SeekableStream;
+
+/**
+ * A class representing an Image File Directory (IFD) from a TIFF 6.0
+ * stream.  The TIFF file format is described in more detail in the
+ * comments for the TIFFDescriptor class.
+ *
+ * <p> A TIFF IFD consists of a set of TIFFField tags.  Methods are
+ * provided to query the set of tags and to obtain the raw field
+ * array.  In addition, convenience methods are provided for acquiring
+ * the values of tags that contain a single value that fits into a
+ * byte, int, long, float, or double.
+ *
+ * <p> Every TIFF file is made up of one or more public IFDs that are
+ * joined in a linked list, rooted in the file header.  A file may
+ * also contain so-called private IFDs that are referenced from
+ * tag data and do not appear in the main list.
+ *
+ * <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 TIFFField
+ * @version $Id: TIFFDirectory.java 501495 2007-01-30 18:00:36Z dvholten $
+ */
+public class TIFFDirectory implements Serializable {
+
+    /** A boolean storing the endianness of the stream. */
+    boolean isBigEndian;
+
+    /** The number of entries in the IFD. */
+    int numEntries;
+
+    /** An array of TIFFFields. */
+    TIFFField[] fields;
+
+    /** A Hashtable indexing the fields by tag number. */
+    Map fieldIndex = new HashMap();
+
+    /** The offset of this IFD. */
+    long IFDOffset = 8;
+
+    /** The offset of the next IFD. */
+    long nextIFDOffset = 0;
+
+    /** The default constructor. */
+    TIFFDirectory() {}
+
+    private static boolean isValidEndianTag(int endian) {
+        return ((endian == 0x4949) || (endian == 0x4d4d));
+    }
+
+    /**
+     * Constructs a TIFFDirectory from a SeekableStream.
+     * The directory parameter specifies which directory to read from
+     * the linked list present in the stream; directory 0 is normally
+     * read but it is possible to store multiple images in a single
+     * TIFF file by maintaing multiple directories.
+     *
+     * @param stream a SeekableStream to read from.
+     * @param directory the index of the directory to read.
+     */
+    public TIFFDirectory(SeekableStream stream, int directory)
+        throws IOException {
+
+        long global_save_offset = stream.getFilePointer();
+        long ifd_offset;
+
+        // Read the TIFF header
+        stream.seek(0L);
+        int endian = stream.readUnsignedShort();
+        if (!isValidEndianTag(endian)) {
+            throw new
+                IllegalArgumentException("TIFFDirectory1");
+        }
+        isBigEndian = (endian == 0x4d4d);
+
+        int magic = readUnsignedShort(stream);
+        if (magic != 42) {
+            throw new
+                IllegalArgumentException("TIFFDirectory2");
+        }
+
+        // Get the initial ifd offset as an unsigned int (using a long)
+        ifd_offset = readUnsignedInt(stream);
+
+        for (int i = 0; i < directory; i++) {
+            if (ifd_offset == 0L) {
+                throw new
+                   IllegalArgumentException("TIFFDirectory3");
+            }
+
+            stream.seek(ifd_offset);
+            long entries = readUnsignedShort(stream);
+            stream.skip(12*entries);
+
+            ifd_offset = readUnsignedInt(stream);
+        }
+
+        stream.seek(ifd_offset);
+        initialize(stream);
+        stream.seek(global_save_offset);
+    }
+
+    /**
+     * Constructs a TIFFDirectory by reading a SeekableStream.
+     * The ifd_offset parameter specifies the stream offset from which
+     * to begin reading; this mechanism is sometimes used to store
+     * private IFDs within a TIFF file that are not part of the normal
+     * sequence of IFDs.
+     *
+     * @param stream a SeekableStream to read from.
+     * @param ifd_offset the long byte offset of the directory.
+     * @param directory the index of the directory to read beyond the
+     *        one at the current stream offset; zero indicates the IFD
+     *        at the current offset.
+     */
+    public TIFFDirectory(SeekableStream stream, long ifd_offset, int directory)
+        throws IOException {
+
+        long global_save_offset = stream.getFilePointer();
+        stream.seek(0L);
+        int endian = stream.readUnsignedShort();
+        if (!isValidEndianTag(endian)) {
+            throw new
+                IllegalArgumentException("TIFFDirectory1");
+        }
+        isBigEndian = (endian == 0x4d4d);
+
+        // Seek to the first IFD.
+        stream.seek(ifd_offset);
+
+        // Seek to desired IFD if necessary.
+        int dirNum = 0;
+        while(dirNum < directory) {
+            // Get the number of fields in the current IFD.
+            long numEntries = readUnsignedShort(stream);
+
+            // Skip to the next IFD offset value field.
+            stream.seek(ifd_offset + 12*numEntries);
+
+            // Read the offset to the next IFD beyond this one.
+            ifd_offset = readUnsignedInt(stream);
+
+            // Seek to the next IFD.
+            stream.seek(ifd_offset);
+
+            // Increment the directory.
+            dirNum++;
+        }
+
+        initialize(stream);
+        stream.seek(global_save_offset);
+    }
+
+    private static final int[] sizeOfType = {
+        0, //  0 = n/a
+        1, //  1 = byte
+        1, //  2 = ascii
+        2, //  3 = short
+        4, //  4 = long
+        8, //  5 = rational
+        1, //  6 = sbyte
+        1, //  7 = undefined
+        2, //  8 = sshort
+        4, //  9 = slong
+        8, // 10 = srational
+        4, // 11 = float
+        8  // 12 = double
+    };
+
+    private void initialize(SeekableStream stream) throws IOException {
+        long nextTagOffset;
+        int i, j;
+
+        IFDOffset = stream.getFilePointer();
+
+        numEntries = readUnsignedShort(stream);
+        fields = new TIFFField[numEntries];
+
+        for (i = 0; i < numEntries; i++) {
+            int tag = readUnsignedShort(stream);
+            int type = readUnsignedShort(stream);
+            int count = (int)(readUnsignedInt(stream));
+            int value = 0;
+
+            // The place to return to to read the next tag
+            nextTagOffset = stream.getFilePointer() + 4;
+
+            try {
+                // If the tag data can't fit in 4 bytes, the next 4 bytes
+                // contain the starting offset of the data
+                if (count*sizeOfType[type] > 4) {
+                    value = (int)(readUnsignedInt(stream));
+                    stream.seek(value);
+                }
+            } catch (ArrayIndexOutOfBoundsException ae) {
+
+                System.err.println(tag + " " + "TIFFDirectory4");
+                // if the data type is unknown we should skip this TIFF Field
+                stream.seek(nextTagOffset);
+                continue;
+            }
+
+            fieldIndex.put(new Integer(tag), new Integer(i));
+            Object obj = null;
+
+            switch (type) {
+            case TIFFField.TIFF_BYTE:
+            case TIFFField.TIFF_SBYTE:
+            case TIFFField.TIFF_UNDEFINED:
+            case TIFFField.TIFF_ASCII:
+                byte[] bvalues = new byte[count];
+                stream.readFully(bvalues, 0, count);
+
+                if (type == TIFFField.TIFF_ASCII) {
+
+                    // Can be multiple strings
+                    int index = 0, prevIndex = 0;
+                    List v = new ArrayList();
+
+                    while (index < count) {
+
+                        while ((index < count) && (bvalues[index++] != 0));
+
+                        // When we encountered zero, means one string has ended
+                        v.add(new String(bvalues, prevIndex,
+                                         (index - prevIndex)) );
+                        prevIndex = index;
+                    }
+
+                    count = v.size();
+                    String[] strings = new String[count];
+                    v.toArray( strings );
+                    obj = strings;
+                } else {
+                    obj = bvalues;
+                }
+
+                break;
+
+            case TIFFField.TIFF_SHORT:
+                char[] cvalues = new char[count];
+                for (j = 0; j < count; j++) {
+                    cvalues[j] = (char)(readUnsignedShort(stream));
+                }
+                obj = cvalues;
+                break;
+
+            case TIFFField.TIFF_LONG:
+                long[] lvalues = new long[count];
+                for (j = 0; j < count; j++) {
+                    lvalues[j] = readUnsignedInt(stream);
+                }
+                obj = lvalues;
+                break;
+
+            case TIFFField.TIFF_RATIONAL:
+                long[][] llvalues = new long[count][2];
+                for (j = 0; j < count; j++) {
+                    llvalues[j][0] = readUnsignedInt(stream);
+                    llvalues[j][1] = readUnsignedInt(stream);
+                }
+                obj = llvalues;
+                break;
+
+            case TIFFField.TIFF_SSHORT:
+                short[] svalues = new short[count];
+                for (j = 0; j < count; j++) {
+                    svalues[j] = readShort(stream);
+                }
+                obj = svalues;
+                break;
+
+            case TIFFField.TIFF_SLONG:
+                int[] ivalues = new int[count];
+                for (j = 0; j < count; j++) {
+                    ivalues[j] = readInt(stream);
+                }
+                obj = ivalues;
+                break;
+
+            case TIFFField.TIFF_SRATIONAL:
+                int[][] iivalues = new int[count][2];
+                for (j = 0; j < count; j++) {
+                    iivalues[j][0] = readInt(stream);
+                    iivalues[j][1] = readInt(stream);
+                }
+                obj = iivalues;
+                break;
+
+            case TIFFField.TIFF_FLOAT:
+                float[] fvalues = new float[count];
+                for (j = 0; j < count; j++) {
+                    fvalues[j] = readFloat(stream);
+                }
+                obj = fvalues;
+                break;
+
+            case TIFFField.TIFF_DOUBLE:
+                double[] dvalues = new double[count];
+                for (j = 0; j < count; j++) {
+                    dvalues[j] = readDouble(stream);
+                }
+                obj = dvalues;
+                break;
+
+            default:
+                System.err.println("TIFFDirectory0");
+                break;
+            }
+
+            fields[i] = new TIFFField(tag, type, count, obj);
+            stream.seek(nextTagOffset);
+        }
+
+        // Read the offset of the next IFD.
+        nextIFDOffset = readUnsignedInt(stream);
+    }
+
+    /** Returns the number of directory entries. */
+    public int getNumEntries() {
+        return numEntries;
+    }
+
+    /**
+     * Returns the value of a given tag as a TIFFField,
+     * or null if the tag is not present.
+     */
+    public TIFFField getField(int tag) {
+        Integer i = (Integer)fieldIndex.get(new Integer(tag));
+        if (i == null) {
+            return null;
+        } else {
+            return fields[i.intValue()];
+        }
+    }
+
+    /**
+     * Returns true if a tag appears in the directory.
+     */
+    public boolean isTagPresent(int tag) {
+        return fieldIndex.containsKey(new Integer(tag));
+    }
+
+    /**
+     * Returns an ordered array of ints indicating the tag
+     * values.
+     */
+    public int[] getTags() {
+        int[] tags = new int[fieldIndex.size()];
+        Iterator iter = fieldIndex.keySet().iterator();
+        int i = 0;
+
+        while (iter.hasNext()) {
+            tags[i++] = ((Integer)iter.next()).intValue();
+        }
+
+        return tags;
+    }
+
+    /**
+     * Returns an array of TIFFFields containing all the fields
+     * in this directory.
+     */
+    public TIFFField[] getFields() {
+        return fields;
+    }
+
+    /**
+     * Returns the value of a particular index of a given tag as a
+     * byte.  The caller is responsible for ensuring that the tag is
+     * present and has type TIFFField.TIFF_SBYTE, TIFF_BYTE, or
+     * TIFF_UNDEFINED.
+     */
+    public byte getFieldAsByte(int tag, int index) {
+        Integer i = (Integer)fieldIndex.get(new Integer(tag));
+        byte [] b = (fields[i.intValue()]).getAsBytes();
+        return b[index];
+    }
+
+    /**
+     * Returns the value of index 0 of a given tag as a
+     * byte.  The caller is responsible for ensuring that the tag is
+     * present and has  type TIFFField.TIFF_SBYTE, TIFF_BYTE, or
+     * TIFF_UNDEFINED.
+     */
+    public byte getFieldAsByte(int tag) {
+        return getFieldAsByte(tag, 0);
+    }
+
+    /**
+     * Returns the value of a particular index of a given tag as a
+     * long.  The caller is responsible for ensuring that the tag is
+     * present and has type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED,
+     * TIFF_SHORT, TIFF_SSHORT, TIFF_SLONG or TIFF_LONG.
+     */
+    public long getFieldAsLong(int tag, int index) {
+        Integer i = (Integer)fieldIndex.get(new Integer(tag));
+        return (fields[i.intValue()]).getAsLong(index);
+    }
+
+    /**
+     * Returns the value of index 0 of a given tag as a
+     * long.  The caller is responsible for ensuring that the tag is
+     * present and has type TIFF_BYTE, TIFF_SBYTE, TIFF_UNDEFINED,
+     * TIFF_SHORT, TIFF_SSHORT, TIFF_SLONG or TIFF_LONG.
+     */
+    public long getFieldAsLong(int tag) {
+        return getFieldAsLong(tag, 0);
+    }
+
+    /**
+     * Returns the value of a particular index of a given tag as a
+     * float.  The caller is responsible for ensuring that the tag is
+     * present and has numeric type (all but TIFF_UNDEFINED and
+     * TIFF_ASCII).
+     */
+    public float getFieldAsFloat(int tag, int index) {
+        Integer i = (Integer)fieldIndex.get(new Integer(tag));
+        return fields[i.intValue()].getAsFloat(index);
+    }
+
+    /**
+     * Returns the value of index 0 of a given tag as a float.  The
+     * caller is responsible for ensuring that the tag is present and
+     * has numeric type (all but TIFF_UNDEFINED and TIFF_ASCII).
+     */
+    public float getFieldAsFloat(int tag) {
+        return getFieldAsFloat(tag, 0);
+    }
+
+    /**
+     * Returns the value of a particular index of a given tag as a
+     * double.  The caller is responsible for ensuring that the tag is
+     * present and has numeric type (all but TIFF_UNDEFINED and
+     * TIFF_ASCII).
+     */
+    public double getFieldAsDouble(int tag, int index) {
+        Integer i = (Integer)fieldIndex.get(new Integer(tag));
+        return fields[i.intValue()].getAsDouble(index);
+    }
+
+    /**
+     * Returns the value of index 0 of a given tag as a double.  The
+     * caller is responsible for ensuring that the tag is present and
+     * has numeric type (all but TIFF_UNDEFINED and TIFF_ASCII).
+     */
+    public double getFieldAsDouble(int tag) {
+        return getFieldAsDouble(tag, 0);
+    }
+
+    // Methods to read primitive data types from the stream
+
+    private short readShort(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readShort();
+        } else {
+            return stream.readShortLE();
+        }
+    }
+
+    private int readUnsignedShort(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readUnsignedShort();
+        } else {
+            return stream.readUnsignedShortLE();
+        }
+    }
+
+    private int readInt(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readInt();
+        } else {
+            return stream.readIntLE();
+        }
+    }
+
+    private long readUnsignedInt(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readUnsignedInt();
+        } else {
+            return stream.readUnsignedIntLE();
+        }
+    }
+
+    private long readLong(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readLong();
+        } else {
+            return stream.readLongLE();
+        }
+    }
+
+    private float readFloat(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readFloat();
+        } else {
+            return stream.readFloatLE();
+        }
+    }
+
+    private double readDouble(SeekableStream stream)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readDouble();
+        } else {
+            return stream.readDoubleLE();
+        }
+    }
+
+    private static int readUnsignedShort(SeekableStream stream,
+                                         boolean isBigEndian)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readUnsignedShort();
+        } else {
+            return stream.readUnsignedShortLE();
+        }
+    }
+
+    private static long readUnsignedInt(SeekableStream stream,
+                                        boolean isBigEndian)
+        throws IOException {
+        if (isBigEndian) {
+            return stream.readUnsignedInt();
+        } else {
+            return stream.readUnsignedIntLE();
+        }
+    }
+
+    // Utilities
+
+    /**
+     * Returns the number of image directories (subimages) stored in a
+     * given TIFF file, represented by a <code>SeekableStream</code>.
+     */
+    public static int getNumDirectories(SeekableStream stream)
+        throws IOException{
+        long pointer = stream.getFilePointer(); // Save stream pointer
+
+        stream.seek(0L);
+        int endian = stream.readUnsignedShort();
+        if (!isValidEndianTag(endian)) {
+            throw new
+                IllegalArgumentException("TIFFDirectory1");
+        }
+        boolean isBigEndian = (endian == 0x4d4d);
+        int magic = readUnsignedShort(stream, isBigEndian);
+        if (magic != 42) {
+            throw new
+                IllegalArgumentException("TIFFDirectory2");
+        }
+
+        stream.seek(4L);
+        long offset = readUnsignedInt(stream, isBigEndian);
+
+        int numDirectories = 0;
+        while (offset != 0L) {
+            ++numDirectories;
+
+            stream.seek(offset);
+            long entries = readUnsignedShort(stream, isBigEndian);
+            stream.skip(12*entries);
+            offset = readUnsignedInt(stream, isBigEndian);
+        }
+
+        stream.seek(pointer); // Reset stream pointer
+        return numDirectories;
+    }
+
+    /**
+     * Returns a boolean indicating whether the byte order used in the
+     * the TIFF file is big-endian.  That is, whether the byte order is from
+     * the most significant to the least significant.
+     */
+    public boolean isBigEndian() {
+        return isBigEndian;
+    }
+
+    /**
+     * Returns the offset of the IFD corresponding to this
+     * <code>TIFFDirectory</code>.
+     */
+    public long getIFDOffset() {
+        return IFDOffset;
+    }
+
+    /**
+     * Returns the offset of the next IFD after the IFD corresponding to this
+     * <code>TIFFDirectory</code>.
+     */
+    public long getNextIFDOffset() {
+        return nextIFDOffset;
+    }
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFDirectory.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFEncodeParam.java
URL: http://svn.apache.org/viewvc/incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFEncodeParam.java?rev=1402274&view=auto
==============================================================================
--- incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFEncodeParam.java
(added)
+++ incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFEncodeParam.java
Thu Oct 25 19:01:43 2012
@@ -0,0 +1,342 @@
+/*
+
+   Licensed to the Apache Software Foundation (ASF) under one or more
+   contributor license agreements.  See the NOTICE file distributed with
+   this work for additional information regarding copyright ownership.
+   The ASF licenses this file to You 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 org.apache.flex.forks.batik.ext.awt.image.codec.tiff;
+
+import java.util.Iterator;
+import java.util.zip.Deflater;
+
+import org.apache.flex.forks.batik.ext.awt.image.codec.util.ImageEncodeParam;
+
+import com.sun.image.codec.jpeg.JPEGEncodeParam;
+
+/**
+ * An instance of <code>ImageEncodeParam</code> for encoding images in
+ * the TIFF format.
+ *
+ * <p> This class allows for the specification of encoding parameters. By
+ * default, the image is encoded without any compression, and is written
+ * out consisting of strips, not tiles. The particular compression scheme
+ * to be used can be specified by using the <code>setCompression()</code>
+ * method. The compression scheme specified will be honored only if it is
+ * compatible with the type of image being written out. For example,
+ * Group3 and Group4 compressions can only be used with Bilevel images.
+ * Writing of tiled TIFF images can be enabled by calling the
+ * <code>setWriteTiled()</code> method.
+ *
+ * <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>
+ *
+ * @version $Id: TIFFEncodeParam.java 498740 2007-01-22 18:35:57Z dvholten $
+ */
+public class TIFFEncodeParam implements ImageEncodeParam {
+
+    /** No compression. */
+    public static final int COMPRESSION_NONE          = 1;
+
+    /**
+     * Modified Huffman Compression (CCITT Group 3 1D facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    public static final int COMPRESSION_GROUP3_1D     = 2;
+
+    /**
+     * CCITT T.4 bilevel compression (CCITT Group 3 2D facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    public static final int COMPRESSION_GROUP3_2D     = 3;
+
+    /**
+     * CCITT T.6 bilevel compression (CCITT Group 4 facsimile compression).
+     * <p><b>Not currently supported.</b>
+     */
+    public static final int COMPRESSION_GROUP4        = 4;
+
+    /**
+     * LZW compression.
+     * <p><b>Not supported.</b>
+     */
+    public static final int COMPRESSION_LZW           = 5;
+
+    /**
+     * Code for original JPEG-in-TIFF compression which has been
+     * depricated (for many good reasons) in favor of Tech Note 2
+     * JPEG compression (compression scheme 7).
+     * <p><b>Not supported.</b>
+     */
+    public static final int COMPRESSION_JPEG_BROKEN   = 6;
+
+    /**
+     * <a href="ftp://ftp.sgi.com/graphics/tiff/TTN2.draft.txt">
+     * JPEG-in-TIFF</a> compression.
+     */
+    public static final int COMPRESSION_JPEG_TTN2     = 7;
+
+    /** Byte-oriented run-length encoding "PackBits" compression. */
+    public static final int COMPRESSION_PACKBITS      = 32773;
+
+    /**
+     * <a href="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc1951.txt">
+     * DEFLATE</a> lossless compression (also known as "Zip-in-TIFF").
+     */
+    public static final int COMPRESSION_DEFLATE       = 32946;
+
+    private int compression = COMPRESSION_NONE;
+
+    private boolean writeTiled = false;
+    private int tileWidth;
+    private int tileHeight;
+
+    private Iterator extraImages;
+
+    private TIFFField[] extraFields;
+
+    private boolean convertJPEGRGBToYCbCr = true;
+    private JPEGEncodeParam jpegEncodeParam = null;
+
+    private int deflateLevel = Deflater.DEFAULT_COMPRESSION;
+
+    /**
+     * Constructs a TIFFEncodeParam object with default values for
+     * all parameters.
+     */
+    public TIFFEncodeParam() {}
+
+    /**
+     * Returns the value of the compression parameter.
+     */
+    public int getCompression() {
+        return compression;
+    }
+
+    /**
+     * Specifies the type of compression to be used.  The compression type
+     * specified will be honored only if it is compatible with the image
+     * being written out.  Currently only PackBits, JPEG, and DEFLATE
+     * compression schemes are supported.
+     *
+     * <p> If <code>compression</code> is set to any value but
+     * <code>COMPRESSION_NONE</code> and the <code>OutputStream</code>
+     * supplied to the <code>ImageEncoder</code> is not a
+     * <code>SeekableOutputStream</code>, then the encoder will use either
+     * a temporary file or a memory cache when compressing the data
+     * depending on whether the file system is accessible.  Compression
+     * will therefore be more efficient if a <code>SeekableOutputStream</code>
+     * is supplied.
+     *
+     * @param compression    The compression type.
+     */
+    public void setCompression(int compression) {
+
+        switch(compression) {
+        case COMPRESSION_NONE:
+        case COMPRESSION_PACKBITS:
+        case COMPRESSION_JPEG_TTN2:
+        case COMPRESSION_DEFLATE:
+            // Do nothing.
+            break;
+        default:
+            throw new Error("TIFFEncodeParam0");
+        }
+
+        this.compression = compression;
+    }
+
+    /**
+     * Returns the value of the writeTiled parameter.
+     */
+    public boolean getWriteTiled() {
+        return writeTiled;
+    }
+
+    /**
+     * If set, the data will be written out in tiled format, instead of
+     * in strips.
+     *
+     * @param writeTiled     Specifies whether the image data should be
+     *                       wriiten out in tiled format.
+     */
+    public void setWriteTiled(boolean writeTiled) {
+        this.writeTiled = writeTiled;
+    }
+
+    /**
+     * Sets the dimensions of the tiles to be written.  If either
+     * value is non-positive, the encoder will use a default value.
+     *
+     * <p> If the data are being written as tiles, i.e.,
+     * <code>getWriteTiled()</code> returns <code>true</code>, then
the
+     * default tile dimensions used by the encoder are those of the tiles
+     * of the image being encoded.
+     *
+     * <p> If the data are being written as strips, i.e.,
+     * <code>getWriteTiled()</code> returns <code>false</code>, the
width
+     * of each strip is always the width of the image and the default
+     * number of rows per strip is 8.
+     *
+     * <p> If JPEG compession is being used, the dimensions of the strips or
+     * tiles may be modified to conform to the JPEG-in-TIFF specification.
+     *
+     * @param tileWidth The tile width; ignored if strips are used.
+     * @param tileHeight The tile height or number of rows per strip.
+     */
+    public void setTileSize(int tileWidth, int tileHeight) {
+        this.tileWidth = tileWidth;
+        this.tileHeight = tileHeight;
+    }
+
+    /**
+     * Retrieves the tile width set via <code>setTileSize()</code>.
+     */
+    public int getTileWidth() {
+        return tileWidth;
+    }
+
+    /**
+     * Retrieves the tile height set via <code>setTileSize()</code>.
+     */
+    public int getTileHeight() {
+        return tileHeight;
+    }
+
+    /**
+     * Sets an <code>Iterator</code> of additional images to be written
+     * after the image passed as an argument to the <code>ImageEncoder</code>.
+     * The methods on the supplied <code>Iterator</code> must only be invoked
+     * by the <code>ImageEncoder</code> which will exhaust the available
+     * values unless an error occurs.
+     *
+     * <p> The value returned by an invocation of <code>next()</code> on
the
+     * <code>Iterator</code> must return either a <code>RenderedImage</code>
+     * or an <code>Object[]</code> of length 2 wherein the element at index
+     * zero is a <code>RenderedImage</code> amd the other element is a
+     * <code>TIFFEncodeParam</code>.  If no <code>TIFFEncodeParam</code>
is
+     * supplied in this manner for an additional image, the parameters used
+     * to create the <code>ImageEncoder</code> will be used.  The extra
+     * image <code>Iterator</code> set on any <code>TIFFEncodeParam</code>
+     * of an additional image will in all cases be ignored.
+     */
+    public synchronized void setExtraImages(Iterator extraImages) {
+        this.extraImages = extraImages;
+    }
+
+    /**
+     * Returns the additional image <code>Iterator</code> specified via
+     * <code>setExtraImages()</code> or <code>null</code> if none
was
+     * supplied or if a <code>null</code> value was supplied.
+     */
+    public synchronized Iterator getExtraImages() {
+        return extraImages;
+    }
+
+    /**
+     * Sets the compression level for DEFLATE-compressed data which should
+     * either be <code>java.util.Deflater.DEFAULT_COMPRESSION</code> or a
+     * value in the range [1,9] where larger values indicate more compression.
+     * The default setting is <code>Deflater.DEFAULT_COMPRESSION</code>.  This
+     * setting is ignored if the compression type is not DEFLATE.
+     */
+    public void setDeflateLevel(int deflateLevel) {
+        if(deflateLevel < 1 && deflateLevel > 9 &&
+           deflateLevel != Deflater.DEFAULT_COMPRESSION) {
+            throw new Error("TIFFEncodeParam1");
+        }
+
+        this.deflateLevel = deflateLevel;
+    }
+
+    /**
+     * Gets the compression level for DEFLATE compression.
+     */
+    public int getDeflateLevel() {
+        return deflateLevel;
+    }
+
+    /**
+     * Sets flag indicating whether to convert RGB data to YCbCr when the
+     * compression type is JPEG.  The default value is <code>true</code>.
+     * This flag is ignored if the compression type is not JPEG.
+     */
+    public void setJPEGCompressRGBToYCbCr(boolean convertJPEGRGBToYCbCr) {
+        this.convertJPEGRGBToYCbCr = convertJPEGRGBToYCbCr;
+    }
+
+    /**
+     * Whether RGB data will be converted to YCbCr when using JPEG compression.
+     */
+    public boolean getJPEGCompressRGBToYCbCr() {
+        return convertJPEGRGBToYCbCr;
+    }
+
+    /**
+     * Sets the JPEG compression parameters.  These parameters are ignored
+     * if the compression type is not JPEG.  The argument may be
+     * <code>null</code> to indicate that default compression parameters
+     * are to be used.  For maximum conformance with the specification it
+     * is recommended in most cases that only the quality compression
+     * parameter be set.
+     *
+     * <p> The <code>writeTablesOnly</code> and <code>JFIFHeader</code>
+     * flags of the <code>JPEGEncodeParam</code> are ignored.  The
+     * <code>writeImageOnly</code> flag is used to determine whether the
+     * JPEGTables field will be written to the TIFF stream: if
+     * <code>writeImageOnly</code> is <code>true</code>, then the
JPEGTables
+     * field will be written and will contain a valid JPEG abbreviated
+     * table specification datastream.  In this case the data in each data
+     * segment (strip or tile) will contain an abbreviated JPEG image
+     * datastream.  If the <code>writeImageOnly</code> flag is
+     * <code>false</code>, then the JPEGTables field will not be written and
+     * each data segment will contain a complete JPEG interchange datastream.
+     */
+    public void setJPEGEncodeParam(JPEGEncodeParam jpegEncodeParam) {
+        if(jpegEncodeParam != null) {
+            jpegEncodeParam = (JPEGEncodeParam)jpegEncodeParam.clone();
+            jpegEncodeParam.setTableInfoValid(false);
+            jpegEncodeParam.setImageInfoValid(true);
+        }
+        this.jpegEncodeParam = jpegEncodeParam;
+    }
+
+    /**
+     * Retrieves the JPEG compression parameters.
+     */
+    public JPEGEncodeParam getJPEGEncodeParam() {
+        return jpegEncodeParam;
+    }
+
+    /**
+     * Sets an array of extra fields to be written to the TIFF Image File
+     * Directory (IFD).  Fields with tags equal to the tag of any
+     * automatically generated fields are ignored.  No error checking is
+     * performed with respect to the validity of the field contents or
+     * the appropriateness of the field for the image being encoded.
+     *
+     * @param extraFields An array of extra fields; the parameter is
+     * copied by reference.
+     */
+    public void setExtraFields(TIFFField[] extraFields) {
+        this.extraFields = extraFields;
+    }
+
+    /**
+     * Returns the value set by <code>setExtraFields()</code>.
+     */
+    public TIFFField[] getExtraFields() {
+        return extraFields;
+    }
+}

Propchange: incubator/flex/sdk/branches/develop/modules/thirdparty/batik/sources/org/apache/flex/forks/batik/ext/awt/image/codec/tiff/TIFFEncodeParam.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message