TIFFEncodeParam


1   /*
2   
3      Copyright 2001,2003  The Apache Software Foundation 
4   
5      Licensed under the Apache License, Version 2.0 (the "License");
6      you may not use this file except in compliance with the License.
7      You may obtain a copy of the License at
8   
9          http://www.apache.org/licenses/LICENSE-2.0
10  
11     Unless required by applicable law or agreed to in writing, software
12     distributed under the License is distributed on an "AS IS" BASIS,
13     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14     See the License for the specific language governing permissions and
15     limitations under the License.
16  
17   */
18  package org.apache.batik.ext.awt.image.codec.tiff;
19  
20  import java.util.Iterator  ;
21  import java.util.zip.Deflater  ;
22  
23  import org.apache.batik.ext.awt.image.codec.ImageEncodeParam;
24  
25  import com.sun.image.codec.jpeg.JPEGEncodeParam;
26  
27  /**
28   * An instance of <code>ImageEncodeParam</code> for encoding images in 
29   * the TIFF format.
30   *
31   * <p> This class allows for the specification of encoding parameters. By
32   * default, the image is encoded without any compression, and is written
33   * out consisting of strips, not tiles. The particular compression scheme 
34   * to be used can be specified by using the <code>setCompression()</code>
35   * method. The compression scheme specified will be honored only if it is 
36   * compatible with the type of image being written out. For example, 
37   * Group3 and Group4 compressions can only be used with Bilevel images.
38   * Writing of tiled TIFF images can be enabled by calling the
39   * <code>setWriteTiled()</code> method.
40   *
41   * <p><b> This class is not a committed part of the JAI API.  It may
42   * be removed or changed in future releases of JAI.</b>
43   *
44   */
45  public class TIFFEncodeParam implements ImageEncodeParam {
46  
47      /** No compression. */
48      public static final int COMPRESSION_NONE          = 1;
49  
50      /**
51       * Modified Huffman Compression (CCITT Group 3 1D facsimile compression).
52       * <p><b>Not currently supported.</b>
53       */
54      public static final int COMPRESSION_GROUP3_1D     = 2;
55  
56      /**
57       * CCITT T.4 bilevel compression (CCITT Group 3 2D facsimile compression).
58       * <p><b>Not currently supported.</b>
59       */
60      public static final int COMPRESSION_GROUP3_2D     = 3;
61  
62      /**
63       * CCITT T.6 bilevel compression (CCITT Group 4 facsimile compression).
64       * <p><b>Not currently supported.</b>
65       */
66      public static final int COMPRESSION_GROUP4        = 4;
67  
68      /**
69       * LZW compression.
70       * <p><b>Not supported.</b>
71       */
72      public static final int COMPRESSION_LZW           = 5;
73  
74      /**
75       * Code for original JPEG-in-TIFF compression which has been
76       * depricated (for many good reasons) in favor of Tech Note 2
77       * JPEG compression (compression scheme 7).
78       * <p><b>Not supported.</b>
79       */
80      public static final int COMPRESSION_JPEG_BROKEN   = 6;
81  
82      /**
83       * <a HREF="ftp://ftp.sgi.com/graphics/tiff/TTN2.draft.txt"> 
84       * JPEG-in-TIFF</a> compression.
85       */
86      public static final int COMPRESSION_JPEG_TTN2     = 7;
87  
88      /** Byte-oriented run-length encoding "PackBits" compression. */
89      public static final int COMPRESSION_PACKBITS      = 32773;
90  
91      /**
92       * <a HREF="http://info.internet.isi.edu:80/in-notes/rfc/files/rfc1951.txt"> 
93       * DEFLATE</a> lossless compression (also known as "Zip-in-TIFF").
94       */
95      public static final int COMPRESSION_DEFLATE       = 32946;
96  
97      private int compression = COMPRESSION_NONE;
98  
99      private boolean writeTiled = false;
100     private int tileWidth;
101     private int tileHeight;
102 
103     private Iterator   extraImages;
104 
105     private TIFFField[] extraFields;
106 
107     private boolean convertJPEGRGBToYCbCr = true;
108     private JPEGEncodeParam jpegEncodeParam = null;
109 
110     private int deflateLevel = Deflater.DEFAULT_COMPRESSION;
111 
112     /** 
113      * Constructs a TIFFEncodeParam object with default values for
114      * all parameters.
115      */
116     public TIFFEncodeParam() {}
117 
118     /**
119      * Returns the value of the compression parameter.
120      */
121     public int getCompression() {
122     return compression;
123     }
124 
125     /**
126      * Specifies the type of compression to be used.  The compression type
127      * specified will be honored only if it is compatible with the image
128      * being written out.  Currently only PackBits, JPEG, and DEFLATE
129      * compression schemes are supported.
130      *
131      * <p> If <code>compression</code> is set to any value but
132      * <code>COMPRESSION_NONE</code> and the <code>OutputStream</code>
133      * supplied to the <code>ImageEncoder</code> is not a
134      * <code>SeekableOutputStream</code>, then the encoder will use either
135      * a temporary file or a memory cache when compressing the data
136      * depending on whether the file system is accessible.  Compression
137      * will therefore be more efficient if a <code>SeekableOutputStream</code>
138      * is supplied.
139      *
140      * @param compression    The compression type.
141      */
142     public void setCompression(int compression) {
143 
144         switch(compression) {
145         case COMPRESSION_NONE:
146         case COMPRESSION_PACKBITS:
147         case COMPRESSION_JPEG_TTN2:
148         case COMPRESSION_DEFLATE:
149             // Do nothing.
150             break;
151         default:
152         throw new Error  ("TIFFEncodeParam0");
153     }
154 
155     this.compression = compression;
156     }
157 
158     /**
159      * Returns the value of the writeTiled parameter. 
160      */
161     public boolean getWriteTiled() {
162     return writeTiled;
163     }
164 
165     /**
166      * If set, the data will be written out in tiled format, instead of
167      * in strips.
168      *
169      * @param writeTiled     Specifies whether the image data should be 
170      *                       wriiten out in tiled format.
171      */
172     public void setWriteTiled(boolean writeTiled) {
173     this.writeTiled = writeTiled;
174     }
175 
176     /**
177      * Sets the dimensions of the tiles to be written.  If either
178      * value is non-positive, the encoder will use a default value.
179      *
180      * <p> If the data are being written as tiles, i.e.,
181      * <code>getWriteTiled()</code> returns <code>true</code>, then the
182      * default tile dimensions used by the encoder are those of the tiles
183      * of the image being encoded.
184      *
185      * <p> If the data are being written as strips, i.e.,
186      * <code>getWriteTiled()</code> returns <code>false</code>, the width
187      * of each strip is always the width of the image and the default
188      * number of rows per strip is 8.
189      *
190      * <p> If JPEG compession is being used, the dimensions of the strips or
191      * tiles may be modified to conform to the JPEG-in-TIFF specification.
192      * 
193      * @param tileWidth The tile width; ignored if strips are used.
194      * @param tileHeight The tile height or number of rows per strip.
195      */
196     public void setTileSize(int tileWidth, int tileHeight) {
197         this.tileWidth = tileWidth;
198         this.tileHeight = tileHeight;
199     }
200 
201     /**
202      * Retrieves the tile width set via <code>setTileSize()</code>.
203      */
204     public int getTileWidth() {
205         return tileWidth;
206     }
207 
208     /**
209      * Retrieves the tile height set via <code>setTileSize()</code>.
210      */
211     public int getTileHeight() {
212         return tileHeight;
213     }
214 
215     /**
216      * Sets an <code>Iterator</code> of additional images to be written
217      * after the image passed as an argument to the <code>ImageEncoder</code>.
218      * The methods on the supplied <code>Iterator</code> must only be invoked
219      * by the <code>ImageEncoder</code> which will exhaust the available
220      * values unless an error occurs.
221      *
222      * <p> The value returned by an invocation of <code>next()</code> on the
223      * <code>Iterator</code> must return either a <code>RenderedImage</code>
224      * or an <code>Object[]</code> of length 2 wherein the element at index
225      * zero is a <code>RenderedImage</code> amd the other element is a
226      * <code>TIFFEncodeParam</code>.  If no <code>TIFFEncodeParam</code> is
227      * supplied in this manner for an additional image, the parameters used
228      * to create the <code>ImageEncoder</code> will be used.  The extra
229      * image <code>Iterator</code> set on any <code>TIFFEncodeParam</code>
230      * of an additional image will in all cases be ignored.
231      */
232     public synchronized void setExtraImages(Iterator   extraImages) {
233         this.extraImages = extraImages;
234     }
235 
236     /**
237      * Returns the additional image <code>Iterator</code> specified via
238      * <code>setExtraImages()</code> or <code>null</code> if none was
239      * supplied or if a <code>null</code> value was supplied.
240      */
241     public synchronized Iterator   getExtraImages() {
242         return extraImages;
243     }
244 
245     /**
246      * Sets the compression level for DEFLATE-compressed data which should
247      * either be <code>java.util.Deflater.DEFAULT_COMPRESSION</code> or a
248      * value in the range [1,9] where larger values indicate more compression.
249      * The default setting is <code>Deflater.DEFAULT_COMPRESSION</code>.  This
250      * setting is ignored if the compression type is not DEFLATE.
251      */
252     public void setDeflateLevel(int deflateLevel) {
253         if(deflateLevel < 1 && deflateLevel > 9 &&
254            deflateLevel != Deflater.DEFAULT_COMPRESSION) {
255         throw new Error  ("TIFFEncodeParam1");
256         }
257 
258         this.deflateLevel = deflateLevel;
259     }
260 
261     /**
262      * Gets the compression level for DEFLATE compression.
263      */
264     public int getDeflateLevel() {
265         return deflateLevel;
266     }
267 
268     /**
269      * Sets flag indicating whether to convert RGB data to YCbCr when the
270      * compression type is JPEG.  The default value is <code>true</code>.
271      * This flag is ignored if the compression type is not JPEG.
272      */
273     public void setJPEGCompressRGBToYCbCr(boolean convertJPEGRGBToYCbCr) {
274         this.convertJPEGRGBToYCbCr = convertJPEGRGBToYCbCr;
275     }
276 
277     /**
278      * Whether RGB data will be converted to YCbCr when using JPEG compression.
279      */
280     public boolean getJPEGCompressRGBToYCbCr() {
281         return convertJPEGRGBToYCbCr;
282     }
283 
284     /**
285      * Sets the JPEG compression parameters.  These parameters are ignored
286      * if the compression type is not JPEG.  The argument may be
287      * <code>null</code> to indicate that default compression parameters
288      * are to be used.  For maximum conformance with the specification it
289      * is recommended in most cases that only the quality compression
290      * parameter be set.
291      *
292      * <p> The <code>writeTablesOnly</code> and <code>JFIFHeader</code>
293      * flags of the <code>JPEGEncodeParam</code> are ignored.  The
294      * <code>writeImageOnly</code> flag is used to determine whether the
295      * JPEGTables field will be written to the TIFF stream: if
296      * <code>writeImageOnly</code> is <code>true</code>, then the JPEGTables
297      * field will be written and will contain a valid JPEG abbreviated
298      * table specification datastream.  In this case the data in each data
299      * segment (strip or tile) will contain an abbreviated JPEG image
300      * datastream.  If the <code>writeImageOnly</code> flag is
301      * <code>false</code>, then the JPEGTables field will not be written and
302      * each data segment will contain a complete JPEG interchange datastream.
303      */
304     public void setJPEGEncodeParam(JPEGEncodeParam jpegEncodeParam) {
305         if(jpegEncodeParam != null) {
306             jpegEncodeParam = (JPEGEncodeParam)jpegEncodeParam.clone();
307             jpegEncodeParam.setTableInfoValid(false);
308             jpegEncodeParam.setImageInfoValid(true);
309         }
310         this.jpegEncodeParam = jpegEncodeParam;
311     }
312 
313     /**
314      * Retrieves the JPEG compression parameters.
315      */
316     public JPEGEncodeParam getJPEGEncodeParam() {
317         return jpegEncodeParam;
318     }
319 
320     /**
321      * Sets an array of extra fields to be written to the TIFF Image File
322      * Directory (IFD).  Fields with tags equal to the tag of any
323      * automatically generated fields are ignored.  No error checking is
324      * performed with respect to the validity of the field contents or
325      * the appropriateness of the field for the image being encoded.
326      *
327      * @param extraFields An array of extra fields; the parameter is
328      * copied by reference.
329      */
330     public void setExtraFields(TIFFField[] extraFields) {
331         this.extraFields = extraFields;
332     }
333 
334     /**
335      * Returns the value set by <code>setExtraFields()</code>.
336      */
337     public TIFFField[] getExtraFields() {
338         return extraFields;
339     }
340 }
341
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags