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

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

DNA

开发平台：

Java

BMPImageDecoder.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.Transparency;
  35. import java.awt.color.ColorSpace;
  36. import java.awt.image.DataBuffer;
  37. import java.awt.image.DataBufferByte;
  38. import java.awt.image.Raster;
  39. import java.awt.image.RenderedImage;
  40. import java.awt.image.WritableRaster;
  41. import java.awt.image.IndexColorModel;
  42. import java.awt.image.MultiPixelPackedSampleModel;
  43. import java.io.IOException;
  44. import java.io.BufferedInputStream;
  45. import java.io.InputStream;
  46. import java.util.Hashtable;
  47. import java.util.Enumeration;
  49. /**
  50.  */
  51. public class BMPImageDecoder extends ImageDecoderImpl {
  53.     public BMPImageDecoder(InputStream input, ImageDecodeParam param) {
  54.         super(input, param);
  55.     }
  57.     public RenderedImage decodeAsRenderedImage(int page) throws IOException {
  58.         if (page != 0) {
  59.             throw new IOException(JaiI18N.getString("BMPImageDecoder8"));
  60.         }
  61.         return new BMPImage(input);
  62.     }
  63. }
  65. class BMPImage extends SimpleRenderedImage {
  66.     
  67.     // BMP variables
  68.     private BufferedInputStream inputStream;
  69.     private long bitmapFileSize;
  70.     private long bitmapOffset;
  71.     private long compression;
  72.     private long imageSize;
  73.     private byte palette[];
  74.     private int imageType;
  75.     private int numBands;
  76.     private boolean isBottomUp;
  77.     private int bitsPerPixel;
  78.     private int redMask, greenMask, blueMask;    
  79.     
  80.     // BMP Image types
  81.     private static final int VERSION_2_1_BIT = 0;
  82.     private static final int VERSION_2_4_BIT = 1;
  83.     private static final int VERSION_2_8_BIT = 2;
  84.     private static final int VERSION_2_24_BIT = 3;
  86.     private static final int VERSION_3_1_BIT = 4;
  87.     private static final int VERSION_3_4_BIT = 5;
  88.     private static final int VERSION_3_8_BIT = 6;
  89.     private static final int VERSION_3_24_BIT = 7;
  91.     private static final int VERSION_3_NT_16_BIT = 8;
  92.     private static final int VERSION_3_NT_32_BIT = 9;
  94.     private static final int VERSION_4_1_BIT = 10;
  95.     private static final int VERSION_4_4_BIT = 11;
  96.     private static final int VERSION_4_8_BIT = 12;
  97.     private static final int VERSION_4_16_BIT = 13;
  98.     private static final int VERSION_4_24_BIT = 14;
  99.     private static final int VERSION_4_32_BIT = 15;
  101.     // Color space types
  102.     private static final int LCS_CALIBRATED_RGB = 0;
  103.     private static final int LCS_sRGB = 1;
  104.     private static final int LCS_CMYK = 2;
  106.     // Compression Types
  107.     private static final int BI_RGB = 0;
  108.     private static final int BI_RLE8 = 1;
  109.     private static final int BI_RLE4 = 2;
  110.     private static final int BI_BITFIELDS = 3;
  112.     // Shifts for each color component
  113.     private int blueBits, greenBits, redBits;
  115.     private WritableRaster theTile = null;
  117.     /**
  118.      * Constructor for BMPImage
  119.      *
  120.      * @param stream 
  121.      */
  122.     public BMPImage(InputStream stream) {
  123. if (stream instanceof BufferedInputStream) {
  124.     inputStream = (BufferedInputStream)stream;
  125. } else {
  126.     inputStream = new BufferedInputStream(stream);
  127. }
  129. try {
  131.     // Start File Header
  132.     if (!(readUnsignedByte(inputStream) == 'B' &&
  133.     readUnsignedByte(inputStream) == 'M')) {
  134. throw new
  135.     RuntimeException(JaiI18N.getString("BMPImageDecoder0"));
  136.     }
  137.     
  138.     // Read file size
  139.     bitmapFileSize = readDWord(inputStream);
  141.     // Read the two reserved fields
  142.     readWord(inputStream);
  143.     readWord(inputStream);
  144.     
  145.     // Offset to the bitmap from the beginning
  146.     bitmapOffset = readDWord(inputStream);
  147.     
  148.     // End File Header
  149.     
  150.     // Start BitmapCoreHeader
  151.     long size = readDWord(inputStream);
  153.     if (size == 12) {
  154. width = readWord(inputStream);
  155. height = readWord(inputStream);
  156.     } else {
  157. width = readLong(inputStream);
  158. height = readLong(inputStream);
  159.     }
  161.     int planes = readWord(inputStream);
  162.     bitsPerPixel = readWord(inputStream);
  164.     properties.put("color_planes", new Integer(planes));
  165.     properties.put("bits_per_pixel", new Integer(bitsPerPixel));
  166.     
  167.     // As BMP always has 3 rgb bands, except for Version 5,
  168.     // which is bgra
  169.     numBands = 3;
  170.     
  171.     if (size == 12) {
  172. // Windows 2.x and OS/2 1.x
  173. properties.put("bmp_version", "BMP v. 2.x");
  175. // Classify the image type
  176. if (bitsPerPixel == 1) {
  177.     imageType = VERSION_2_1_BIT;
  178. } else if (bitsPerPixel == 4) {
  179.     imageType = VERSION_2_4_BIT;
  180. } else if (bitsPerPixel == 8) {
  181.     imageType = VERSION_2_8_BIT;
  182. } else if (bitsPerPixel == 24) {
  183.     imageType = VERSION_2_24_BIT;
  184. }
  186. // Read in the palette
  187. int numberOfEntries = (int)((bitmapOffset-14-size) / 3);
  188. int sizeOfPalette = numberOfEntries*3;
  189. palette = new byte[sizeOfPalette];
  190. inputStream.read(palette, 0, sizeOfPalette);
  191. properties.put("palette", palette);
  192.     } else {
  194. compression = readDWord(inputStream);
  195. imageSize = readDWord(inputStream);
  196. long xPelsPerMeter = readLong(inputStream);
  197. long yPelsPerMeter = readLong(inputStream);
  198. long colorsUsed = readDWord(inputStream);
  199. long colorsImportant = readDWord(inputStream);
  201. switch((int)compression) {
  202. case BI_RGB:
  203.     properties.put("compression", "BI_RGB");
  204.     break;
  206. case BI_RLE8:
  207.     properties.put("compression", "BI_RLE8");
  208.     break;
  209.     
  210. case BI_RLE4:
  211.     properties.put("compression", "BI_RLE4");
  212.     break;
  213.     
  214. case BI_BITFIELDS:
  215.     properties.put("compression", "BI_BITFIELDS");
  216.     break;
  217. }
  219. properties.put("x_pixels_per_meter", new Long(xPelsPerMeter));
  220. properties.put("y_pixels_per_meter", new Long(yPelsPerMeter));
  221. properties.put("colors_used", new Long(colorsUsed));
  222. properties.put("colors_important", new Long(colorsImportant));
  224. if (size == 40) {
  225.     // Windows 3.x and Windows NT     
  226.     switch((int)compression) {
  227.     
  228.     case BI_RGB:  // No compression
  229.     case BI_RLE8:  // 8-bit RLE compression
  230.     case BI_RLE4:  // 4-bit RLE compression
  232. // Read in the palette
  233. int numberOfEntries = (int)((bitmapOffset-14-size) / 4);
  234. int sizeOfPalette = numberOfEntries*4;
  235. palette = new byte[sizeOfPalette];
  236. inputStream.read(palette, 0, sizeOfPalette);
  237. properties.put("palette", palette);
  239. if (bitsPerPixel == 1) {
  240.     imageType = VERSION_3_1_BIT;
  241. } else if (bitsPerPixel == 4) {
  242.     imageType = VERSION_3_4_BIT;
  243. } else if (bitsPerPixel == 8) {
  244.     imageType = VERSION_3_8_BIT;
  245. } else if (bitsPerPixel == 24) {
  246.     imageType = VERSION_3_24_BIT;
  247. } else if (bitsPerPixel == 16) {
  248.     imageType = VERSION_3_NT_16_BIT;
  249.     redMask = 0x7C00;
  250.     greenMask = 0x3E0;
  251.     blueMask = 0x1F;
  252.     properties.put("red_mask", new Integer(redMask));
  253.     properties.put("green_mask", new Integer(greenMask));
  254.     properties.put("blue_mask", new Integer(blueMask));
  255.     computeShifts();
  256. } else if (bitsPerPixel == 32) {
  257.     imageType = VERSION_3_NT_32_BIT;
  258.     redMask   = 0x00FF0000;
  259.     greenMask = 0x0000FF00;
  260.     blueMask  = 0x000000FF;
  261.     properties.put("red_mask", new Integer(redMask));
  262.     properties.put("green_mask", new Integer(greenMask));
  263.     properties.put("blue_mask", new Integer(blueMask));
  264.     computeShifts();
  265. }
  267. properties.put("bmp_version", "BMP v. 3.x");
  268. break;
  269.     
  270.     case BI_BITFIELDS:
  272. if (bitsPerPixel == 16) {
  273.     imageType = VERSION_3_NT_16_BIT;
  274. } else if (bitsPerPixel == 32) {
  275.     imageType = VERSION_3_NT_32_BIT;
  276. }
  278. // BitsField encoding
  279. redMask = (int)readDWord(inputStream);
  280. greenMask = (int)readDWord(inputStream);
  281. blueMask = (int)readDWord(inputStream);
  283. properties.put("red_mask", new Integer(redMask));
  284. properties.put("green_mask", new Integer(greenMask));
  285. properties.put("blue_mask", new Integer(blueMask));
  287. computeShifts();
  289. if (colorsUsed != 0) {
  290.     // there is a palette
  291.     sizeOfPalette = (int)colorsUsed*4;
  292.     palette = new byte[sizeOfPalette];
  293.     inputStream.read(palette, 0, sizeOfPalette);
  294.     properties.put("palette", palette);
  295. }
  297. properties.put("bmp_version", "BMP v. 3.x NT");
  298. break;
  299.     
  300.     default:
  301. throw new 
  302.  RuntimeException(JaiI18N.getString("BMPImageDecoder1"));
  303.     }
  304. } else if (size == 108) {
  305.     // Windows 4.x BMP
  306.     
  307.     properties.put("bmp_version", "BMP v. 4.x");
  308.          
  309.     // rgb masks, valid only if comp is BI_BITFIELDS
  310.     redMask = (int)readDWord(inputStream);
  311.     greenMask = (int)readDWord(inputStream);
  312.     blueMask = (int)readDWord(inputStream);
  313.     // Only supported for 32bpp BI_RGB argb
  314.     int alphaMask = (int)readDWord(inputStream);
  315.     long csType = readDWord(inputStream);
  316.     int redX = readLong(inputStream);
  317.     int redY = readLong(inputStream);
  318.     int redZ = readLong(inputStream);
  319.     int greenX = readLong(inputStream);
  320.     int greenY = readLong(inputStream);
  321.     int greenZ = readLong(inputStream);
  322.     int blueX = readLong(inputStream);
  323.     int blueY = readLong(inputStream);
  324.     int blueZ = readLong(inputStream);
  325.     long gammaRed = readDWord(inputStream);
  326.     long gammaGreen = readDWord(inputStream);
  327.     long gammaBlue = readDWord(inputStream);
  329.     // Read in the palette
  330.     int numberOfEntries = (int)((bitmapOffset-14-size) / 4);
  331.     int sizeOfPalette = numberOfEntries*4;
  332.     palette = new byte[sizeOfPalette];
  333.     inputStream.read(palette, 0, sizeOfPalette);
  335.     if (palette != null || palette.length != 0) {
  336. properties.put("palette", palette);
  337.     }
  338.     
  339.     switch((int)csType) {
  340.     case LCS_CALIBRATED_RGB:
  341. // All the new fields are valid only for this case
  342. properties.put("color_space", "LCS_CALIBRATED_RGB");
  343. properties.put("redX", new Integer(redX));
  344. properties.put("redY", new Integer(redY));
  345. properties.put("redZ", new Integer(redZ));
  346. properties.put("greenX", new Integer(greenX));
  347. properties.put("greenY", new Integer(greenY));
  348. properties.put("greenZ", new Integer(greenZ));
  349. properties.put("blueX", new Integer(blueX));
  350. properties.put("blueY", new Integer(blueY));
  351. properties.put("blueZ", new Integer(blueZ));
  352. properties.put("gamma_red", new Long(gammaRed));
  353. properties.put("gamma_green", new Long(gammaGreen));
  354. properties.put("gamma_blue", new Long(gammaBlue));
  356. // break;
  357. throw new 
  358.  RuntimeException(JaiI18N.getString("BMPImageDecoder2"));
  360.     case LCS_sRGB:
  361. // Default Windows color space
  362. properties.put("color_space", "LCS_sRGB");
  363. break;
  365.     case LCS_CMYK:
  366. properties.put("color_space", "LCS_CMYK");
  367. //     break;
  368. throw new 
  369.  RuntimeException(JaiI18N.getString("BMPImageDecoder2"));
  370.     }
  371.     
  372.     if (bitsPerPixel == 1) {
  373. imageType = VERSION_4_1_BIT;
  374.     } else if (bitsPerPixel == 4) {
  375. imageType = VERSION_4_4_BIT;
  376.     } else if (bitsPerPixel == 8) {
  377. imageType = VERSION_4_8_BIT;
  378.     } else if (bitsPerPixel == 16) {
  379. imageType = VERSION_4_16_BIT;
  380. if ((int)compression == BI_RGB) {
  381.     redMask = 0x7C00;
  382.     greenMask = 0x3E0;
  383.     blueMask = 0x1F;
  384. }
  385.     } else if (bitsPerPixel == 24) {
  386. imageType = VERSION_4_24_BIT;
  387.     } else if (bitsPerPixel == 32) {
  388. imageType = VERSION_4_32_BIT;
  389. if ((int)compression == BI_RGB) {
  390.     redMask   = 0x00FF0000;
  391.     greenMask = 0x0000FF00;
  392.     blueMask  = 0x000000FF;
  393. }
  394.     }
  395.     
  396.     properties.put("red_mask", new Integer(redMask));
  397.     properties.put("green_mask", new Integer(greenMask));
  398.     properties.put("blue_mask", new Integer(blueMask));
  399.     properties.put("alpha_mask", new Integer(alphaMask));
  400.     
  401.     computeShifts();
  402. } else {
  403.     properties.put("bmp_version", "BMP v. 5.x");
  404.     throw new 
  405. RuntimeException(JaiI18N.getString("BMPImageDecoder4"));
  406. }
  407.     }
  408. } catch (IOException ioe) {
  409.     throw new RuntimeException(JaiI18N.getString("BMPImageDecoder5"));
  410. }
  411.     
  412. if (height > 0) {
  413.     // bottom up image
  414.     isBottomUp = true;
  415. } else {
  416.     // top down image
  417.     isBottomUp = false;
  418.     height = Math.abs(height);
  419. }
  421. // Reset Image Layout so there's only one tile.
  422. tileWidth = width;
  423. tileHeight = height;
  425. // When number of bitsPerPixel is <= 8, we use IndexColorModel.
  426.   if (bitsPerPixel == 1 || bitsPerPixel == 4 || bitsPerPixel == 8) {
  428.     numBands = 1;
  430.     if (bitsPerPixel == 8) {
  431. sampleModel = 
  432.     RasterFactory.createPixelInterleavedSampleModel(
  433.    DataBuffer.TYPE_BYTE,
  434.    width, height, 
  435.    numBands);
  436.     } else {
  437. // 1 and 4 bit pixels can be stored in a packed format.
  438. sampleModel = 
  439.     new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, 
  440.     width, height,
  441.     bitsPerPixel);
  442.     }
  444.     // Create IndexColorModel from the palette.
  445.     byte r[], g[], b[];
  446.     int size;
  447.     if (imageType == VERSION_2_1_BIT || 
  448. imageType == VERSION_2_4_BIT ||
  449. imageType == VERSION_2_8_BIT) {
  451. size = palette.length/3;
  453. if (size > 256) {
  454.     size = 256;
  455. }
  457. int off;
  458. r = new byte[size];
  459. g = new byte[size];
  460. b = new byte[size];
  461. for (int i=0; i<size; i++) {
  462.     off = 3 * i;
  463.     b[i] = palette[off];
  464.     g[i] = palette[off+1];
  465.     r[i] = palette[off+2];
  466. }
  467.     } else {
  468. size = palette.length/4;
  470. if (size > 256) {
  471.     size = 256;
  472. }
  474. int off;
  475. r = new byte[size];
  476. g = new byte[size];
  477. b = new byte[size];
  478. for (int i=0; i<size; i++) {
  479.     off = 4 * i;
  480.     b[i] = palette[off];
  481.     g[i] = palette[off+1];
  482.     r[i] = palette[off+2];
  483. }
  484.     }
  486.     colorModel = new IndexColorModel(bitsPerPixel, size, r, g, b);
  488. } else {
  489.     numBands = 3;
  490.     // Create SampleModel
  491.     sampleModel =
  492. RasterFactory.createPixelInterleavedSampleModel(
  493.                     DataBuffer.TYPE_BYTE, width, height, numBands);
  495.             colorModel =
  496.                 ImageCodec.createComponentColorModel(sampleModel);
  497.      }
  498.     }
  500.     // Deal with 1 Bit images using IndexColorModels
  501.     private void read1Bit(byte[] bdata, int paletteEntries) {
  503. int padding = 0;
  504. int bytesPerScanline = (int)Math.ceil((double)width/8.0);
  506. int remainder = bytesPerScanline % 4;
  507. if (remainder != 0) {
  508.     padding = 4 - remainder;
  509. }
  511. int imSize = (bytesPerScanline + padding) * height;
  513. // Read till we have the whole image
  514. byte values[] = new byte[imSize];
  515. try {
  516.     int bytesRead = 0;
  517.     while (bytesRead < imSize) {
  518. bytesRead += inputStream.read(values, bytesRead,
  519.       imSize - bytesRead);
  520.     }
  521. } catch (IOException ioe) {
  522.     throw new 
  523. RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  524. }
  526. if (isBottomUp) {
  528.     // Convert the bottom up image to a top down format by copying
  529.     // one scanline from the bottom to the top at a time.
  531.     for (int i=0; i<height; i++) {
  532.   System.arraycopy(values, 
  533.  imSize - (i+1)*(bytesPerScanline + padding),
  534.  bdata, 
  535.  i*bytesPerScanline, bytesPerScanline);
  536.     }
  537. } else {
  538.     
  539.    for (int i=0; i<height; i++) {
  540.   System.arraycopy(values, 
  541.  i * (bytesPerScanline + padding), 
  542.  bdata, 
  543.  i * bytesPerScanline, 
  544.  bytesPerScanline);
  545.     } 
  546. }
  547.     }
  548.     
  549.     // Method to read a 4 bit BMP image data
  550.     private void read4Bit(byte[] bdata, int paletteEntries) {
  552. // Padding bytes at the end of each scanline
  553. int padding = 0;
  555. int bytesPerScanline = (int)Math.ceil((double)width/2.0);
  556. int remainder = bytesPerScanline % 4;
  557. if (remainder != 0) {
  558.     padding = 4 - remainder;
  559. }
  561. int imSize = (bytesPerScanline + padding) * height;
  563. // Read till we have the whole image
  564. byte values[] = new byte[imSize];
  565. try {
  566.     int bytesRead = 0;
  567.     while (bytesRead < imSize) {
  568. bytesRead += inputStream.read(values, bytesRead,
  569.       imSize - bytesRead);
  570.     }
  571. } catch (IOException ioe) {
  572.     throw new 
  573. RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  574. }
  576. if (isBottomUp) {
  577.     
  578.     // Convert the bottom up image to a top down format by copying
  579.     // one scanline from the bottom to the top at a time.
  580.     for (int i=0; i<height; i++) {
  581.   System.arraycopy(values, 
  582.  imSize - (i+1)*(bytesPerScanline + padding), 
  583.  bdata, 
  584.  i*bytesPerScanline, 
  585.  bytesPerScanline);
  586.     }
  587. } else {
  588.     for (int i=0; i<height; i++) {
  589.   System.arraycopy(values, 
  590.  i * (bytesPerScanline + padding), 
  591.  bdata, 
  592.  i * bytesPerScanline, 
  593.  bytesPerScanline);
  594.     }
  595. }
  596.     }
  597.     
  598.     // Method to read 8 bit BMP image data
  599.     private void read8Bit(byte[] bdata, int paletteEntries) {
  601. // Padding bytes at the end of each scanline
  602. int padding = 0;
  604. // width * bitsPerPixel should be divisible by 32
  605. int bitsPerScanline = width * 8;
  606. if ( bitsPerScanline%32 != 0) {
  607.     padding = (bitsPerScanline/32 + 1)*32 - bitsPerScanline;
  608.     padding = (int)Math.ceil(padding/8.0);
  609. }
  611. int imSize = (width + padding) * height;
  613. // Read till we have the whole image
  614. byte values[] = new byte[imSize];
  615. try {
  616.     int bytesRead = 0;
  617.     while (bytesRead < imSize) {
  618. bytesRead += inputStream.read(values, bytesRead,
  619.       imSize - bytesRead);
  620.     }
  621. } catch (IOException ioe) {
  622.     throw new 
  623. RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  624. }
  626. if (isBottomUp) {
  628.     // Convert the bottom up image to a top down format by copying
  629.     // one scanline from the bottom to the top at a time.
  630.     for (int i=0; i<height; i++) {
  631.   System.arraycopy(values, 
  632.  imSize - (i+1) * (width + padding), 
  633.  bdata, 
  634.  i * width, 
  635.  width);
  636.     }
  637. } else {
  638.     for (int i=0; i<height; i++) {
  639.   System.arraycopy(values, 
  640.  i * (width + padding), 
  641.  bdata, 
  642.  i * width, 
  643.  width);
  644.     }
  645. }
  646.     }
  648.     // Method to read 24 bit BMP image data
  649.     private void read24Bit(byte[] bdata) {
  650. // Padding bytes at the end of each scanline
  651. int padding = 0;
  653. // width * bitsPerPixel should be divisible by 32
  654. int bitsPerScanline = width * 24;
  655. if ( bitsPerScanline%32 != 0) {
  656.     padding = (bitsPerScanline/32 + 1)*32 - bitsPerScanline;
  657.     padding = (int)Math.ceil(padding/8.0);
  658. }
  660. int imSize = (int)imageSize;
  661. if (imSize == 0) {
  662.     imSize = (int)(bitmapFileSize - bitmapOffset);
  663. }
  665. // Read till we have the whole image
  666. byte values[] = new byte[imSize];
  667. try {
  668.     int bytesRead = 0;
  669.     while (bytesRead < imSize) {
  670. bytesRead += inputStream.read(values, bytesRead,
  671.       imSize - bytesRead);
  672.     }
  673. } catch (IOException ioe) {
  674.     // throw new RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  675.     throw new RuntimeException(ioe.getMessage());
  676. }
  678. int l=0, count;
  680. if (isBottomUp) {
  681.     int max = width*height*3-1;
  682.     
  683.     count = -padding;
  684.     for (int i=0; i<height; i++) {
  685. l = max - (i+1)*width*3 + 1;
  686. count += padding;
  687. for (int j=0; j<width; j++) {
  688.     bdata[l++] = values[count++];
  689.     bdata[l++] = values[count++];
  690.     bdata[l++] = values[count++];
  691. }
  692.     }
  693. } else {
  694.     count = -padding;
  695.     for (int i=0; i<height; i++) {
  696. count += padding;
  697. for (int j=0; j<width; j++) {
  698.     bdata[l++] = values[count++];
  699.     bdata[l++] = values[count++];
  700.     bdata[l++] = values[count++];
  701. }
  702.     }
  703. }
  704.     }
  706.     private void read16Bit(byte bdata[]) {
  707. // Padding bytes at the end of each scanline
  708. int padding = 0;
  710. // width * bitsPerPixel should be divisible by 32
  711. int bitsPerScanline = width * 16;
  712. if ( bitsPerScanline%32 != 0) {
  713.     padding = (bitsPerScanline/32 + 1)*32 - bitsPerScanline;
  714.     padding = (int)Math.ceil(padding/8.0);
  715. }
  717. int imSize = (int)imageSize;
  718. if (imSize == 0) {
  719.     imSize = (int)(bitmapFileSize - bitmapOffset);
  720. }
  722. int l=0;
  724. try {
  725.     if (isBottomUp) {
  726. int max = width*height*3-1;
  728. for (int i=0; i<height; i++) {
  729.     l = max - (i+1)*width*3 + 1;
  730.     for (int j=0; j<width; j++) {
  731. int value = readWord(inputStream);
  733. bdata[l++] = (byte)((value & blueMask) >> blueBits);
  734. bdata[l++] = (byte)((value & greenMask) >> greenBits);
  735. bdata[l++] = (byte)((value & redMask) >> redBits);
  736.     }
  737.     for (int m=0; m<padding; m++) {
  738. inputStream.read();
  739.     }
  740. }
  741.     } else {
  742. for (int i=0; i<height; i++) {
  743.     for (int j=0; j<width; j++) {
  744. int value = readWord(inputStream);
  745. bdata[l++] = (byte)((value & blueMask) >> blueBits);
  746. bdata[l++] = (byte)((value & greenMask) >> greenBits);
  747. bdata[l++] = (byte)((value & redMask) >> redBits);
  748.     }
  749.     for (int m=0; m<padding; m++) {
  750. inputStream.read();
  751.     }
  752. }
  753.     }
  754. } catch (IOException ioe) {
  755.     throw new RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  756. }
  757.     }
  759.     private void read32Bit(byte bdata[]) {
  760. int imSize = (int)imageSize;
  761. if (imSize == 0) {
  762.     imSize = (int)(bitmapFileSize - bitmapOffset);
  763. }
  765. int l=0;
  767. try {
  768.     if (isBottomUp) {
  769. int max = width*height*3-1;
  771. for (int i=0; i<height; i++) {
  772.     l = max - (i+1)*width*3 + 1;
  773.     for (int j=0; j<width; j++) {
  774. int value = (int)readDWord(inputStream);
  776. bdata[l++] = (byte)((value & blueMask) >> blueBits);
  777. bdata[l++] = (byte)((value & greenMask) >> greenBits);
  778. bdata[l++] = (byte)((value & redMask) >> redBits);
  779.     }
  780. }
  781.     } else {
  782. for (int i=0; i<height; i++) {
  783.     for (int j=0; j<width; j++) {
  784. int value = (int)readDWord(inputStream);
  785. bdata[l++] = (byte)((value & blueMask) >> blueBits);
  786. bdata[l++] = (byte)((value & greenMask) >> greenBits);
  787. bdata[l++] = (byte)((value & redMask) >> redBits);
  788.     }
  789. }
  790.     }
  791. } catch (IOException ioe) {
  792.     throw new RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  793. }
  794.     }
  795.     
  796.     private void readRLE8(byte bdata[]) {
  798. // If imageSize field is not provided, calculate it.
  799. int imSize = (int)imageSize;
  800. if (imSize == 0) {
  801.     imSize = (int)(bitmapFileSize - bitmapOffset);
  802. }
  804. int padding = 0;
  805. // If width is not 32 bit aligned, then while uncompressing each 
  806. // scanline will have padding bytes, calculate the amount of padding
  807. int remainder = width % 4;
  808. if (remainder != 0) {
  809.     padding = 4 - remainder;
  810. }
  812. // Read till we have the whole image
  813. byte values[] = new byte[imSize];
  814. try {
  815.     int bytesRead = 0;
  816.     while (bytesRead < imSize) {
  817. bytesRead += inputStream.read(values, bytesRead,
  818.       imSize - bytesRead);
  819.     }
  820. } catch (IOException ioe) {
  821.     throw new RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  822. }
  824. // Since data is compressed, decompress it
  825. byte val[] = decodeRLE8(imSize, padding, values);
  827. // Uncompressed data does not have any padding
  828.         imSize = width * height;
  830. if (isBottomUp) {
  832.     // Convert the bottom up image to a top down format by copying
  833.     // one scanline from the bottom to the top at a time.
  834.     // int bytesPerScanline = (int)Math.ceil((double)width/8.0);
  835.     int bytesPerScanline = width;
  836.     for (int i=0; i<height; i++) {
  837. System.arraycopy(val, 
  838.  imSize - (i+1)*(bytesPerScanline), 
  839.  bdata, 
  840.  i*bytesPerScanline, bytesPerScanline);
  841.     }
  842.     
  843. } else {
  844.     
  845.     bdata = val;
  846. }
  847.     }
  848.     
  849.     private byte[] decodeRLE8(int imSize, int padding, byte values[]) {
  851. byte val[] = new byte[width * height];
  852. int count = 0, l = 0;
  853. int value;
  854. boolean flag = false;
  856. while (count != imSize) {
  858.     value = values[count++] & 0xff;
  860.     if (value == 0) {
  861. switch(values[count++] & 0xff) {
  863. case 0:
  864.     // End-of-scanline marker
  865.     break;
  867. case 1:
  868.     // End-of-RLE marker
  869.     flag = true;
  870.     break;
  872. case 2:
  873.     // delta or vector marker
  874.     int xoff = values[count++] & 0xff;
  875.     int yoff = values[count] & 0xff;
  876.     // Move to the position xoff, yoff down
  877.     l += xoff + yoff*width;
  878.     break;
  879.       
  880. default:
  881.     int end = values[count-1] & 0xff;
  882.     for (int i=0; i<end; i++) {
  883. val[l++] = (byte)(values[count++] & 0xff);
  884.     }
  886.     // Whenever end pixels can fit into odd number of bytes,
  887.     // an extra padding byte will be present, so skip that.
  888.     if (!isEven(end)) {
  889. count++;
  890.     }
  891. }
  892.     } else {
  893. for (int i=0; i<value; i++) {
  894.     val[l++] = (byte)(values[count] & 0xff);
  895. }
  896. count++;
  897.     }
  899.     // If End-of-RLE data, then exit the while loop
  900.     if (flag) {
  901. break;
  902.     }
  903. }
  905. return val;
  906.     }
  908.     private int[] readRLE4() {
  910. // If imageSize field is not specified, calculate it.
  911. int imSize = (int)imageSize;
  912. if (imSize == 0) {
  913.     imSize = (int)(bitmapFileSize - bitmapOffset);
  914. }
  916. int padding = 0;
  917. // If width is not 32 byte aligned, then while uncompressing each 
  918. // scanline will have padding bytes, calculate the amount of padding
  919. int remainder = width % 4;
  920. if (remainder != 0) {
  921.     padding = 4 - remainder;
  922. }
  924. // Read till we have the whole image
  925. int values[] = new int[imSize];
  926. try {
  927.     for (int i=0; i<imSize; i++) {
  928. values[i] = inputStream.read();
  929.     }
  930. } catch(IOException ioe) {
  931.     throw new RuntimeException(JaiI18N.getString("BMPImageDecoder6"));
  932. }
  934. // Decompress the RLE4 compressed data.
  935. int val[] = decodeRLE4(imSize, padding, values);
  937. // Invert it as it is bottom up format.
  938. if (isBottomUp) {
  940.     int inverted[] = val;
  941.     val = new int[width * height];
  942.     int l = 0, index, lineEnd;
  944.     for (int i = height-1; i >= 0; i--) {
  945. index = i * width;
  946. lineEnd = l + width;
  947. while(l != lineEnd) {
  948.     val[l++] = inverted[index++];
  949. }
  950.     }
  951. }
  953. // This array will be used to call setPixels as the decompression
  954. // had unpacked the 4bit pixels each into an int.
  955. return val;
  956.     }
  958.     private int[] decodeRLE4(int imSize, int padding, int values[]) {
  960. int val[] = new int[width * height];
  961.   int count = 0, l = 0;
  962. int value;
  963. boolean flag = false;
  965. while (count != imSize) {
  967.     value = values[count++];
  969.     if (value == 0) {
  971. // Absolute mode
  972. switch(values[count++]) {
  974. case 0:
  975.     // End-of-scanline marker
  976.     break;
  978. case 1:
  979.     // End-of-RLE marker
  980.     flag = true;
  981.     break;
  983. case 2:
  984.     // delta or vector marker
  985.     int xoff = values[count++];
  986.     int yoff = values[count];
  987.     // Move to the position xoff, yoff down
  988.     l += xoff + yoff*width;
  989.     break;
  990.       
  991. default:
  992.     int end = values[count-1];
  993.     for (int i=0; i<end; i++) {
  994. val[l++] = isEven(i) ? (values[count] & 0xf0) >> 4 
  995.                      : (values[count++] & 0x0f);
  996.     }
  998.     // When end is odd, the above for loop does not
  999.     // increment count, so do it now.
  1000.     if (!isEven(end)) {
  1001. count++;
  1002.     } 
  1003.     
  1004.     // Whenever end pixels can fit into odd number of bytes,
  1005.     // an extra padding byte will be present, so skip that.
  1006.     if ( !isEven((int)Math.ceil(end/2)) ) {
  1007. count++;
  1008.     }
  1009.     break;
  1010. }
  1011.     } else {
  1012. // Encoded mode
  1013. int alternate[] = { (values[count] & 0xf0) >> 4, 
  1014.     values[count] & 0x0f };
  1015. for (int i=0; i<value; i++) {
  1016.     val[l++] = alternate[i%2];
  1017. }
  1019. count++;
  1020.     }
  1022.     // If End-of-RLE data, then exit the while loop
  1023.     if (flag) {
  1024. break;
  1025.     }
  1026.     
  1027. }
  1029. return val;
  1030.     }
  1032.     private boolean isEven(int number) {
  1033. return (number%2 == 0 ? true : false);
  1034.     }
  1035.     
  1036.     private void computeShifts() {
  1037. redBits = computeShift(redMask);
  1038. greenBits = computeShift(greenMask);
  1039. blueBits = computeShift(blueMask);
  1040.     }
  1042.     private int computeShift(int hexNumber) {
  1043. int factor = 0x1;
  1044. int result = 0, count=0;
  1046. while (result == 0) {
  1047.     result = hexNumber & factor;
  1048.     count++;
  1049.     factor = factor << 1;
  1050. }
  1052. return (count-1);
  1053.     }
  1054.     
  1055.     // Windows defined data type reading methods - everything is little endian
  1057.     // Unsigned 8 bits
  1058.     private int readUnsignedByte(InputStream stream) throws IOException {
  1059. return (stream.read() & 0xff);
  1060.     }
  1062.     // Unsigned 2 bytes
  1063.     private int readUnsignedShort(InputStream stream) throws IOException {
  1064. int b1 = readUnsignedByte(stream);
  1065. int b2 = readUnsignedByte(stream);
  1066. return ((b2 << 8) | b1) & 0xffff;
  1067.     }
  1069.     // Signed 16 bits
  1070.     private int readShort(InputStream stream) throws IOException {
  1071. int b1 = readUnsignedByte(stream);
  1072. int b2 = readUnsignedByte(stream);
  1073. return (b2 << 8) | b1;
  1074.     }
  1076.     // Unsigned 16 bits
  1077.     private int readWord(InputStream stream) throws IOException {
  1078. return readUnsignedShort(stream);
  1079.     }
  1081.     // Unsigned 4 bytes
  1082.     private long readUnsignedInt(InputStream stream) throws IOException {
  1083. int b1 = readUnsignedByte(stream);
  1084.         int b2 = readUnsignedByte(stream);
  1085.         int b3 = readUnsignedByte(stream);
  1086.         int b4 = readUnsignedByte(stream);
  1087. long l = (long)((b4 << 24) | (b3 << 16) | (b2 << 8) | b1);
  1088. return l & 0xffffffff;
  1089.     }
  1091.     // Signed 4 bytes
  1092.     private int readInt(InputStream stream) throws IOException {
  1093. int b1 = readUnsignedByte(stream);
  1094.         int b2 = readUnsignedByte(stream);
  1095.         int b3 = readUnsignedByte(stream);
  1096.         int b4 = readUnsignedByte(stream);
  1097. return (b4 << 24) | (b3 << 16) | (b2 << 8) | b1;
  1098.     }
  1099.     
  1100.     // Unsigned 4 bytes 
  1101.     private long readDWord(InputStream stream) throws IOException {
  1102. return readUnsignedInt(stream);
  1103.     }
  1105.     // 32 bit signed value
  1106.     private int readLong(InputStream stream) throws IOException {
  1107. return readInt(stream);
  1108.     }
  1110.     private synchronized Raster computeTile(int tileX, int tileY) {
  1111.         if (theTile != null) {
  1112.             return theTile;
  1113.         }
  1115. // Create a new tile
  1116. Point org = new Point(tileXToX(tileX), tileYToY(tileY));
  1117. WritableRaster tile = 
  1118.     RasterFactory.createWritableRaster(sampleModel, org);
  1119. DataBufferByte buffer = (DataBufferByte)tile.getDataBuffer();
  1120. byte bdata[] = buffer.getData();
  1122. // There should only be one tile.
  1123. switch(imageType) {
  1124.     
  1125. case VERSION_2_1_BIT:
  1126.     // no compression
  1127.     read1Bit(bdata, 3);
  1128.     break;
  1129.     
  1130. case VERSION_2_4_BIT:
  1131.     // no compression
  1132.     read4Bit(bdata, 3);
  1133.     break;
  1134.     
  1135. case VERSION_2_8_BIT:
  1136.     // no compression
  1137.     read8Bit(bdata, 3);
  1138.     break;
  1139.     
  1140. case VERSION_2_24_BIT:
  1141.     // no compression
  1142.     read24Bit(bdata);
  1143.     break;
  1144.     
  1145. case VERSION_3_1_BIT:
  1146.     // 1-bit images cannot be compressed.
  1147.     read1Bit(bdata, 4);
  1148.     break;
  1149.     
  1150. case VERSION_3_4_BIT:
  1151.     switch((int)compression) {
  1152.     case BI_RGB:
  1153. read4Bit(bdata, 4);
  1154. break;
  1156.     case BI_RLE4:
  1157. int pixels[] = readRLE4();
  1158. tile.setPixels(0, 0, width, height, pixels);
  1159. break;
  1161.     default:
  1162. throw new 
  1163.     RuntimeException(JaiI18N.getString("BMPImageDecoder3"));
  1164.     }
  1165.     break;
  1167. case VERSION_3_8_BIT:
  1168.     switch((int)compression) {
  1169.     case BI_RGB:
  1170. read8Bit(bdata, 4);
  1171.     break;
  1172.     
  1173.     case BI_RLE8:
  1174. readRLE8(bdata);
  1175. break;
  1176.     
  1177.     default:
  1178. throw new 
  1179.     RuntimeException(JaiI18N.getString("BMPImageDecoder3"));
  1180.     }
  1182.     break;
  1183.     
  1184. case VERSION_3_24_BIT:
  1185.     // 24-bit images are not compressed
  1186.     read24Bit(bdata);
  1187.     break;
  1188.     
  1189. case VERSION_3_NT_16_BIT:
  1190.     read16Bit(bdata);
  1191.     break;
  1192.     
  1193. case VERSION_3_NT_32_BIT:
  1194.     read32Bit(bdata);
  1195.     break;
  1196.     
  1197. case VERSION_4_1_BIT:
  1198.     read1Bit(bdata, 4);
  1199.     break;
  1201. case VERSION_4_4_BIT:
  1202.     switch((int)compression) {
  1204.     case BI_RGB:
  1205. read4Bit(bdata, 4);
  1206. break;
  1208.     case BI_RLE4:
  1209. int pixels[] = readRLE4();
  1210. tile.setPixels(0, 0, width, height, pixels);
  1211. break;
  1213.     default:
  1214. throw new 
  1215.     RuntimeException(JaiI18N.getString("BMPImageDecoder3"));
  1216.     }
  1218. case VERSION_4_8_BIT:
  1219.     switch((int)compression) {
  1221.     case BI_RGB:
  1222. read8Bit(bdata, 4);
  1223. break;
  1225.     case BI_RLE8:
  1226. readRLE8(bdata);
  1227. break;
  1229.     default:
  1230. throw new 
  1231.     RuntimeException(JaiI18N.getString("BMPImageDecoder3"));
  1232.     }
  1233.     break;
  1234.     
  1235. case VERSION_4_16_BIT:
  1236.     read16Bit(bdata);
  1237.     break;
  1238.     
  1239. case VERSION_4_24_BIT:
  1240.     read24Bit(bdata);
  1241.     break;
  1242.     
  1243. case VERSION_4_32_BIT:
  1244.     read32Bit(bdata);
  1245.     break;
  1246. }
  1248.         theTile = tile;
  1250. return tile;
  1251.     }
  1253.     public synchronized Raster getTile(int tileX, int tileY) {
  1254.         if ((tileX != 0) || (tileY != 0)) {
  1255.             throw new
  1256. IllegalArgumentException(JaiI18N.getString("BMPImageDecoder7"));
  1257.         }
  1258.         return computeTile(tileX, tileY);
  1259.     }
  1260. }