开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > DNA > 查看源码
TIFFImage.java
资源名称：JAIReaderWriterCode1.1.zip　[点击查看]
上传用户：btjssb159
上传日期：2018-01-04
资源大小：241k
文件大小：68k
源码类别：

DNA

开发平台：

Java

TIFFImage.java：源码内容
  1. /*
  2.  * Copyright (c) 2001 Sun Microsystems, Inc. All Rights Reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without 
  5.  * modification, are permitted provided that the following conditions are met:
  6.  * 
  7.  * -Redistributions of source code must retain the above copyright notice, this 
  8.  * list of conditions and the following disclaimer.
  9.  *
  10.  * -Redistribution in binary form must reproduct the above copyright notice,
  11.  * this list of conditions and the following disclaimer in the documentation
  12.  * and/or other materials provided with the distribution.
  13.  * 
  14.  * Neither the name of Sun Microsystems, Inc. or the names of contributors may
  15.  * be used to endorse or promote products derived from this software without
  16.  * specific prior written permission.
  17.  * 
  18.  * This software is provided "AS IS," without a warranty of any kind. ALL
  19.  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
  20.  * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
  21.  * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN AND ITS LICENSORS SHALL NOT BE
  22.  * LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
  23.  * OR DISTRIBUTING THE SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR ITS
  24.  * LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR DIRECT,
  25.  * INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER
  26.  * CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, ARISING OUT OF THE USE OF
  27.  * OR INABILITY TO USE SOFTWARE, EVEN IF SUN HAS BEEN ADVISED OF THE
  28.  * POSSIBILITY OF SUCH DAMAGES.
  29.  * 
  30.  * You acknowledge that Software is not designed,licensed or intended for use in 
  31.  * the design, construction, operation or maintenance of any nuclear facility.
  32.  */
  33. import java.awt.Point;
  34. import java.awt.Rectangle;
  35. import java.awt.Transparency;
  36. import java.awt.color.ColorSpace;
  37. import java.awt.image.ColorModel;
  38. import java.awt.image.DataBuffer;
  39. import java.awt.image.DataBufferByte;
  40. import java.awt.image.DataBufferShort;
  41. import java.awt.image.DataBufferUShort;
  42. import java.awt.image.DataBufferInt;
  43. import java.awt.image.Raster;
  44. import java.awt.image.WritableRaster;
  45. import java.awt.image.RenderedImage;
  46. import java.awt.image.SampleModel;
  47. import java.awt.image.IndexColorModel;
  48. import java.awt.image.MultiPixelPackedSampleModel;
  49. import java.awt.image.PixelInterleavedSampleModel;
  50. import java.awt.image.ComponentColorModel;
  51. import java.io.ByteArrayInputStream;
  52. import java.io.File;
  53. import java.io.InputStream;
  54. import java.io.IOException;
  55. import java.lang.reflect.Constructor;
  56. import java.lang.reflect.Method;
  57. import java.util.zip.DataFormatException;
  58. import java.util.zip.Inflater;
  59. import com.sun.image.codec.jpeg.JPEGCodec;
  60. import com.sun.image.codec.jpeg.JPEGDecodeParam;
  61. import com.sun.image.codec.jpeg.JPEGImageDecoder;
  63. public class TIFFImage extends SimpleRenderedImage {
  65.     // Compression types
  66.     public static final int COMP_NONE      = 1;
  67.     public static final int COMP_FAX_G3_1D = 2;
  68.     public static final int COMP_FAX_G3_2D = 3;
  69.     public static final int COMP_FAX_G4_2D = 4;
  70.     public static final int COMP_LZW       = 5;
  71.     public static final int COMP_JPEG_OLD  = 6;
  72.     public static final int COMP_JPEG_TTN2 = 7;
  73.     public static final int COMP_PACKBITS  = 32773;
  74.     public static final int COMP_DEFLATE   = 32946;
  76.     // Image types
  77.     private static final int TYPE_UNSUPPORTED = -1;
  78.     private static final int TYPE_BILEVEL      = 0;
  79.     private static final int TYPE_GRAY_4BIT    = 1;
  80.     private static final int TYPE_GRAY         = 2;
  81.     private static final int TYPE_GRAY_ALPHA   = 3;
  82.     private static final int TYPE_PALETTE      = 4;
  83.     private static final int TYPE_RGB          = 5;
  84.     private static final int TYPE_RGB_ALPHA    = 6;
  85.     private static final int TYPE_YCBCR_SUB    = 7;
  86.     private static final int TYPE_GENERIC      = 8;
  88.     // Incidental tags
  89.     private static final int TIFF_JPEG_TABLES       = 347;
  90.     private static final int TIFF_YCBCR_SUBSAMPLING = 530;
  92.     SeekableStream stream;
  93.     int tileSize;
  94.     int tilesX, tilesY;
  95.     long[] tileOffsets;
  96.     long[] tileByteCounts;
  97.     char[] colormap;
  98.     int sampleSize;
  99.     int compression;
  100.     byte[] palette;
  101.     int numBands;
  103.     int chromaSubH;
  104.     int chromaSubV;
  106.     // Fax compression related variables
  107.     long tiffT4Options;
  108.     long tiffT6Options;
  109.     int fillOrder;
  111.     // LZW compression related variable
  112.     int predictor;
  114.     // TTN2 JPEG related variables
  115.     JPEGDecodeParam decodeParam = null;
  116.     boolean colorConvertJPEG = false;
  118.     // DEFLATE variables
  119.     Inflater inflater = null;
  121.     // Endian-ness indicator
  122.     boolean isBigEndian;
  123.     
  124.     int imageType;
  125.     boolean isWhiteZero = false;
  126.     int dataType;
  128.     boolean decodePaletteAsShorts;
  130.     // Decoders
  131.     private TIFFFaxDecoder decoder = null;
  132.     private TIFFLZWDecoder lzwDecoder = null;
  134.     /**
  135.      * Decode a buffer of data into a Raster with the specified location.
  136.      *
  137.      * @param data buffer contain an interchange or abbreviated datastream.
  138.      * @param decodeParam decoding parameters; may be null unless the
  139.      *        data buffer contains an abbreviated datastream in which case
  140.      *        it may not be null or an error will occur.
  141.      * @param colorConvert whether to perform color conversion; in this
  142.      *        case that would be limited to YCbCr-to-RGB.
  143.      * @param minX the X position of the returned Raster.
  144.      * @param minY the Y position of the returned Raster.
  145.      */
  146.     private static final Raster decodeJPEG(byte[] data,
  147.                                            JPEGDecodeParam decodeParam,
  148.                                            boolean colorConvert,
  149.                                            int minX,
  150.                                            int minY) {
  151.         // Create an InputStream from the compressed data array.
  152.         ByteArrayInputStream jpegStream = new ByteArrayInputStream(data);
  154.         // Create a decoder.
  155.         JPEGImageDecoder decoder = decodeParam == null ?
  156.             JPEGCodec.createJPEGDecoder(jpegStream) :
  157.             JPEGCodec.createJPEGDecoder(jpegStream,
  158.                                         decodeParam);
  160.         // Decode the compressed data into a Raster.
  161.         Raster jpegRaster;
  162.         try {
  163.             jpegRaster = colorConvert ?
  164.                 decoder.decodeAsBufferedImage().getWritableTile(0, 0) :
  165.                 decoder.decodeAsRaster();
  166.         } catch (IOException ioe) {
  167.             throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  168.         }
  170.         // Translate the decoded Raster to the specified location and return.
  171.         return jpegRaster.createTranslatedChild(minX, minY);
  172.     }
  174.     /**
  175.      * Inflates <code>deflated</code> into <code>inflated</code> using the
  176.      * <code>Inflater</code> constructed during class instantiation.
  177.      */
  178.     private final void inflate(byte[] deflated, byte[] inflated) {
  179.         inflater.setInput(deflated);
  180.         try {
  181.             inflater.inflate(inflated);
  182.         } catch(DataFormatException dfe) {
  183.             throw new RuntimeException(JaiI18N.getString("TIFFImage17")+": "+
  184.                                        dfe.getMessage());
  185.         }
  186.         inflater.reset();
  187.     }
  189.     /**
  190.      * Creates a pixel-interleaved <code>SampleModel</code>. This is a hack
  191.      * to work around a cast exception when using JAI with float data.
  192.      */
  193.     private final static SampleModel
  194.         createPixelInterleavedSampleModel(int dataType,
  195.                                           int tileWidth,
  196.                                           int tileHeight,
  197.                                           int pixelStride,
  198.                                           int scanlineStride,
  199.                                           int bandOffsets[]) {
  200.         SampleModel sampleModel = null;
  202.         if(dataType == DataBuffer.TYPE_FLOAT) {
  203.             // This is a hack to make this work with JAI which in some
  204.             // cases downcasts the DataBuffer to a type-specific class.
  205.             // In the case of float data this current means the JAI class
  206.             // javax.media.jai.DataBufferFloat.
  207.             try {
  208.                 Class rfClass =
  209.                     Class.forName("javax.media.jai.RasterFactory");
  210.                 Class[] paramTypes = new Class[] {int.class, int.class, 
  211.                                                   int.class, int.class,
  212.                                                   int.class, int[].class};
  213.                 Method rfMthd =
  214.                     rfClass.getMethod("createPixelInterleavedSampleModel",
  215.                                       paramTypes);
  216.                 Object[] params =
  217.                     new Object[] {new Integer(dataType),
  218.                                   new Integer(tileWidth),
  219.                                   new Integer(tileHeight),
  220.                                   new Integer(pixelStride),
  221.                                   new Integer(scanlineStride),
  222.                                   bandOffsets};
  223.                 sampleModel = (SampleModel)rfMthd.invoke(null, params);
  224.             } catch(Exception e) {
  225.                 // Deliberately ignore the Exception.
  226.             }
  227.         }
  229.         // Create a SampleModel for non-float data or, in the case of
  230.         // float data, if it is still null. This latter case should occur
  231.         // if and only if the decoder is being used without JAI.
  232.         if(dataType != DataBuffer.TYPE_FLOAT || sampleModel == null) {
  233.             sampleModel =
  234.                 RasterFactory.createPixelInterleavedSampleModel(dataType,
  235.                                                                 tileWidth,
  236.                                                                 tileHeight,
  237.                                                                 pixelStride,
  238.                                                                 scanlineStride,
  239.                                                                 bandOffsets);
  240.         }
  242.         return sampleModel;
  243.     }
  245.     /**
  246.      * Return as a long[] the value of a TIFF_LONG or TIFF_SHORT field.
  247.      */
  248.     private final long[] getFieldAsLongs(TIFFField field) {
  249.         long[] value = null;
  251.         if(field.getType() == TIFFField.TIFF_SHORT) {
  252.             char[] charValue = field.getAsChars();
  253.             value = new long[charValue.length];
  254.             for(int i = 0; i < charValue.length; i++) {
  255.                 value[i] = charValue[i]  & 0xffff;
  256.             }
  257.         } else if(field.getType() == TIFFField.TIFF_LONG) {
  258.             value = field.getAsLongs();
  259.         } else {
  260.             throw new RuntimeException();
  261.         }
  263.         return value;
  264.     }
  266.     /**
  267.      * Constructs a TIFFImage that acquires its data from a given
  268.      * SeekableStream and reads from a particular IFD of the stream.
  269.      * The index of the first IFD is 0.
  270.      *
  271.      * @param stream the SeekableStream to read from.
  272.      * @param param an instance of TIFFDecodeParam, or null.
  273.      * @param directory the index of the IFD to read from.
  274.      */
  275.     public TIFFImage(SeekableStream stream,
  276.                      TIFFDecodeParam param,
  277.                      int directory)
  278.         throws IOException {
  280.         this.stream = stream;
  281. if (param == null) {
  282.     param = new TIFFDecodeParam();
  283. } 
  285. decodePaletteAsShorts = param.getDecodePaletteAsShorts();
  287.         // Read the specified directory.
  288.         TIFFDirectory dir = param.getIFDOffset() == null ?
  289.             new TIFFDirectory(stream, directory) :
  290.             new TIFFDirectory(stream, param.getIFDOffset().longValue(),
  291.                               directory);
  293.         // Set a property "tiff_directory".
  294.         properties.put("tiff_directory", dir);
  296. // Get the number of samples per pixel
  297. TIFFField sfield = dir.getField(TIFFImageDecoder.TIFF_SAMPLES_PER_PIXEL);
  298.         int samplesPerPixel = sfield == null ? 1 : (int)sfield.getAsLong(0);
  300. // Read the TIFF_PLANAR_CONFIGURATION field
  301. TIFFField planarConfigurationField = 
  302.     dir.getField(TIFFImageDecoder.TIFF_PLANAR_CONFIGURATION);
  303. char[] planarConfiguration = planarConfigurationField == null ?
  304.             new char[] {1} :
  305.             planarConfigurationField.getAsChars();
  307.         // Support planar format (band sequential) only for 1 sample/pixel.
  308.         if (planarConfiguration[0] != 1 && samplesPerPixel != 1) {
  309.             throw new RuntimeException(JaiI18N.getString("TIFFImage0"));
  310.         }
  312. // Read the TIFF_BITS_PER_SAMPLE field
  313. TIFFField bitsField = 
  314.     dir.getField(TIFFImageDecoder.TIFF_BITS_PER_SAMPLE);
  315.         char[] bitsPerSample = null;
  316.         if(bitsField != null) {
  317.             bitsPerSample = bitsField.getAsChars();
  318.         } else {
  319.             bitsPerSample = new char[] {1};
  321.             // Ensure that all samples have the same bit depth.
  322.             for (int i = 1; i < bitsPerSample.length; i++) {
  323.                 if (bitsPerSample[i] != bitsPerSample[0]) {
  324.                     throw new RuntimeException(JaiI18N.getString("TIFFImage1"));
  325.                 }
  326.             }
  327.         }
  328.         sampleSize = (int)bitsPerSample[0];
  330. // Read the TIFF_SAMPLE_FORMAT tag to see whether the data might be
  331. // signed or floating point
  332. TIFFField sampleFormatField = 
  333.     dir.getField(TIFFImageDecoder.TIFF_SAMPLE_FORMAT);
  335.         char[] sampleFormat = null;
  336. if (sampleFormatField != null) {
  337.     sampleFormat = sampleFormatField.getAsChars();
  339.     // Check that all the samples have the same format
  340.     for (int l=1; l<sampleFormat.length; l++) {
  341. if (sampleFormat[l] != sampleFormat[0]) {
  342.     throw new RuntimeException(JaiI18N.getString("TIFFImage2"));
  343. }
  344.     }
  346. } else {
  347.     sampleFormat = new char[] {1};
  348. }
  350.         // Set the data type based on the sample size and format.
  351.         boolean isValidDataFormat = false;
  352.         switch(sampleSize) {
  353.         case 1:
  354.         case 4:
  355.         case 8:
  356.             if(sampleFormat[0] != 3) {
  357.                 // Ignore whether signed or unsigned: treat all as unsigned.
  358. dataType = DataBuffer.TYPE_BYTE;
  359.                 isValidDataFormat = true;
  360.             }
  361.             break;
  362.         case 16:
  363.             if(sampleFormat[0] != 3) {
  364.                 dataType = sampleFormat[0] == 2 ?
  365.                     DataBuffer.TYPE_SHORT : DataBuffer.TYPE_USHORT;
  366.                 isValidDataFormat = true;
  367.             }
  368.             break;
  369.         case 32:
  370.             dataType = sampleFormat[0] == 3 ?
  371.                 DataBuffer.TYPE_FLOAT : DataBuffer.TYPE_INT;
  372.             isValidDataFormat = true;
  373.             break;
  374.         }
  376.         if(!isValidDataFormat) {
  377.             throw new RuntimeException(JaiI18N.getString("TIFFImage3"));
  378.         }
  380. // Figure out what compression if any, is being used.
  381. TIFFField compField = dir.getField(TIFFImageDecoder.TIFF_COMPRESSION);
  382.         compression = compField == null ? COMP_NONE : compField.getAsInt(0);
  384.         // Get the photometric interpretation.
  385. int photometricType = (int)dir.getFieldAsLong(
  386.       TIFFImageDecoder.TIFF_PHOTOMETRIC_INTERPRETATION);
  388. // Determine which kind of image we are dealing with.
  389.         imageType = TYPE_UNSUPPORTED;
  390. switch(photometricType) {
  391.         case 0: // WhiteIsZero
  392.             isWhiteZero = true;
  393.         case 1: // BlackIsZero
  394.             if(sampleSize == 1 && samplesPerPixel == 1) {
  395.                 imageType = TYPE_BILEVEL;
  396.             } else if(sampleSize == 4 && samplesPerPixel == 1) {
  397.                 imageType = TYPE_GRAY_4BIT;
  398.             } else if(sampleSize % 8 == 0) {
  399.                 if(samplesPerPixel == 1) {
  400.                     imageType = TYPE_GRAY;
  401.                 } else if(samplesPerPixel == 2) {
  402.                     imageType = TYPE_GRAY_ALPHA;
  403.                 } else {
  404.                     imageType = TYPE_GENERIC;
  405.                 }
  406.             }
  407.             break;
  408.         case 2: // RGB
  409.             if(sampleSize % 8 == 0) {
  410.                 if(samplesPerPixel == 3) {
  411.                     imageType = TYPE_RGB;
  412.                 } else if(samplesPerPixel == 4) {
  413.                     imageType = TYPE_RGB_ALPHA;
  414.                 } else {
  415.                     imageType = TYPE_GENERIC;
  416.                 }
  417.             }
  418.             break;
  419.         case 3: // RGB Palette
  420.             if(samplesPerPixel == 1 &&
  421.                (sampleSize == 4 || sampleSize == 8 || sampleSize == 16)) {
  422.                 imageType = TYPE_PALETTE;
  423.             }
  424.             break;
  425.         case 4: // Transparency mask
  426.             if(sampleSize == 1 && samplesPerPixel == 1) {
  427.                 imageType = TYPE_BILEVEL;
  428.             }
  429.             break;
  430.         case 6: // YCbCr
  431.             if(compression == COMP_JPEG_TTN2 &&
  432.                sampleSize == 8 && samplesPerPixel == 3) {
  433.                 // Set color conversion flag.
  434.                 colorConvertJPEG = param.getJPEGDecompressYCbCrToRGB();
  436.                 // Set type to RGB if color converting.
  437.                 imageType = colorConvertJPEG ? TYPE_RGB : TYPE_GENERIC;
  438.             } else {
  439.                 TIFFField chromaField = dir.getField(TIFF_YCBCR_SUBSAMPLING);
  440.                 if(chromaField != null) {
  441.                     chromaSubH = chromaField.getAsInt(0);
  442.                     chromaSubV = chromaField.getAsInt(1);
  443.                 } else {
  444.                     chromaSubH = chromaSubV = 2;
  445.                 }
  447.                 if(chromaSubH*chromaSubV == 1) {
  448.                     imageType = TYPE_GENERIC;
  449.                 } else if(sampleSize == 8 && samplesPerPixel == 3) {
  450.                     imageType = TYPE_YCBCR_SUB;
  451.                 }
  452.             }
  453.             break;
  454.         default: // Other including CMYK, CIE L*a*b*, unknown.
  455.             if(sampleSize % 8 == 0) {
  456.                 imageType = TYPE_GENERIC;
  457.             }
  458.         }
  460.         // Bail out if not one of the supported types.
  461.         if(imageType == TYPE_UNSUPPORTED) {
  462.             throw new RuntimeException(JaiI18N.getString("TIFFImage4"));
  463.         }
  465. // Set basic image layout        
  466.         minX = minY = 0;
  467.         width = (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_IMAGE_WIDTH);
  468.         height = (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_IMAGE_LENGTH);
  470.         // Set a preliminary band count. This may be changed later as needed.
  471.         numBands = samplesPerPixel;
  473. // Figure out if any extra samples are present.
  474. TIFFField efield = dir.getField(TIFFImageDecoder.TIFF_EXTRA_SAMPLES);
  475.         int extraSamples = efield == null ? 0 : (int)efield.getAsLong(0);
  477. if (dir.getField(TIFFImageDecoder.TIFF_TILE_OFFSETS) != null) {
  478.     // Image is in tiled format
  479.             tileWidth = 
  480. (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_TILE_WIDTH);
  481.             tileHeight = 
  482. (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_TILE_LENGTH);
  483.     tileOffsets = 
  484. (dir.getField(TIFFImageDecoder.TIFF_TILE_OFFSETS)).getAsLongs();
  485.     tileByteCounts = 
  486.        getFieldAsLongs(dir.getField(TIFFImageDecoder.TIFF_TILE_BYTE_COUNTS));
  488.         } else {
  490.             // Image is in stripped format, looks like tiles to us
  491.             // Note: Some legacy files may have tile width and height
  492.             // written but use the strip offsets and byte counts fields
  493.             // instead of the tile offsets and byte counts. Therefore
  494.             // we default here to the tile dimensions if they are written.
  495.             tileWidth =
  496.                 dir.getField(TIFFImageDecoder.TIFF_TILE_WIDTH) != null ?
  497.                 (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_TILE_WIDTH) :
  498.                 width;
  499.     TIFFField field =
  500.                 dir.getField(TIFFImageDecoder.TIFF_ROWS_PER_STRIP);
  501.     if (field == null) {
  502. // Default is infinity (2^32 -1), basically the entire image
  504. tileHeight =
  505.                     dir.getField(TIFFImageDecoder.TIFF_TILE_LENGTH) != null ?
  506.                     (int)dir.getFieldAsLong(TIFFImageDecoder.TIFF_TILE_LENGTH):
  507.                     height;
  508.     } else {
  509. long l = field.getAsLong(0);
  510. long infinity = 1;
  511. infinity = (infinity << 32) - 1;
  512. if (l == infinity) {   
  513.     // 2^32 - 1 (effectively infinity, entire image is 1 strip)
  514.     tileHeight = height;
  515. } else {
  516.     tileHeight = (int)l;
  517. }
  518.     }
  520.     TIFFField tileOffsetsField = 
  521. dir.getField(TIFFImageDecoder.TIFF_STRIP_OFFSETS);
  522.     if (tileOffsetsField == null) {
  523. throw new RuntimeException(JaiI18N.getString("TIFFImage5"));
  524.     } else {
  525. tileOffsets = getFieldAsLongs(tileOffsetsField);
  526.     }
  528.     TIFFField tileByteCountsField = 
  529. dir.getField(TIFFImageDecoder.TIFF_STRIP_BYTE_COUNTS);
  530.     if (tileByteCountsField == null) {
  531. throw new RuntimeException(JaiI18N.getString("TIFFImage6"));
  532.     } else {
  533. tileByteCounts = getFieldAsLongs(tileByteCountsField);
  534.     }
  535. }
  537. // Calculate number of tiles and the tileSize in bytes
  538.         tilesX = (width + tileWidth - 1)/tileWidth;
  539.         tilesY = (height + tileHeight - 1)/tileHeight;
  540.         tileSize = tileWidth * tileHeight * numBands;
  542. // Check whether big endian or little endian format is used.
  543. isBigEndian = dir.isBigEndian();
  545. TIFFField fillOrderField = 
  546.     dir.getField(TIFFImageDecoder.TIFF_FILL_ORDER);
  547. if (fillOrderField != null) {
  548.     fillOrder = fillOrderField.getAsInt(0);
  549. } else {
  550.     // Default Fill Order
  551.     fillOrder = 1;
  552. }
  554. switch(compression) {
  555.         case COMP_NONE:
  556.         case COMP_PACKBITS:
  557.             // Do nothing.
  558.             break;
  559.         case COMP_DEFLATE:
  560.             inflater = new Inflater();
  561.             break;
  562.         case COMP_FAX_G3_1D:
  563.         case COMP_FAX_G3_2D:
  564.         case COMP_FAX_G4_2D:
  565.             if(sampleSize != 1) {
  566.                 throw new RuntimeException(JaiI18N.getString("TIFFImage7")); 
  567.             }
  569.             // Fax T.4 compression options
  570.             if (compression == 3) {
  571.                 TIFFField t4OptionsField = 
  572.                     dir.getField(TIFFImageDecoder.TIFF_T4_OPTIONS);
  573.                 if (t4OptionsField != null) {
  574.                     tiffT4Options = t4OptionsField.getAsLong(0);
  575.                 } else {
  576.                     // Use default value
  577.                     tiffT4Options = 0;
  578.                 }
  579.             }
  581.             // Fax T.6 compression options
  582.             if (compression == 4) {
  583.                 TIFFField t6OptionsField =
  584.                     dir.getField(TIFFImageDecoder.TIFF_T6_OPTIONS);
  585.                 if (t6OptionsField != null) {
  586.                     tiffT6Options = t6OptionsField.getAsLong(0);
  587.                 } else {
  588.                     // Use default value
  589.                     tiffT6Options = 0;
  590.                 }
  591.             }
  593.             // Fax encoding, need to create the Fax decoder.
  594.             decoder = new TIFFFaxDecoder(fillOrder,
  595.                                          tileWidth, tileHeight);
  596.             break;
  598.         case COMP_LZW:
  599.             // LZW compression used, need to create the LZW decoder.
  600.             TIFFField predictorField = 
  601.                 dir.getField(TIFFImageDecoder.TIFF_PREDICTOR);
  603.             if (predictorField == null) {
  604.                 predictor = 1;
  605.             } else {
  606.                 predictor = predictorField.getAsInt(0);
  607.     
  608.                 if (predictor != 1 && predictor != 2) {
  609.                     throw new RuntimeException(JaiI18N.getString("TIFFImage8")); 
  610.                 }
  611.     
  612.                 if (predictor == 2 && sampleSize != 8) {
  613.                     throw new RuntimeException(sampleSize + 
  614.                                                JaiI18N.getString("TIFFImage9"));
  615.                 }
  616.             }
  618.             lzwDecoder = new TIFFLZWDecoder(tileWidth, predictor, 
  619.                                             samplesPerPixel); 
  620.             break;
  622.         case COMP_JPEG_OLD:
  623.             throw new RuntimeException(JaiI18N.getString("TIFFImage15"));
  625.         case COMP_JPEG_TTN2:
  626.             if(!(sampleSize == 8 &&
  627.                  ((imageType == TYPE_GRAY && samplesPerPixel == 1) ||
  628.                   (imageType == TYPE_PALETTE && samplesPerPixel == 1) ||
  629.                   (imageType == TYPE_RGB && samplesPerPixel == 3)))) {
  630.                 throw new RuntimeException(JaiI18N.getString("TIFFImage16"));
  631.             }
  633.             // Create decodeParam from JPEGTables field if present.
  634.             if(dir.isTagPresent(TIFF_JPEG_TABLES)) {
  635.                 TIFFField jpegTableField = dir.getField(TIFF_JPEG_TABLES);
  636.                 byte[] jpegTable = jpegTableField.getAsBytes();
  637.                 ByteArrayInputStream tableStream =
  638.                     new ByteArrayInputStream(jpegTable);
  639.                 JPEGImageDecoder decoder =
  640.                     JPEGCodec.createJPEGDecoder(tableStream);
  641.                 decoder.decodeAsRaster();
  642.                 decodeParam = decoder.getJPEGDecodeParam();
  643.             }
  645.             break;
  646.         default:
  647.             throw new RuntimeException(JaiI18N.getString("TIFFImage10"));
  648. }
  650.         switch(imageType) {
  651.         case TYPE_BILEVEL:
  652.         case TYPE_GRAY_4BIT:
  653.             sampleModel = 
  654.                 new MultiPixelPackedSampleModel(dataType,
  655.                                                 tileWidth, 
  656.                                                 tileHeight,
  657.                                                 sampleSize);
  658.             if(imageType == TYPE_BILEVEL) {
  659.                 byte[] map = new byte[] {(byte)(isWhiteZero ? 255 : 0),
  660.                                          (byte)(isWhiteZero ? 0 : 255)};
  661. colorModel = new IndexColorModel(1, 2, map, map, map);
  662.             } else {
  663.                 colorModel = 
  664.                     ImageCodec.createGrayIndexColorModel(sampleModel,
  665.                                                          !isWhiteZero);
  666.             }
  667.             break;
  669.         case TYPE_GRAY:
  670.         case TYPE_GRAY_ALPHA:
  671.         case TYPE_RGB:
  672.         case TYPE_RGB_ALPHA:
  673.             // Create a pixel interleaved SampleModel with decreasing
  674.             // band offsets.
  675.             int[] reverseOffsets = new int[numBands];
  676.             for (int i=0; i<numBands; i++) {
  677.                 reverseOffsets[i] = numBands - 1 - i;
  678.             }
  679.             sampleModel = createPixelInterleavedSampleModel(dataType,
  680.                                                             tileWidth,
  681.                                                             tileHeight,
  682.                                                             numBands,
  683.                                                             numBands*tileWidth,
  684.                                                             reverseOffsets);
  686.             if(imageType == TYPE_GRAY || imageType == TYPE_RGB) {
  687.                 colorModel =
  688.                     ImageCodec.createComponentColorModel(sampleModel);
  689.             } else { // hasAlpha
  690.                 // Transparency.OPAQUE signifies image data that is 
  691.                 // completely opaque, meaning that all pixels have an alpha
  692.                 // value of 1.0. So the extra band gets ignored, which is
  693.                 // what we want.
  694.                 int transparency = Transparency.OPAQUE;
  695.                 if(extraSamples == 1) { // associated (premultiplied) alpha
  696.                     transparency = Transparency.TRANSLUCENT;
  697.                 } else if(extraSamples == 2) { // unassociated alpha
  698.                     transparency = Transparency.BITMASK;
  699.                 }
  701.                 colorModel =
  702.                     createAlphaComponentColorModel(dataType,
  703.                                                    numBands,
  704.                                                    extraSamples == 1,
  705.    transparency);
  706.             }
  707.             break;
  709.         case TYPE_GENERIC:
  710.         case TYPE_YCBCR_SUB:
  711.             // For this case we can't display the image, so we create a
  712.             // SampleModel with increasing bandOffsets, and keep the
  713.             // ColorModel as null, as there is no appropriate ColorModel.
  715.             int[] bandOffsets = new int[numBands];
  716.             for (int i=0; i<numBands; i++) {
  717.                 bandOffsets[i] = i;
  718.             }
  720.             sampleModel =
  721.                 createPixelInterleavedSampleModel(dataType,
  722.                                                   tileWidth, tileHeight,
  723.                                                   numBands, numBands * tileWidth,
  724.                                                   bandOffsets);
  725.             colorModel = null;
  726.             break;
  728.         case TYPE_PALETTE:
  729.     // Get the colormap
  730.     TIFFField cfield = dir.getField(TIFFImageDecoder.TIFF_COLORMAP);
  731.     if (cfield == null) {
  732. throw new RuntimeException(JaiI18N.getString("TIFFImage11"));
  733.     } else {
  734. colormap = cfield.getAsChars();
  735.     }
  737.     // Could be either 1 or 3 bands depending on whether we use
  738.     // IndexColorModel or not.
  739.     if (decodePaletteAsShorts) {
  740. numBands = 3;
  742. // If no SampleFormat tag was specified and if the 
  743. // sampleSize is less than or equal to 8, then the 
  744. // dataType was initially set to byte, but now we want to 
  745. // expand the palette as shorts, so the dataType should 
  746. // be ushort.
  747. if (dataType == DataBuffer.TYPE_BYTE) {
  748.     dataType = DataBuffer.TYPE_USHORT;
  749. }
  751. // Data will have to be unpacked into a 3 band short image
  752. // as we do not have a IndexColorModel that can deal with
  753. // a colormodel whose entries are of short data type.
  754. sampleModel = 
  755.     RasterFactory.createPixelInterleavedSampleModel(dataType,
  756.     tileWidth,
  757.     tileHeight, 
  758.     numBands);
  759. colorModel = ImageCodec.createComponentColorModel(sampleModel);
  761.     } else {
  763. numBands = 1;
  765. if (sampleSize == 4) {
  766.     // Pixel data will not be unpacked, will use MPPSM to store 
  767.     // packed data and IndexColorModel to do the unpacking.
  768.     sampleModel = 
  769. new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, 
  770. tileWidth, 
  771. tileHeight, 
  772. sampleSize);
  773. } else if (sampleSize == 8) {
  774.     sampleModel =
  775. RasterFactory.createPixelInterleavedSampleModel(
  776.     DataBuffer.TYPE_BYTE,
  777.     tileWidth,
  778.     tileHeight,
  779.     numBands);
  780. } else if (sampleSize == 16) {
  782.     // Here datatype has to be unsigned since we are storing
  783.     // indices into the IndexColorModel palette. Ofcourse
  784.     // the actual palette entries are allowed to be negative.
  785.                     dataType = DataBuffer.TYPE_USHORT;
  786.     sampleModel =
  787. RasterFactory.createPixelInterleavedSampleModel(
  788. DataBuffer.TYPE_USHORT,
  789. tileWidth,
  790. tileHeight,
  791. numBands);
  792. }
  794. int bandLength = colormap.length/3;
  795. byte r[] = new byte[bandLength];
  796. byte g[] = new byte[bandLength];
  797. byte b[] = new byte[bandLength];
  799. int gIndex = bandLength;
  800. int bIndex = bandLength * 2;
  802. if (dataType == DataBuffer.TYPE_SHORT) {
  804.     for (int i=0; i<bandLength; i++) {
  805. r[i] = param.decodeSigned16BitsTo8Bits(
  806.        (short)colormap[i]);
  807. g[i] = param.decodeSigned16BitsTo8Bits(
  808.      (short)colormap[gIndex+i]);
  809. b[i] = param.decodeSigned16BitsTo8Bits(
  810.      (short)colormap[bIndex+i]);
  811.     }
  813. } else {
  815.     for (int i=0; i<bandLength; i++) {
  816. r[i] = param.decode16BitsTo8Bits(colormap[i] & 0xffff);
  817. g[i] = param.decode16BitsTo8Bits(colormap[gIndex+i] & 
  818.  0xffff);
  819. b[i] = param.decode16BitsTo8Bits(colormap[bIndex+i] & 
  820.  0xffff);
  821.     }
  822.     
  823. }
  825. colorModel = new IndexColorModel(sampleSize, 
  826.  bandLength, r, g, b);
  827.     }
  828.             break;
  830.         default:
  831.             throw new RuntimeException("TIFFImage4");
  832.         }
  833.     }
  835.     /**
  836.      * Reads a private IFD from a given offset in the stream.  This
  837.      * method may be used to obtain IFDs that are referenced
  838.      * only by private tag values.
  839.      */
  840.     public TIFFDirectory getPrivateIFD(long offset) throws IOException {
  841.         return new TIFFDirectory(stream, offset, 0);
  842.     }
  844.     /**
  845.      * Returns tile (tileX, tileY) as a Raster.
  846.      */
  847.     public synchronized Raster getTile(int tileX, int tileY) {
  848.         if ((tileX < 0) || (tileX >= tilesX) ||
  849.             (tileY < 0) || (tileY >= tilesY)) {
  850.             throw new IllegalArgumentException(JaiI18N.getString("TIFFImage12"));
  851.         }
  853. // Get the data array out of the DataBuffer
  854. byte bdata[] = null;
  855. short sdata[] = null;
  856. int idata[] = null;
  857. float fdata[] = null;
  858. DataBuffer buffer = sampleModel.createDataBuffer();
  860. int dataType = sampleModel.getDataType();
  861. if (dataType == DataBuffer.TYPE_BYTE) {
  862.     bdata = ((DataBufferByte)buffer).getData();
  863. } else if (dataType == DataBuffer.TYPE_USHORT) {
  864.     sdata = ((DataBufferUShort)buffer).getData();
  865. } else if (dataType == DataBuffer.TYPE_SHORT) {
  866.     sdata = ((DataBufferShort)buffer).getData();
  867. } else if (dataType == DataBuffer.TYPE_INT) {
  868.     idata = ((DataBufferInt)buffer).getData();
  869. } else if (dataType == DataBuffer.TYPE_FLOAT) {
  870.             if(buffer instanceof DataBufferFloat) {
  871.                 fdata = ((DataBufferFloat)buffer).getData();
  872.             } else {
  873.                 // This is a hack to make this work with JAI which in some
  874.                 // cases downcasts the DataBuffer to a type-specific class.
  875.                 // In the case of float data this current means the JAI class
  876.                 // javax.media.jai.DataBufferFloat.
  877.                 try {
  878.                     Method getDataMethod =
  879.                         buffer.getClass().getMethod("getData", null);
  880.                     fdata = (float[])getDataMethod.invoke(buffer, null);
  881.                 } catch(Exception e) {
  882.                     throw new RuntimeException(JaiI18N.getString("TIFFImage18"));
  883.                 }
  884.             }
  885. }
  887.         WritableRaster tile = 
  888.     (WritableRaster)RasterFactory.createWritableRaster(sampleModel,
  889.                                                    buffer,
  890.                                                    new Point(tileXToX(tileX),
  891.                                                              tileYToY(tileY)));
  893. // Variables used for swapping when converting from RGB to BGR
  894. byte bswap;
  895. short sswap;
  896.         int iswap;
  897.         float fswap;
  899. // Save original file pointer position and seek to tile data location.
  900. long save_offset = 0;
  901. try {
  902.     save_offset = stream.getFilePointer();
  903.     stream.seek(tileOffsets[tileY*tilesX + tileX]);
  904. } catch (IOException ioe) {
  905.     throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  906. }
  908. // Number of bytes in this tile (strip) after compression.
  909. int byteCount = (int)tileByteCounts[tileY*tilesX + tileX];
  911. // Find out the number of bytes in the current tile
  912. Rectangle tileRect = new Rectangle(tileXToX(tileX), tileYToY(tileY),
  913.    tileWidth, tileHeight);
  914. Rectangle newRect = tileRect.intersection(getBounds());
  915.         int unitsInThisTile = newRect.width * newRect.height * numBands;
  917.         // Allocate read buffer if needed.
  918. byte data[] = compression != COMP_NONE || imageType == TYPE_PALETTE ?
  919.             new byte[byteCount] : null;
  921.         // Read the data, uncompressing as needed. There are four cases:
  922.         // bilevel, palette-RGB, 4-bit grayscale, and everything else.
  923.         if(imageType == TYPE_BILEVEL) { // bilevel
  924.     try {
  925. if (compression == COMP_PACKBITS) {
  926.     stream.readFully(data, 0, byteCount);
  928.     // Since the decompressed data will still be packed 
  929.     // 8 pixels into 1 byte, calculate bytesInThisTile
  930.     int bytesInThisTile;
  931.     if ((newRect.width % 8) == 0) {
  932. bytesInThisTile = (newRect.width/8) * newRect.height;
  933.     } else {
  934. bytesInThisTile =
  935.                             (newRect.width/8 + 1) * newRect.height;
  936.     }
  937.     decodePackbits(data, bytesInThisTile, bdata);
  938. } else if (compression == COMP_LZW) {
  939.     stream.readFully(data, 0, byteCount);
  940.     lzwDecoder.decode(data, bdata, newRect.height);
  941. } else if (compression == COMP_FAX_G3_1D) {
  942.     stream.readFully(data, 0, byteCount);
  943.     decoder.decode1D(bdata, data, 0, newRect.height);
  944. } else if (compression == COMP_FAX_G3_2D) {
  945.     stream.readFully(data, 0, byteCount);
  946.     decoder.decode2D(bdata, data, 0, newRect.height,
  947.                                      tiffT4Options);
  948. } else if (compression == COMP_FAX_G4_2D) {
  949.     stream.readFully(data, 0, byteCount);
  950.                     decoder.decodeT6(bdata, data, 0, newRect.height,
  951.                                      tiffT6Options);
  952. } else if (compression == COMP_DEFLATE) {
  953.                     stream.readFully(data, 0, byteCount);
  954.                     inflate(data, bdata);
  955. } else if (compression == COMP_NONE) {
  956.     stream.readFully(bdata, 0, byteCount);
  957. }
  959. stream.seek(save_offset);
  960.     } catch (IOException ioe) {
  961. throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  962.     }
  963.         } else if(imageType == TYPE_PALETTE) { // palette-RGB
  964.     if (sampleSize == 16) {
  966. if (decodePaletteAsShorts) {
  967.     
  968.     short tempData[]= null;
  969.          
  970.     // At this point the data is 1 banded and will
  971.     // become 3 banded only after we've done the palette
  972.     // lookup, since unitsInThisTile was calculated with
  973.     // 3 bands, we need to divide this by 3.
  974.     int unitsBeforeLookup = unitsInThisTile / 3;
  975.     
  976.     // Since unitsBeforeLookup is the number of shorts, 
  977.     // but we do our decompression in terms of bytes, we 
  978.     // need to multiply it by 2 in order to figure out
  979.     // how many bytes we'll get after decompression.
  980.     int entries = unitsBeforeLookup * 2;
  981.     
  982.     // Read the data, if compressed, decode it, reset the pointer
  983.     try {
  985. if (compression == COMP_PACKBITS) {
  987.     stream.readFully(data, 0, byteCount);
  988.     
  989.     byte byteArray[] = new byte[entries];
  990.     decodePackbits(data, entries, byteArray);
  991.     tempData = new short[unitsBeforeLookup];
  992.     interpretBytesAsShorts(byteArray, tempData,
  993.    unitsBeforeLookup);
  994.     
  995. }  else if (compression == COMP_LZW) {
  997.     // Read in all the compressed data for this tile
  998.     stream.readFully(data, 0, byteCount);
  1000.     byte byteArray[] = new byte[entries];
  1001.     lzwDecoder.decode(data, byteArray, newRect.height);
  1002.     tempData = new short[unitsBeforeLookup];
  1003.     interpretBytesAsShorts(byteArray, tempData,
  1004.    unitsBeforeLookup);
  1006. }  else if (compression == COMP_DEFLATE) {
  1008.     stream.readFully(data, 0, byteCount);
  1009.     byte byteArray[] = new byte[entries];
  1010.     inflate(data, byteArray);
  1011.     tempData = new short[unitsBeforeLookup];
  1012.     interpretBytesAsShorts(byteArray, tempData,
  1013.    unitsBeforeLookup);
  1015. } else if (compression == COMP_NONE) {
  1017.     // byteCount tells us how many bytes are there
  1018.     // in this tile, but we need to read in shorts, 
  1019.     // which will take half the space, so while
  1020.     // allocating we divide byteCount by 2.
  1021.     tempData = new short[byteCount/2];
  1022.     readShorts(byteCount/2, tempData);
  1023. }
  1025. stream.seek(save_offset);
  1027.     } catch (IOException ioe) {
  1028. throw new RuntimeException(
  1029. JaiI18N.getString("TIFFImage13"));
  1030.     }
  1032.     if (dataType == DataBuffer.TYPE_USHORT) {
  1034. // Expand the palette image into an rgb image with ushort
  1035. // data type.
  1036. int cmapValue; 
  1037. int count = 0, lookup, len = colormap.length/3;
  1038. int len2 = len * 2;
  1039. for (int i=0; i<unitsBeforeLookup; i++) {
  1040.     // Get the index into the colormap
  1041.     lookup = tempData[i] & 0xffff;
  1042.     // Get the blue value 
  1043.     cmapValue = colormap[lookup+len2];
  1044.     sdata[count++] = (short)(cmapValue & 0xffff);
  1045.     // Get the green value
  1046.     cmapValue = colormap[lookup+len];
  1047.     sdata[count++] = (short)(cmapValue & 0xffff);
  1048.     // Get the red value
  1049.     cmapValue = colormap[lookup];
  1050.     sdata[count++] = (short)(cmapValue & 0xffff);
  1051. }
  1053.     } else if (dataType == DataBuffer.TYPE_SHORT) {
  1055. // Expand the palette image into an rgb image with 
  1056. // short data type.
  1057. int cmapValue; 
  1058. int count = 0, lookup, len = colormap.length/3;
  1059. int len2 = len * 2;
  1060. for (int i=0; i<unitsBeforeLookup; i++) {
  1061.     // Get the index into the colormap
  1062.     lookup = tempData[i] & 0xffff;
  1063.     // Get the blue value 
  1064.     cmapValue = colormap[lookup+len2];
  1065.     sdata[count++] = (short)cmapValue;
  1066.     // Get the green value
  1067.     cmapValue = colormap[lookup+len];
  1068.     sdata[count++] = (short)cmapValue;
  1069.     // Get the red value
  1070.     cmapValue = colormap[lookup];
  1071.     sdata[count++] = (short)cmapValue;
  1072. }
  1073.     }
  1075. } else {
  1076.     
  1077.     // No lookup being done here, when RGB values are needed,
  1078.     // the associated IndexColorModel can be used to get them.
  1079.     
  1080.     try {
  1082. if (compression == COMP_PACKBITS) {
  1084.     stream.readFully(data, 0, byteCount);
  1086.     // Since unitsInThisTile is the number of shorts, 
  1087.     // but we do our decompression in terms of bytes, we 
  1088.     // need to multiply unitsInThisTile by 2 in order to 
  1089.     // figure out how many bytes we'll get after 
  1090.     // decompression.
  1091.     int bytesInThisTile = unitsInThisTile * 2;
  1093.     byte byteArray[] = new byte[bytesInThisTile];
  1094.     decodePackbits(data, bytesInThisTile, byteArray);
  1095.     interpretBytesAsShorts(byteArray, sdata,
  1096.    unitsInThisTile);
  1097.     
  1098. } else if (compression == COMP_LZW) {
  1099.     
  1100.     stream.readFully(data, 0, byteCount);
  1102.     // Since unitsInThisTile is the number of shorts, 
  1103.     // but we do our decompression in terms of bytes, we 
  1104.     // need to multiply unitsInThisTile by 2 in order to 
  1105.     // figure out how many bytes we'll get after 
  1106.     // decompression.
  1107.     byte byteArray[] = new byte[unitsInThisTile * 2];
  1108.     lzwDecoder.decode(data, byteArray, newRect.height);
  1109.     interpretBytesAsShorts(byteArray, sdata, 
  1110.    unitsInThisTile);
  1112. }  else if (compression == COMP_DEFLATE) {
  1114.     stream.readFully(data, 0, byteCount);
  1115.     byte byteArray[] = new byte[unitsInThisTile * 2];
  1116.     inflate(data, byteArray);
  1117.     interpretBytesAsShorts(byteArray, sdata, 
  1118.    unitsInThisTile);
  1120. } else if (compression == COMP_NONE) {
  1122.     readShorts(byteCount/2, sdata);
  1123. }
  1125. stream.seek(save_offset);
  1127.     } catch (IOException ioe) {
  1128. throw new RuntimeException(
  1129. JaiI18N.getString("TIFFImage13"));
  1130.     }     
  1131. }
  1133.     } else if (sampleSize == 8) {
  1135. if (decodePaletteAsShorts) {
  1136.     
  1137.     byte tempData[]= null;
  1139.     // At this point the data is 1 banded and will
  1140.     // become 3 banded only after we've done the palette
  1141.     // lookup, since unitsInThisTile was calculated with
  1142.     // 3 bands, we need to divide this by 3.
  1143.     int unitsBeforeLookup = unitsInThisTile / 3;
  1144.     
  1145.     // Read the data, if compressed, decode it, reset the pointer
  1146.     try {
  1148. if (compression == COMP_PACKBITS) {
  1149.     
  1150.     stream.readFully(data, 0, byteCount);
  1151.     tempData = new byte[unitsBeforeLookup];
  1152.     decodePackbits(data, unitsBeforeLookup, tempData);
  1153.     
  1154. }  else if (compression == COMP_LZW) {
  1155.     
  1156.     stream.readFully(data, 0, byteCount);
  1157.     tempData = new byte[unitsBeforeLookup];
  1158.     lzwDecoder.decode(data, tempData, newRect.height);
  1159.     
  1160.                         } else if (compression == COMP_JPEG_TTN2) {
  1162.                             stream.readFully(data, 0, byteCount);
  1163.                             Raster tempTile = decodeJPEG(data,
  1164.                                                          decodeParam,
  1165.                                                          colorConvertJPEG,
  1166.                                                          tile.getMinX(),
  1167.                                                          tile.getMinY());
  1168.                             int[] tempPixels = new int[unitsBeforeLookup];
  1169.                             tempTile.getPixels(tile.getMinX(),
  1170.                                                tile.getMinY(),
  1171.                                                tile.getWidth(),
  1172.                                                tile.getHeight(),
  1173.                                                tempPixels);
  1174.     tempData = new byte[unitsBeforeLookup];
  1175.                             for(int i = 0; i < unitsBeforeLookup; i++) {
  1176.                                 tempData[i] = (byte)tempPixels[i];
  1177.                             }
  1179. }  else if (compression == COMP_DEFLATE) {
  1181.     stream.readFully(data, 0, byteCount);
  1182.     tempData = new byte[unitsBeforeLookup];
  1183.     inflate(data, tempData);
  1185. } else if (compression == COMP_NONE) {
  1187.     tempData = new byte[byteCount];
  1188.     stream.readFully(tempData, 0, byteCount);
  1189. }
  1191. stream.seek(save_offset);
  1193.     } catch (IOException ioe) {
  1194. throw new RuntimeException(
  1195. JaiI18N.getString("TIFFImage13"));
  1196.     }
  1198.     // Expand the palette image into an rgb image with ushort
  1199.     // data type.
  1200.     int cmapValue; 
  1201.     int count = 0, lookup, len = colormap.length/3;
  1202.     int len2 = len * 2;
  1203.     for (int i=0; i<unitsBeforeLookup; i++) {
  1204. // Get the index into the colormap
  1205. lookup = tempData[i] & 0xff;
  1206. // Get the blue value 
  1207. cmapValue = colormap[lookup+len2];
  1208. sdata[count++] = (short)(cmapValue & 0xffff);
  1209. // Get the green value
  1210. cmapValue = colormap[lookup+len];
  1211. sdata[count++] = (short)(cmapValue & 0xffff);
  1212. // Get the red value
  1213. cmapValue = colormap[lookup];
  1214. sdata[count++] = (short)(cmapValue & 0xffff);
  1215.     }
  1216. } else {
  1217.     
  1218.     // No lookup being done here, when RGB values are needed,
  1219.     // the associated IndexColorModel can be used to get them.
  1220.     
  1221.     try {
  1223. if (compression == COMP_PACKBITS) {
  1224.     
  1225.     stream.readFully(data, 0, byteCount);
  1226.     decodePackbits(data, unitsInThisTile, bdata);
  1227.     
  1228. } else if (compression == COMP_LZW) {
  1229.     
  1230.     stream.readFully(data, 0, byteCount);
  1231.     lzwDecoder.decode(data, bdata, newRect.height);
  1232.     
  1233.                         } else if (compression == COMP_JPEG_TTN2) {
  1235.                             stream.readFully(data, 0, byteCount);
  1236.                             tile.setRect(decodeJPEG(data,
  1237.                                                     decodeParam,
  1238.                                                     colorConvertJPEG,
  1239.                                                     tile.getMinX(),
  1240.                                                     tile.getMinY()));
  1242. }  else if (compression == COMP_DEFLATE) {
  1243.                             
  1244.                             stream.readFully(data, 0, byteCount);
  1245.                             inflate(data, bdata);
  1247. } else if (compression == COMP_NONE) {
  1249.     stream.readFully(bdata, 0, byteCount);
  1250. }
  1252. stream.seek(save_offset);
  1254.     } catch (IOException ioe) {
  1255. throw new RuntimeException(
  1256. JaiI18N.getString("TIFFImage13"));
  1257.     }     
  1258. }
  1260.     } else if (sampleSize == 4) {
  1262. int padding = (newRect.width % 2 == 0) ? 0 : 1;
  1263. int bytesPostDecoding = ((newRect.width/2 + padding) *
  1264.  newRect.height);
  1266. // Output short images
  1267. if (decodePaletteAsShorts) {
  1268.     
  1269.     byte tempData[] = null;
  1271.     try {
  1272. stream.readFully(data, 0, byteCount);
  1273. stream.seek(save_offset);
  1274.     } catch (IOException ioe) {
  1275. throw new RuntimeException(
  1276. JaiI18N.getString("TIFFImage13"));
  1277.     }
  1278.     
  1279.     // If compressed, decode the data.
  1280.     if (compression == COMP_PACKBITS) {
  1282. tempData = new byte[bytesPostDecoding];
  1283. decodePackbits(data, bytesPostDecoding, tempData);
  1285.     }  else if (compression == COMP_LZW) {
  1287. tempData = new byte[bytesPostDecoding];
  1288. lzwDecoder.decode(data, tempData, newRect.height);
  1290.                     }  else if (compression == COMP_DEFLATE) {
  1292. tempData = new byte[bytesPostDecoding];
  1293. inflate(data, tempData);
  1295.     } else if (compression == COMP_NONE) {
  1297. tempData = data;
  1298.     } 
  1299.     
  1300.     int bytes = unitsInThisTile / 3;
  1301.     
  1302.     // Unpack the 2 pixels packed into each byte.    
  1303.     data = new byte[bytes];
  1304.     
  1305.     int srcCount = 0, dstCount = 0;
  1306.     for (int j=0; j<newRect.height; j++) {
  1307. for (int i=0; i<newRect.width/2; i++) {
  1308.     data[dstCount++] = 
  1309. (byte)((tempData[srcCount] & 0xf0) >> 4);
  1310.     data[dstCount++] = 
  1311. (byte)(tempData[srcCount++] & 0x0f);
  1312. }
  1313.        
  1314. if (padding == 1) {
  1315.     data[dstCount++] = 
  1316. (byte)((tempData[srcCount++] & 0xf0) >> 4);
  1317. }
  1318.     }
  1319.     
  1320.     int len = colormap.length/3;
  1321.     int len2 = len*2;
  1322.     int cmapValue, lookup;
  1323.     int count = 0;
  1324.     for (int i=0; i<bytes; i++) {
  1325. lookup = data[i] & 0xff;
  1326. cmapValue = colormap[lookup+len2];
  1327. sdata[count++] = (short)(cmapValue & 0xffff);
  1328. cmapValue = colormap[lookup+len];
  1329. sdata[count++] = (short)(cmapValue & 0xffff);
  1330. cmapValue = colormap[lookup];
  1331. sdata[count++] = (short)(cmapValue & 0xffff);
  1332.     }
  1333. } else {
  1334.     
  1335.     // Output byte values, use IndexColorModel for unpacking
  1336.     try {
  1338. // If compressed, decode the data.
  1339. if (compression == COMP_PACKBITS) {
  1340.     
  1341.     stream.readFully(data, 0, byteCount);
  1342.     decodePackbits(data, bytesPostDecoding, bdata);
  1343.     
  1344. }  else if (compression == COMP_LZW) {
  1345.     
  1346.     stream.readFully(data, 0, byteCount);
  1347.     lzwDecoder.decode(data, bdata, newRect.height);
  1348.     
  1349.                         }  else if (compression == COMP_DEFLATE) {
  1351.     stream.readFully(data, 0, byteCount);
  1352.     inflate(data, bdata);
  1354. } else if (compression == COMP_NONE) {
  1355.     
  1356.     stream.readFully(bdata, 0, byteCount);
  1357. } 
  1359. stream.seek(save_offset);
  1361.     } catch (IOException ioe) {
  1362. throw new RuntimeException(
  1363. JaiI18N.getString("TIFFImage13"));
  1364.     }
  1365. }
  1366.     }
  1367.         } else if(imageType == TYPE_GRAY_4BIT) { // 4-bit gray
  1368.             try {
  1369.                 if (compression == COMP_PACKBITS) {
  1371.                     stream.readFully(data, 0, byteCount);
  1373.                     // Since the decompressed data will still be packed 
  1374.                     // 2 pixels into 1 byte, calculate bytesInThisTile
  1375.                     int bytesInThisTile;
  1376.                     if ((newRect.width % 8) == 0) {
  1377.                         bytesInThisTile = (newRect.width/2) * newRect.height;
  1378.                     } else {
  1379.                         bytesInThisTile = (newRect.width/2 + 1) * 
  1380.                             newRect.height;
  1381.                     }
  1383.                     decodePackbits(data, bytesInThisTile, bdata);
  1385.                 } else if (compression == COMP_LZW) {
  1387.                     stream.readFully(data, 0, byteCount);
  1388.                     lzwDecoder.decode(data, bdata, newRect.height);
  1390.                 }  else if (compression == COMP_DEFLATE) {
  1392.                     stream.readFully(data, 0, byteCount);
  1393.                     inflate(data, bdata);
  1395.                 } else {
  1397.                     stream.readFully(bdata, 0, byteCount);
  1398.                 }
  1400.                 stream.seek(save_offset);
  1401.     } catch (IOException ioe) {
  1402. throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  1403.     }
  1404.         } else { // everything else
  1405.     try {
  1407. if (sampleSize == 8) {
  1408.     
  1409.     if (compression == COMP_NONE) {
  1411. stream.readFully(bdata, 0, byteCount);
  1413.     } else if (compression == COMP_LZW) {
  1415. stream.readFully(data, 0, byteCount);
  1416. lzwDecoder.decode(data, bdata, newRect.height);
  1418.     } else if (compression == COMP_PACKBITS) {
  1420. stream.readFully(data, 0, byteCount);
  1421. decodePackbits(data, unitsInThisTile, bdata);
  1423.     } else if (compression == COMP_JPEG_TTN2) {
  1425. stream.readFully(data, 0, byteCount);
  1426.                         tile.setRect(decodeJPEG(data,
  1427.                                                 decodeParam,
  1428.                                                 colorConvertJPEG,
  1429.                                                 tile.getMinX(),
  1430.                                                 tile.getMinY()));
  1431.     } else if (compression == COMP_DEFLATE) {
  1433. stream.readFully(data, 0, byteCount);
  1434.                         inflate(data, bdata);
  1435.                     }
  1436.     
  1437. } else if (sampleSize == 16) {
  1438.     
  1439.     if (compression == COMP_NONE) {
  1441. readShorts(byteCount/2, sdata);
  1443.     } else if (compression == COMP_LZW) {
  1445. stream.readFully(data, 0, byteCount);
  1447. // Since unitsInThisTile is the number of shorts, 
  1448. // but we do our decompression in terms of bytes, we 
  1449. // need to multiply unitsInThisTile by 2 in order to 
  1450. // figure out how many bytes we'll get after 
  1451. // decompression.
  1452. byte byteArray[] = new byte[unitsInThisTile * 2];
  1453. lzwDecoder.decode(data, byteArray, newRect.height);
  1454. interpretBytesAsShorts(byteArray, sdata, 
  1455.        unitsInThisTile);
  1457.     } else if (compression == COMP_PACKBITS) {
  1459. stream.readFully(data, 0, byteCount);
  1461. // Since unitsInThisTile is the number of shorts, 
  1462. // but we do our decompression in terms of bytes, we 
  1463. // need to multiply unitsInThisTile by 2 in order to 
  1464. // figure out how many bytes we'll get after 
  1465. // decompression.
  1466. int bytesInThisTile = unitsInThisTile * 2;
  1468. byte byteArray[] = new byte[bytesInThisTile];
  1469. decodePackbits(data, bytesInThisTile, byteArray);
  1470. interpretBytesAsShorts(byteArray, sdata, 
  1471.        unitsInThisTile);
  1472.     } else if (compression == COMP_DEFLATE) {
  1474. stream.readFully(data, 0, byteCount);
  1475. byte byteArray[] = new byte[unitsInThisTile * 2];
  1476. inflate(data, byteArray);
  1477. interpretBytesAsShorts(byteArray, sdata, 
  1478.        unitsInThisTile);
  1480.     }
  1481. } else if (sampleSize == 32 &&
  1482.                            dataType == DataBuffer.TYPE_INT) { // redundant
  1483.     if (compression == COMP_NONE) {
  1485. readInts(byteCount/4, idata);
  1487.     } else if (compression == COMP_LZW) {
  1489. stream.readFully(data, 0, byteCount);
  1491. // Since unitsInThisTile is the number of ints, 
  1492. // but we do our decompression in terms of bytes, we 
  1493. // need to multiply unitsInThisTile by 4 in order to 
  1494. // figure out how many bytes we'll get after 
  1495. // decompression.
  1496. byte byteArray[] = new byte[unitsInThisTile * 4];
  1497. lzwDecoder.decode(data, byteArray, newRect.height);
  1498. interpretBytesAsInts(byteArray, idata, 
  1499.                                              unitsInThisTile);
  1501.     } else if (compression == COMP_PACKBITS) {
  1503. stream.readFully(data, 0, byteCount);
  1505. // Since unitsInThisTile is the number of ints, 
  1506. // but we do our decompression in terms of bytes, we 
  1507. // need to multiply unitsInThisTile by 4 in order to 
  1508. // figure out how many bytes we'll get after 
  1509. // decompression.
  1510. int bytesInThisTile = unitsInThisTile * 4;
  1512. byte byteArray[] = new byte[bytesInThisTile];
  1513. decodePackbits(data, bytesInThisTile, byteArray);
  1514. interpretBytesAsInts(byteArray, idata, 
  1515.                                              unitsInThisTile);
  1516.     } else if (compression == COMP_DEFLATE) {
  1518. stream.readFully(data, 0, byteCount);
  1519. byte byteArray[] = new byte[unitsInThisTile * 4];
  1520. inflate(data, byteArray);
  1521. interpretBytesAsInts(byteArray, idata, 
  1522.                                              unitsInThisTile);
  1524.                     }
  1525. } else if (sampleSize == 32 &&
  1526.                            dataType == DataBuffer.TYPE_FLOAT) { // redundant
  1527.     if (compression == COMP_NONE) {
  1529. readFloats(byteCount/4, fdata);
  1531.     } else if (compression == COMP_LZW) {
  1533. stream.readFully(data, 0, byteCount);
  1535. // Since unitsInThisTile is the number of floats, 
  1536. // but we do our decompression in terms of bytes, we 
  1537. // need to multiply unitsInThisTile by 4 in order to 
  1538. // figure out how many bytes we'll get after 
  1539. // decompression.
  1540. byte byteArray[] = new byte[unitsInThisTile * 4];
  1541. lzwDecoder.decode(data, byteArray, newRect.height);
  1542. interpretBytesAsFloats(byteArray, fdata, 
  1543.                                                unitsInThisTile);
  1545.     } else if (compression == COMP_PACKBITS) {
  1547. stream.readFully(data, 0, byteCount);
  1549. // Since unitsInThisTile is the number of floats, 
  1550. // but we do our decompression in terms of bytes, we 
  1551. // need to multiply unitsInThisTile by 4 in order to 
  1552. // figure out how many bytes we'll get after 
  1553. // decompression.
  1554. int bytesInThisTile = unitsInThisTile * 4;
  1556. byte byteArray[] = new byte[bytesInThisTile];
  1557. decodePackbits(data, bytesInThisTile, byteArray);
  1558. interpretBytesAsFloats(byteArray, fdata, 
  1559.                                                unitsInThisTile);
  1560.     } else if (compression == COMP_DEFLATE) {
  1562. stream.readFully(data, 0, byteCount);
  1563. byte byteArray[] = new byte[unitsInThisTile * 4];
  1564.                         inflate(data, byteArray);
  1565. interpretBytesAsFloats(byteArray, fdata, 
  1566.                                                unitsInThisTile);
  1568.                     }
  1569. }
  1571. stream.seek(save_offset);
  1573.     } catch (IOException ioe) {
  1574. throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  1575.     }
  1577.             // Modify the data for certain special cases.
  1578.             switch(imageType) {
  1579.             case TYPE_GRAY:
  1580.             case TYPE_GRAY_ALPHA:
  1581.                 if(isWhiteZero) {
  1582.                     // Since we are using a ComponentColorModel with this
  1583.                     // image, we need to change the WhiteIsZero data to
  1584.                     // BlackIsZero data so it will display properly.
  1585.                     if (dataType == DataBuffer.TYPE_BYTE &&
  1586.                         !(colorModel instanceof IndexColorModel)) {
  1588.                         for (int l = 0; l < bdata.length; l += numBands) {
  1589.                             bdata[l] = (byte)(255 - bdata[l]);
  1590.                         }
  1591.                     } else if (dataType == DataBuffer.TYPE_USHORT) {
  1593.                         int ushortMax = Short.MAX_VALUE - Short.MIN_VALUE;
  1594.                         for (int l = 0; l < sdata.length; l += numBands) {
  1595.                             sdata[l] = (short)(ushortMax - sdata[l]);
  1596.                         }
  1598.                     } else if (dataType == DataBuffer.TYPE_SHORT) {
  1600.                         for (int l = 0; l < sdata.length; l += numBands) {
  1601.                             sdata[l] = (short)(~sdata[l]);
  1602.                         }
  1603.                     } else if (dataType == DataBuffer.TYPE_INT) {
  1605.                         long uintMax = Integer.MAX_VALUE - Integer.MIN_VALUE;
  1606.                         for (int l = 0; l < idata.length; l += numBands) {
  1607.                             idata[l] = (int)(uintMax - (long)idata[l]);
  1608.                         }
  1609.                     }
  1610.                 }
  1611.                 break;
  1612.             case TYPE_RGB:
  1613.                 // Change RGB to BGR order, as Java2D displays that faster.
  1614.                 // Unnecessary for JPEG-in-TIFF as the decoder handles it.
  1615.                 if (sampleSize == 8 && compression != COMP_JPEG_TTN2) {
  1616.     for (int i=0; i<unitsInThisTile; i+=3) {
  1617. bswap = bdata[i];
  1618. bdata[i] = bdata[i+2];
  1619. bdata[i+2] = bswap;
  1620.     }
  1621. } else if (sampleSize == 16) {
  1622.     for (int i=0; i<unitsInThisTile; i+=3) {
  1623. sswap = sdata[i];
  1624. sdata[i] = sdata[i+2];
  1625. sdata[i+2] = sswap;
  1626.     }
  1627. } else if (sampleSize == 32) {
  1628.                     if(dataType == DataBuffer.TYPE_INT) {
  1629.                         for (int i=0; i<unitsInThisTile; i+=3) {
  1630.                             iswap = idata[i];
  1631.                             idata[i] = idata[i+2];
  1632.                             idata[i+2] = iswap;
  1633.                         }
  1634.                     } else if(dataType == DataBuffer.TYPE_FLOAT) {
  1635.                         for (int i=0; i<unitsInThisTile; i+=3) {
  1636.                             fswap = fdata[i];
  1637.                             fdata[i] = fdata[i+2];
  1638.                             fdata[i+2] = fswap;
  1639.                         }
  1640.                     }
  1641.                 }
  1642.                 break;
  1643.             case TYPE_RGB_ALPHA:
  1644.                 // Convert from RGBA to ABGR for Java2D
  1645.                 if (sampleSize == 8) {
  1646.     for (int i=0; i<unitsInThisTile; i+=4) {
  1647. // Swap R and A
  1648. bswap = bdata[i];
  1649. bdata[i] = bdata[i+3];
  1650. bdata[i+3] = bswap;
  1652. // Swap G and B
  1653. bswap = bdata[i+1];
  1654. bdata[i+1] = bdata[i+2];
  1655. bdata[i+2] = bswap;
  1656.     }
  1657. } else if (sampleSize == 16) {
  1658.     for (int i=0; i<unitsInThisTile; i+=4) {
  1659. // Swap R and A
  1660. sswap = sdata[i];
  1661. sdata[i] = sdata[i+3];
  1662. sdata[i+3] = sswap;
  1664. // Swap G and B
  1665. sswap = sdata[i+1];
  1666. sdata[i+1] = sdata[i+2];
  1667. sdata[i+2] = sswap;
  1668.     }
  1669. } else if (sampleSize == 32) {
  1670.                     if(dataType == DataBuffer.TYPE_INT) {
  1671.                         for (int i=0; i<unitsInThisTile; i+=4) {
  1672.                             // Swap R and A
  1673.                             iswap = idata[i];
  1674.                             idata[i] = idata[i+3];
  1675.                             idata[i+3] = iswap;
  1677.                             // Swap G and B
  1678.                             iswap = idata[i+1];
  1679.                             idata[i+1] = idata[i+2];
  1680.                             idata[i+2] = iswap;
  1681.                         }
  1682.                     } else if(dataType == DataBuffer.TYPE_FLOAT) {
  1683.                         for (int i=0; i<unitsInThisTile; i+=4) {
  1684.                             // Swap R and A
  1685.                             fswap = fdata[i];
  1686.                             fdata[i] = fdata[i+3];
  1687.                             fdata[i+3] = fswap;
  1689.                             // Swap G and B
  1690.                             fswap = fdata[i+1];
  1691.                             fdata[i+1] = fdata[i+2];
  1692.                             fdata[i+2] = fswap;
  1693.                         }
  1694.                     }
  1695.                 }
  1696.                 break;
  1697.             case TYPE_YCBCR_SUB:
  1698.                 // Post-processing for YCbCr with subsampled chrominance:
  1699.                 // simply replicate the chroma channels for displayability.
  1700.                 int pixelsPerDataUnit = chromaSubH*chromaSubV;
  1702.                 int numH = newRect.width/chromaSubH;
  1703.                 int numV = newRect.height/chromaSubV;
  1705.                 byte[] tempData = new byte[numH*numV*(pixelsPerDataUnit + 2)];
  1706.                 System.arraycopy(bdata, 0, tempData, 0, tempData.length);
  1708.                 int samplesPerDataUnit = pixelsPerDataUnit*3;
  1709.                 int[] pixels = new int[samplesPerDataUnit];
  1711.                 int bOffset = 0;
  1712.                 int offsetCb = pixelsPerDataUnit;
  1713.                 int offsetCr = offsetCb + 1;
  1715.                 int y = newRect.y;
  1716.                 for(int j = 0; j < numV; j++) {
  1717.                     int x = newRect.x;
  1718.                     for(int i = 0; i < numH; i++) {
  1719.                         int Cb = tempData[bOffset + offsetCb];
  1720.                         int Cr = tempData[bOffset + offsetCr];
  1721.                         int k = 0;
  1722.                         while(k < samplesPerDataUnit) {
  1723.                             pixels[k++] = tempData[bOffset++];
  1724.                             pixels[k++] = Cb;
  1725.                             pixels[k++] = Cr;
  1726.                         }
  1727.                         bOffset += 2;
  1728.                         tile.setPixels(x, y, chromaSubH, chromaSubV, pixels);
  1729.                         x += chromaSubH;
  1730.                     }
  1731.                     y += chromaSubV;
  1732.                 }
  1734.                 break;
  1735.             }
  1736.         }
  1737.         
  1738.         return tile;
  1739.     }
  1741.     private void readShorts(int shortCount, short shortArray[]) {
  1743. // Since each short consists of 2 bytes, we need a 
  1744. // byte array of double size
  1745. int byteCount = 2 * shortCount;
  1746. byte byteArray[] = new byte[byteCount];
  1748. try {     
  1749.     stream.readFully(byteArray, 0, byteCount);
  1750. } catch (IOException ioe) {
  1751.    throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  1752. }
  1754. interpretBytesAsShorts(byteArray, shortArray, shortCount);
  1755.     }
  1757.     private void readInts(int intCount, int intArray[]) {
  1759. // Since each int consists of 4 bytes, we need a 
  1760. // byte array of quadruple size
  1761. int byteCount = 4 * intCount;
  1762. byte byteArray[] = new byte[byteCount];
  1764. try {     
  1765.     stream.readFully(byteArray, 0, byteCount);
  1766. } catch (IOException ioe) {
  1767.    throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  1768. }
  1770. interpretBytesAsInts(byteArray, intArray, intCount);
  1771.     }
  1773.     private void readFloats(int floatCount, float floatArray[]) {
  1775. // Since each float consists of 4 bytes, we need a 
  1776. // byte array of quadruple size
  1777. int byteCount = 4 * floatCount;
  1778. byte byteArray[] = new byte[byteCount];
  1780. try {     
  1781.     stream.readFully(byteArray, 0, byteCount);
  1782. } catch (IOException ioe) {
  1783.    throw new RuntimeException(JaiI18N.getString("TIFFImage13"));
  1784. }
  1786. interpretBytesAsFloats(byteArray, floatArray, floatCount);
  1787.     }
  1789.     // Method to interpret a byte array to a short array, depending on 
  1790.     // whether the bytes are stored in a big endian or little endian format.
  1791.     private void interpretBytesAsShorts(byte byteArray[], 
  1792. short shortArray[], 
  1793. int shortCount) {
  1795. int j = 0;
  1796. int firstByte, secondByte;
  1798. if (isBigEndian) {
  1800.     for (int i=0; i<shortCount; i++) {
  1801. firstByte = byteArray[j++] & 0xff;
  1802. secondByte = byteArray[j++] & 0xff;
  1803. shortArray[i] = (short)((firstByte << 8) + secondByte);
  1804.     }
  1805.     
  1806. } else {
  1807.     
  1808.     for (int i=0; i<shortCount; i++) {
  1809. firstByte = byteArray[j++] & 0xff;
  1810. secondByte = byteArray[j++] & 0xff;
  1811. shortArray[i] = (short)((secondByte << 8) + firstByte);
  1812.     }
  1813. }
  1814.     }
  1816.     // Method to interpret a byte array to a int array, depending on 
  1817.     // whether the bytes are stored in a big endian or little endian format.
  1818.     private void interpretBytesAsInts(byte byteArray[],
  1819.                                       int intArray[], 
  1820.                                       int intCount) {
  1822. int j = 0;
  1824. if (isBigEndian) {
  1825.     
  1826.     for (int i=0; i<intCount; i++) {
  1827. intArray[i] =
  1828.                     (int)(((byteArray[j++] & 0xff) << 24) |
  1829.                           ((byteArray[j++] & 0xff) << 16) |
  1830.                           ((byteArray[j++] & 0xff) << 8) |
  1831.                           (byteArray[j++] & 0xff));
  1832.     }
  1833.     
  1834. } else {
  1835.     
  1836.     for (int i=0; i<intCount; i++) {
  1837. intArray[i] =
  1838.                     (int)((byteArray[j++] & 0xff) |
  1839.                           ((byteArray[j++] & 0xff) << 8) |
  1840.                           ((byteArray[j++] & 0xff) << 16) |
  1841.                           ((byteArray[j++] & 0xff) << 24));
  1842.     }
  1843. }
  1844.     }
  1846.     // Method to interpret a byte array to a float array, depending on 
  1847.     // whether the bytes are stored in a big endian or little endian format.
  1848.     private void interpretBytesAsFloats(byte byteArray[],
  1849.                                         float floatArray[], 
  1850.                                         int floatCount) {
  1852. int j = 0;
  1854. if (isBigEndian) {
  1855.     
  1856.     for (int i=0; i<floatCount; i++) {
  1857.                 int value = (int)(((byteArray[j++] & 0xff) << 24) |
  1858.                                   ((byteArray[j++] & 0xff) << 16) |
  1859.                                   ((byteArray[j++] & 0xff) << 8) |
  1860.                                   (byteArray[j++] & 0xff));
  1861. floatArray[i] = Float.intBitsToFloat(value);
  1862.     }
  1863.     
  1864. } else {
  1865.     
  1866.     for (int i=0; i<floatCount; i++) {
  1867. int value = (int)((byteArray[j++] & 0xff) |
  1868.                                   ((byteArray[j++] & 0xff) << 8) |
  1869.                                   ((byteArray[j++] & 0xff) << 16) |
  1870.                                   ((byteArray[j++] & 0xff) << 24));
  1871. floatArray[i] = Float.intBitsToFloat(value);
  1872.     }
  1873. }
  1874.     }
  1876.     // Uncompress packbits compressed image data.
  1877.     private byte[] decodePackbits(byte data[], int arraySize, byte[] dst) {
  1879. if (dst == null) {
  1880.     dst = new byte[arraySize];
  1881. }
  1883. int srcCount = 0, dstCount = 0;
  1884. byte repeat, b;
  1886. try {
  1887.     
  1888.     while (dstCount < arraySize) {
  1890. b = data[srcCount++];
  1892. if (b >= 0 && b <= 127) {
  1893.     
  1894.     // literal run packet
  1895.     for (int i=0; i<(b + 1); i++) {
  1896. dst[dstCount++] = data[srcCount++];
  1897.     }
  1898.          
  1899. } else if (b <= -1 && b >= -127) {
  1900.     
  1901.     // 2 byte encoded run packet
  1902.     repeat = data[srcCount++];
  1903.     for (int i=0; i<(-b + 1); i++) {
  1904. dst[dstCount++] = repeat;
  1905.     }
  1906.     
  1907. } else {
  1908.     // no-op packet. Do nothing
  1909.     srcCount++;
  1910. }
  1911.     }
  1912. } catch (java.lang.ArrayIndexOutOfBoundsException ae) {
  1913.     throw new RuntimeException(JaiI18N.getString("TIFFImage14"));
  1914. }
  1916. return dst;
  1917.     }
  1919.     // Need a createColorModel().
  1920.     // Create ComponentColorModel for TYPE_RGB images
  1921.     private ComponentColorModel createAlphaComponentColorModel(
  1922.   int dataType,
  1923.                                                   int numBands,
  1924.   boolean isAlphaPremultiplied,
  1925.   int transparency) {
  1927. ComponentColorModel ccm = null;
  1928.         int RGBBits[] = null;
  1929.         ColorSpace cs = null;
  1930.         switch(numBands) {
  1931.         case 2: // gray+alpha
  1932.             cs = ColorSpace.getInstance(ColorSpace.CS_GRAY);
  1933.             break;
  1934.         case 4: // RGB+alpha
  1935.             cs = ColorSpace.getInstance(ColorSpace.CS_sRGB);
  1936.             break;
  1937.         default:
  1938.             throw new IllegalArgumentException();
  1939.         }
  1941.         if(dataType == DataBuffer.TYPE_FLOAT) {
  1942.             ccm = new FloatDoubleColorModel(cs,
  1943.                                             true,
  1944.                                             isAlphaPremultiplied,
  1945.                                             transparency,
  1946.                                             dataType);
  1947.         } else { // all other types
  1948.             int componentSize = 0;
  1949.             switch(dataType) {
  1950.             case DataBuffer.TYPE_BYTE:
  1951.                 componentSize = 8;
  1952.                 break;
  1953.             case DataBuffer.TYPE_USHORT:
  1954.             case DataBuffer.TYPE_SHORT:
  1955.                 componentSize = 16;
  1956.                 break;
  1957.             case DataBuffer.TYPE_INT:
  1958.                 componentSize = 32;
  1959.                 break;
  1960.             default:
  1961.                 throw new IllegalArgumentException();
  1962.             }
  1964.             RGBBits = new int[numBands];
  1965.             for(int i = 0; i < numBands; i++) {
  1966.                 RGBBits[i] = componentSize;
  1967.             }
  1969.             ccm = new ComponentColorModel(cs,
  1970.                                           RGBBits,
  1971.                                           true,
  1972.                                           isAlphaPremultiplied,
  1973.                                           transparency,
  1974.                                           dataType);
  1975.         }
  1977. return ccm;
  1978.     }
  1979. }