rev 9343 : 8033716: Fix raw and unchecked lint warnings in com.sun.imageio
Reviewed-by: darcy, prr, bae

   1 /*
   2  * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.imageio.plugins.bmp;
  27 
  28 import java.awt.Point;
  29 import java.awt.Rectangle;
  30 import java.awt.Transparency;
  31 import java.awt.color.ColorSpace;
  32 import java.awt.color.ICC_ColorSpace;
  33 import java.awt.color.ICC_Profile;
  34 import java.awt.image.BufferedImage;
  35 import java.awt.image.ColorModel;
  36 import java.awt.image.ComponentColorModel;
  37 import java.awt.image.ComponentSampleModel;
  38 import java.awt.image.DataBuffer;
  39 import java.awt.image.DataBufferByte;
  40 import java.awt.image.DataBufferInt;
  41 import java.awt.image.DataBufferUShort;
  42 import java.awt.image.DirectColorModel;
  43 import java.awt.image.IndexColorModel;
  44 import java.awt.image.MultiPixelPackedSampleModel;
  45 import java.awt.image.PixelInterleavedSampleModel;
  46 import java.awt.image.Raster;
  47 import java.awt.image.SampleModel;
  48 import java.awt.image.SinglePixelPackedSampleModel;
  49 import java.awt.image.WritableRaster;
  50 
  51 import javax.imageio.IIOException;
  52 import javax.imageio.ImageIO;
  53 import javax.imageio.ImageReader;
  54 import javax.imageio.ImageReadParam;
  55 import javax.imageio.ImageTypeSpecifier;
  56 import javax.imageio.metadata.IIOMetadata;
  57 import javax.imageio.spi.ImageReaderSpi;
  58 import javax.imageio.stream.ImageInputStream;
  59 import javax.imageio.event.IIOReadProgressListener;
  60 import javax.imageio.event.IIOReadUpdateListener;
  61 import javax.imageio.event.IIOReadWarningListener;
  62 
  63 import java.io.*;
  64 import java.nio.*;
  65 import java.security.AccessController;
  66 import java.security.PrivilegedAction;
  67 import java.util.ArrayList;
  68 import java.util.Iterator;
  69 import java.util.StringTokenizer;
  70 
  71 import com.sun.imageio.plugins.common.ImageUtil;
  72 import com.sun.imageio.plugins.common.I18N;
  73 
  74 /** This class is the Java Image IO plugin reader for BMP images.
  75  *  It may subsample the image, clip the image, select sub-bands,
  76  *  and shift the decoded image origin if the proper decoding parameter
  77  *  are set in the provided <code>ImageReadParam</code>.
  78  *
  79  *  This class supports Microsoft Windows Bitmap Version 3-5,
  80  *  as well as OS/2 Bitmap Version 2.x (for single-image BMP file).
  81  */
  82 public class BMPImageReader extends ImageReader implements BMPConstants {
  83     // BMP Image types
  84     private static final int VERSION_2_1_BIT = 0;
  85     private static final int VERSION_2_4_BIT = 1;
  86     private static final int VERSION_2_8_BIT = 2;
  87     private static final int VERSION_2_24_BIT = 3;
  88 
  89     private static final int VERSION_3_1_BIT = 4;
  90     private static final int VERSION_3_4_BIT = 5;
  91     private static final int VERSION_3_8_BIT = 6;
  92     private static final int VERSION_3_24_BIT = 7;
  93 
  94     private static final int VERSION_3_NT_16_BIT = 8;
  95     private static final int VERSION_3_NT_32_BIT = 9;
  96 
  97     private static final int VERSION_4_1_BIT = 10;
  98     private static final int VERSION_4_4_BIT = 11;
  99     private static final int VERSION_4_8_BIT = 12;
 100     private static final int VERSION_4_16_BIT = 13;
 101     private static final int VERSION_4_24_BIT = 14;
 102     private static final int VERSION_4_32_BIT = 15;
 103 
 104     private static final int VERSION_3_XP_EMBEDDED = 16;
 105     private static final int VERSION_4_XP_EMBEDDED = 17;
 106     private static final int VERSION_5_XP_EMBEDDED = 18;
 107 
 108     // BMP variables
 109     private long bitmapFileSize;
 110     private long bitmapOffset;
 111     private long compression;
 112     private long imageSize;
 113     private byte palette[];
 114     private int imageType;
 115     private int numBands;
 116     private boolean isBottomUp;
 117     private int bitsPerPixel;
 118     private int redMask, greenMask, blueMask, alphaMask;
 119 
 120     private SampleModel sampleModel, originalSampleModel;
 121     private ColorModel colorModel, originalColorModel;
 122 
 123     /** The input stream where reads from */
 124     private ImageInputStream iis = null;
 125 
 126     /** Indicates whether the header is read. */
 127     private boolean gotHeader = false;
 128 
 129     /** The original image width. */
 130     private int width;
 131 
 132     /** The original image height. */
 133     private int height;
 134 
 135     /** The destination region. */
 136     private Rectangle destinationRegion;
 137 
 138     /** The source region. */
 139     private Rectangle sourceRegion;
 140 
 141     /** The metadata from the stream. */
 142     private BMPMetadata metadata;
 143 
 144     /** The destination image. */
 145     private BufferedImage bi;
 146 
 147     /** Indicates whether subsampled, subregion is required, and offset is
 148      *  defined
 149      */
 150     private boolean noTransform = true;
 151 
 152     /** Indicates whether subband is selected. */
 153     private boolean seleBand = false;
 154 
 155     /** The scaling factors. */
 156     private int scaleX, scaleY;
 157 
 158     /** source and destination bands. */
 159     private int[] sourceBands, destBands;
 160 
 161     /** Constructs <code>BMPImageReader</code> from the provided
 162      *  <code>ImageReaderSpi</code>.
 163      */
 164     public BMPImageReader(ImageReaderSpi originator) {
 165         super(originator);
 166     }
 167 
 168     /** Overrides the method defined in the superclass. */
 169     public void setInput(Object input,
 170                          boolean seekForwardOnly,
 171                          boolean ignoreMetadata) {
 172         super.setInput(input, seekForwardOnly, ignoreMetadata);
 173         iis = (ImageInputStream) input; // Always works
 174         if(iis != null)
 175             iis.setByteOrder(ByteOrder.LITTLE_ENDIAN);
 176         resetHeaderInfo();
 177     }
 178 
 179     /** Overrides the method defined in the superclass. */
 180     public int getNumImages(boolean allowSearch) throws IOException {
 181         if (iis == null) {
 182             throw new IllegalStateException(I18N.getString("GetNumImages0"));
 183         }
 184         if (seekForwardOnly && allowSearch) {
 185             throw new IllegalStateException(I18N.getString("GetNumImages1"));
 186         }
 187         return 1;
 188     }
 189 
 190     @Override
 191     public int getWidth(int imageIndex) throws IOException {
 192         checkIndex(imageIndex);
 193         try {
 194             readHeader();
 195         } catch (IllegalArgumentException e) {
 196             throw new IIOException(I18N.getString("BMPImageReader6"), e);
 197         }
 198         return width;
 199     }
 200 
 201     public int getHeight(int imageIndex) throws IOException {
 202         checkIndex(imageIndex);
 203         try {
 204             readHeader();
 205         } catch (IllegalArgumentException e) {
 206             throw new IIOException(I18N.getString("BMPImageReader6"), e);
 207         }
 208         return height;
 209     }
 210 
 211     private void checkIndex(int imageIndex) {
 212         if (imageIndex != 0) {
 213             throw new IndexOutOfBoundsException(I18N.getString("BMPImageReader0"));
 214         }
 215     }
 216 
 217     /**
 218      * Process the image header.
 219      *
 220      * @exception IllegalStateException if source stream is not set.
 221      *
 222      * @exception IOException if image stream is corrupted.
 223      *
 224      * @exception IllegalArgumentException if the image stream does not contain
 225      *             a BMP image, or if a sample model instance to describe the
 226      *             image can not be created.
 227      */
 228     protected void readHeader() throws IOException, IllegalArgumentException {
 229         if (gotHeader)
 230             return;
 231 
 232         if (iis == null) {
 233             throw new IllegalStateException("Input source not set!");
 234         }
 235         int profileData = 0, profileSize = 0;
 236 
 237         this.metadata = new BMPMetadata();
 238         iis.mark();
 239 
 240         // read and check the magic marker
 241         byte[] marker = new byte[2];
 242         iis.read(marker);
 243         if (marker[0] != 0x42 || marker[1] != 0x4d)
 244             throw new IllegalArgumentException(I18N.getString("BMPImageReader1"));
 245 
 246         // Read file size
 247         bitmapFileSize = iis.readUnsignedInt();
 248         // skip the two reserved fields
 249         iis.skipBytes(4);
 250 
 251         // Offset to the bitmap from the beginning
 252         bitmapOffset = iis.readUnsignedInt();
 253         // End File Header
 254 
 255         // Start BitmapCoreHeader
 256         long size = iis.readUnsignedInt();
 257 
 258         if (size == 12) {
 259             width = iis.readShort();
 260             height = iis.readShort();
 261         } else {
 262             width = iis.readInt();
 263             height = iis.readInt();
 264         }
 265 
 266         metadata.width = width;
 267         metadata.height = height;
 268 
 269         int planes = iis.readUnsignedShort();
 270         bitsPerPixel = iis.readUnsignedShort();
 271 
 272         //metadata.colorPlane = planes;
 273         metadata.bitsPerPixel = (short)bitsPerPixel;
 274 
 275         // As BMP always has 3 rgb bands, except for Version 5,
 276         // which is bgra
 277         numBands = 3;
 278 
 279         if (size == 12) {
 280             // Windows 2.x and OS/2 1.x
 281             metadata.bmpVersion = VERSION_2;
 282 
 283             // Classify the image type
 284             if (bitsPerPixel == 1) {
 285                 imageType = VERSION_2_1_BIT;
 286             } else if (bitsPerPixel == 4) {
 287                 imageType = VERSION_2_4_BIT;
 288             } else if (bitsPerPixel == 8) {
 289                 imageType = VERSION_2_8_BIT;
 290             } else if (bitsPerPixel == 24) {
 291                 imageType = VERSION_2_24_BIT;
 292             }
 293 
 294             // Read in the palette
 295             int numberOfEntries = (int)((bitmapOffset - 14 - size) / 3);
 296             int sizeOfPalette = numberOfEntries*3;
 297             palette = new byte[sizeOfPalette];
 298             iis.readFully(palette, 0, sizeOfPalette);
 299             metadata.palette = palette;
 300             metadata.paletteSize = numberOfEntries;
 301         } else {
 302             compression = iis.readUnsignedInt();
 303             imageSize = iis.readUnsignedInt();
 304             long xPelsPerMeter = iis.readInt();
 305             long yPelsPerMeter = iis.readInt();
 306             long colorsUsed = iis.readUnsignedInt();
 307             long colorsImportant = iis.readUnsignedInt();
 308 
 309             metadata.compression = (int)compression;
 310             metadata.xPixelsPerMeter = (int)xPelsPerMeter;
 311             metadata.yPixelsPerMeter = (int)yPelsPerMeter;
 312             metadata.colorsUsed = (int)colorsUsed;
 313             metadata.colorsImportant = (int)colorsImportant;
 314 
 315             if (size == 40) {
 316                 // Windows 3.x and Windows NT
 317                 switch((int)compression) {
 318 
 319                 case BI_JPEG:
 320                 case BI_PNG:
 321                     metadata.bmpVersion = VERSION_3;
 322                     imageType = VERSION_3_XP_EMBEDDED;
 323                     break;
 324 
 325                 case BI_RGB:  // No compression
 326                 case BI_RLE8:  // 8-bit RLE compression
 327                 case BI_RLE4:  // 4-bit RLE compression
 328 
 329                     // Read in the palette
 330                     if (bitmapOffset < (size + 14)) {
 331                         throw new IIOException(I18N.getString("BMPImageReader7"));
 332                     }
 333                     int numberOfEntries = (int)((bitmapOffset-14-size) / 4);
 334                     int sizeOfPalette = numberOfEntries * 4;
 335                     palette = new byte[sizeOfPalette];
 336                     iis.readFully(palette, 0, sizeOfPalette);
 337 
 338                     metadata.palette = palette;
 339                     metadata.paletteSize = numberOfEntries;
 340 
 341                     if (bitsPerPixel == 1) {
 342                         imageType = VERSION_3_1_BIT;
 343                     } else if (bitsPerPixel == 4) {
 344                         imageType = VERSION_3_4_BIT;
 345                     } else if (bitsPerPixel == 8) {
 346                         imageType = VERSION_3_8_BIT;
 347                     } else if (bitsPerPixel == 24) {
 348                         imageType = VERSION_3_24_BIT;
 349                     } else if (bitsPerPixel == 16) {
 350                         imageType = VERSION_3_NT_16_BIT;
 351 
 352                         redMask = 0x7C00;
 353                         greenMask = 0x3E0;
 354                         blueMask =  (1 << 5) - 1;// 0x1F;
 355                         metadata.redMask = redMask;
 356                         metadata.greenMask = greenMask;
 357                         metadata.blueMask = blueMask;
 358                     } else if (bitsPerPixel == 32) {
 359                         imageType = VERSION_3_NT_32_BIT;
 360                         redMask   = 0x00FF0000;
 361                         greenMask = 0x0000FF00;
 362                         blueMask  = 0x000000FF;
 363                         metadata.redMask = redMask;
 364                         metadata.greenMask = greenMask;
 365                         metadata.blueMask = blueMask;
 366                     }
 367 
 368                     metadata.bmpVersion = VERSION_3;
 369                     break;
 370 
 371                 case BI_BITFIELDS:
 372 
 373                     if (bitsPerPixel == 16) {
 374                         imageType = VERSION_3_NT_16_BIT;
 375                     } else if (bitsPerPixel == 32) {
 376                         imageType = VERSION_3_NT_32_BIT;
 377                     }
 378 
 379                     // BitsField encoding
 380                     redMask = (int)iis.readUnsignedInt();
 381                     greenMask = (int)iis.readUnsignedInt();
 382                     blueMask = (int)iis.readUnsignedInt();
 383                     metadata.redMask = redMask;
 384                     metadata.greenMask = greenMask;
 385                     metadata.blueMask = blueMask;
 386 
 387                     if (colorsUsed != 0) {
 388                         // there is a palette
 389                         sizeOfPalette = (int)colorsUsed*4;
 390                         palette = new byte[sizeOfPalette];
 391                         iis.readFully(palette, 0, sizeOfPalette);
 392 
 393                         metadata.palette = palette;
 394                         metadata.paletteSize = (int)colorsUsed;
 395                     }
 396                     metadata.bmpVersion = VERSION_3_NT;
 397 
 398                     break;
 399                 default:
 400                     throw new
 401                         IIOException(I18N.getString("BMPImageReader2"));
 402                 }
 403             } else if (size == 108 || size == 124) {
 404                 // Windows 4.x BMP
 405                 if (size == 108)
 406                     metadata.bmpVersion = VERSION_4;
 407                 else if (size == 124)
 408                     metadata.bmpVersion = VERSION_5;
 409 
 410                 // rgb masks, valid only if comp is BI_BITFIELDS
 411                 redMask = (int)iis.readUnsignedInt();
 412                 greenMask = (int)iis.readUnsignedInt();
 413                 blueMask = (int)iis.readUnsignedInt();
 414                 // Only supported for 32bpp BI_RGB argb
 415                 alphaMask = (int)iis.readUnsignedInt();
 416                 long csType = iis.readUnsignedInt();
 417                 int redX = iis.readInt();
 418                 int redY = iis.readInt();
 419                 int redZ = iis.readInt();
 420                 int greenX = iis.readInt();
 421                 int greenY = iis.readInt();
 422                 int greenZ = iis.readInt();
 423                 int blueX = iis.readInt();
 424                 int blueY = iis.readInt();
 425                 int blueZ = iis.readInt();
 426                 long gammaRed = iis.readUnsignedInt();
 427                 long gammaGreen = iis.readUnsignedInt();
 428                 long gammaBlue = iis.readUnsignedInt();
 429 
 430                 if (size == 124) {
 431                     metadata.intent = iis.readInt();
 432                     profileData = iis.readInt();
 433                     profileSize = iis.readInt();
 434                     iis.skipBytes(4);
 435                 }
 436 
 437                 metadata.colorSpace = (int)csType;
 438 
 439                 if (csType == LCS_CALIBRATED_RGB) {
 440                     // All the new fields are valid only for this case
 441                     metadata.redX = redX;
 442                     metadata.redY = redY;
 443                     metadata.redZ = redZ;
 444                     metadata.greenX = greenX;
 445                     metadata.greenY = greenY;
 446                     metadata.greenZ = greenZ;
 447                     metadata.blueX = blueX;
 448                     metadata.blueY = blueY;
 449                     metadata.blueZ = blueZ;
 450                     metadata.gammaRed = (int)gammaRed;
 451                     metadata.gammaGreen = (int)gammaGreen;
 452                     metadata.gammaBlue = (int)gammaBlue;
 453                 }
 454 
 455                 // Read in the palette
 456                 int numberOfEntries = (int)((bitmapOffset-14-size) / 4);
 457                 int sizeOfPalette = numberOfEntries*4;
 458                 palette = new byte[sizeOfPalette];
 459                 iis.readFully(palette, 0, sizeOfPalette);
 460                 metadata.palette = palette;
 461                 metadata.paletteSize = numberOfEntries;
 462 
 463                 switch ((int)compression) {
 464                 case BI_JPEG:
 465                 case BI_PNG:
 466                     if (size == 108) {
 467                         imageType = VERSION_4_XP_EMBEDDED;
 468                     } else if (size == 124) {
 469                         imageType = VERSION_5_XP_EMBEDDED;
 470                     }
 471                     break;
 472                 default:
 473                     if (bitsPerPixel == 1) {
 474                         imageType = VERSION_4_1_BIT;
 475                     } else if (bitsPerPixel == 4) {
 476                         imageType = VERSION_4_4_BIT;
 477                     } else if (bitsPerPixel == 8) {
 478                         imageType = VERSION_4_8_BIT;
 479                     } else if (bitsPerPixel == 16) {
 480                         imageType = VERSION_4_16_BIT;
 481                         if ((int)compression == BI_RGB) {
 482                             redMask = 0x7C00;
 483                             greenMask = 0x3E0;
 484                             blueMask = 0x1F;
 485                         }
 486                     } else if (bitsPerPixel == 24) {
 487                         imageType = VERSION_4_24_BIT;
 488                     } else if (bitsPerPixel == 32) {
 489                         imageType = VERSION_4_32_BIT;
 490                         if ((int)compression == BI_RGB) {
 491                             redMask   = 0x00FF0000;
 492                             greenMask = 0x0000FF00;
 493                             blueMask  = 0x000000FF;
 494                         }
 495                     }
 496 
 497                     metadata.redMask = redMask;
 498                     metadata.greenMask = greenMask;
 499                     metadata.blueMask = blueMask;
 500                     metadata.alphaMask = alphaMask;
 501                 }
 502             } else {
 503                 throw new
 504                     IIOException(I18N.getString("BMPImageReader3"));
 505             }
 506         }
 507 
 508         if (height > 0) {
 509             // bottom up image
 510             isBottomUp = true;
 511         } else {
 512             // top down image
 513             isBottomUp = false;
 514             height = Math.abs(height);
 515         }
 516 
 517         // Reset Image Layout so there's only one tile.
 518         //Define the color space
 519         ColorSpace colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
 520         if (metadata.colorSpace == PROFILE_LINKED ||
 521             metadata.colorSpace == PROFILE_EMBEDDED) {
 522 
 523             iis.mark();
 524             iis.skipBytes(profileData - size);
 525             byte[] profile = new byte[profileSize];
 526             iis.readFully(profile, 0, profileSize);
 527             iis.reset();
 528 
 529             try {
 530                 if (metadata.colorSpace == PROFILE_LINKED &&
 531                     isLinkedProfileAllowed() &&
 532                     !isUncOrDevicePath(profile))
 533                 {
 534                     String path = new String(profile, "windows-1252");
 535 
 536                     colorSpace =
 537                         new ICC_ColorSpace(ICC_Profile.getInstance(path));
 538                 } else {
 539                     colorSpace =
 540                         new ICC_ColorSpace(ICC_Profile.getInstance(profile));
 541                 }
 542             } catch (Exception e) {
 543                 colorSpace = ColorSpace.getInstance(ColorSpace.CS_sRGB);
 544             }
 545         }
 546 
 547         if (bitsPerPixel == 0 ||
 548             compression == BI_JPEG || compression == BI_PNG )
 549         {
 550             // the colorModel and sampleModel will be initialzed
 551             // by the  reader of embedded image
 552             colorModel = null;
 553             sampleModel = null;
 554         } else if (bitsPerPixel == 1 || bitsPerPixel == 4 || bitsPerPixel == 8) {
 555             // When number of bitsPerPixel is <= 8, we use IndexColorModel.
 556             numBands = 1;
 557 
 558             if (bitsPerPixel == 8) {
 559                 int[] bandOffsets = new int[numBands];
 560                 for (int i = 0; i < numBands; i++) {
 561                     bandOffsets[i] = numBands -1 -i;
 562                 }
 563                 sampleModel =
 564                     new PixelInterleavedSampleModel(DataBuffer.TYPE_BYTE,
 565                                                     width, height,
 566                                                     numBands,
 567                                                     numBands * width,
 568                                                     bandOffsets);
 569             } else {
 570                 // 1 and 4 bit pixels can be stored in a packed format.
 571                 sampleModel =
 572                     new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE,
 573                                                     width, height,
 574                                                     bitsPerPixel);
 575             }
 576 
 577             // Create IndexColorModel from the palette.
 578             byte r[], g[], b[];
 579             if (imageType == VERSION_2_1_BIT ||
 580                 imageType == VERSION_2_4_BIT ||
 581                 imageType == VERSION_2_8_BIT) {
 582 
 583 
 584                 size = palette.length/3;
 585 
 586                 if (size > 256) {
 587                     size = 256;
 588                 }
 589 
 590                 int off;
 591                 r = new byte[(int)size];
 592                 g = new byte[(int)size];
 593                 b = new byte[(int)size];
 594                 for (int i=0; i<(int)size; i++) {
 595                     off = 3 * i;
 596                     b[i] = palette[off];
 597                     g[i] = palette[off+1];
 598                     r[i] = palette[off+2];
 599                 }
 600             } else {
 601                 size = palette.length/4;
 602 
 603                 if (size > 256) {
 604                     size = 256;
 605                 }
 606 
 607                 int off;
 608                 r = new byte[(int)size];
 609                 g = new byte[(int)size];
 610                 b = new byte[(int)size];
 611                 for (int i=0; i<size; i++) {
 612                     off = 4 * i;
 613                     b[i] = palette[off];
 614                     g[i] = palette[off+1];
 615                     r[i] = palette[off+2];
 616                 }
 617             }
 618 
 619             if (ImageUtil.isIndicesForGrayscale(r, g, b))
 620                 colorModel =
 621                     ImageUtil.createColorModel(null, sampleModel);
 622             else
 623                 colorModel = new IndexColorModel(bitsPerPixel, (int)size, r, g, b);
 624         } else if (bitsPerPixel == 16) {
 625             numBands = 3;
 626             sampleModel =
 627                 new SinglePixelPackedSampleModel(DataBuffer.TYPE_USHORT,
 628                                                  width, height,
 629                                                  new int[] {redMask, greenMask, blueMask});
 630 
 631             colorModel =
 632                 new DirectColorModel(colorSpace,
 633                                      16, redMask, greenMask, blueMask, 0,
 634                                      false, DataBuffer.TYPE_USHORT);
 635 
 636         } else if (bitsPerPixel == 32) {
 637             numBands = alphaMask == 0 ? 3 : 4;
 638 
 639             // The number of bands in the SampleModel is determined by
 640             // the length of the mask array passed in.
 641             int[] bitMasks = numBands == 3 ?
 642                 new int[] {redMask, greenMask, blueMask} :
 643                 new int[] {redMask, greenMask, blueMask, alphaMask};
 644 
 645                 sampleModel =
 646                     new SinglePixelPackedSampleModel(DataBuffer.TYPE_INT,
 647                                                      width, height,
 648                                                      bitMasks);
 649 
 650                 colorModel =
 651                     new DirectColorModel(colorSpace,
 652                                          32, redMask, greenMask, blueMask, alphaMask,
 653                                          false, DataBuffer.TYPE_INT);
 654         } else {
 655             numBands = 3;
 656             // Create SampleModel
 657             int[] bandOffsets = new int[numBands];
 658             for (int i = 0; i < numBands; i++) {
 659                 bandOffsets[i] = numBands -1 -i;
 660             }
 661 
 662             sampleModel =
 663                 new PixelInterleavedSampleModel(DataBuffer.TYPE_BYTE,
 664                                                 width, height,
 665                                                 numBands,
 666                                                 numBands * width,
 667                                                 bandOffsets);
 668 
 669             colorModel =
 670                 ImageUtil.createColorModel(colorSpace, sampleModel);
 671         }
 672 
 673         originalSampleModel = sampleModel;
 674         originalColorModel = colorModel;
 675 
 676         // Reset to the start of bitmap; then jump to the
 677         //start of image data
 678         iis.reset();
 679         iis.skipBytes(bitmapOffset);
 680         gotHeader = true;
 681     }
 682 
 683     public Iterator getImageTypes(int imageIndex)
 684       throws IOException {
 685         checkIndex(imageIndex);
 686         try {
 687             readHeader();
 688         } catch (IllegalArgumentException e) {
 689             throw new IIOException(I18N.getString("BMPImageReader6"), e);
 690         }
 691         ArrayList list = new ArrayList(1);
 692         list.add(new ImageTypeSpecifier(originalColorModel,
 693                                         originalSampleModel));
 694         return list.iterator();
 695     }
 696 
 697     public ImageReadParam getDefaultReadParam() {
 698         return new ImageReadParam();
 699     }
 700 
 701     public IIOMetadata getImageMetadata(int imageIndex)
 702       throws IOException {
 703         checkIndex(imageIndex);
 704         if (metadata == null) {
 705             try {
 706                 readHeader();
 707             } catch (IllegalArgumentException e) {
 708                 throw new IIOException(I18N.getString("BMPImageReader6"), e);
 709             }
 710         }
 711         return metadata;
 712     }
 713 
 714     public IIOMetadata getStreamMetadata() throws IOException {
 715         return null;
 716     }
 717 
 718     public boolean isRandomAccessEasy(int imageIndex) throws IOException {
 719         checkIndex(imageIndex);
 720         try {
 721             readHeader();
 722         } catch (IllegalArgumentException e) {
 723             throw new IIOException(I18N.getString("BMPImageReader6"), e);
 724         }
 725         return metadata.compression == BI_RGB;
 726     }
 727 
 728     public BufferedImage read(int imageIndex, ImageReadParam param)
 729         throws IOException {
 730 
 731         if (iis == null) {
 732             throw new IllegalStateException(I18N.getString("BMPImageReader5"));
 733         }
 734 
 735         checkIndex(imageIndex);
 736         clearAbortRequest();
 737         processImageStarted(imageIndex);
 738 
 739         if (param == null)
 740             param = getDefaultReadParam();
 741 
 742         //read header
 743         try {
 744             readHeader();
 745         } catch (IllegalArgumentException e) {
 746             throw new IIOException(I18N.getString("BMPImageReader6"), e);
 747         }
 748 
 749         sourceRegion = new Rectangle(0, 0, 0, 0);
 750         destinationRegion = new Rectangle(0, 0, 0, 0);
 751 
 752         computeRegions(param, this.width, this.height,
 753                        param.getDestination(),
 754                        sourceRegion,
 755                        destinationRegion);
 756 
 757         scaleX = param.getSourceXSubsampling();
 758         scaleY = param.getSourceYSubsampling();
 759 
 760         // If the destination band is set used it
 761         sourceBands = param.getSourceBands();
 762         destBands = param.getDestinationBands();
 763 
 764         seleBand = (sourceBands != null) && (destBands != null);
 765         noTransform =
 766             destinationRegion.equals(new Rectangle(0, 0, width, height)) ||
 767             seleBand;
 768 
 769         if (!seleBand) {
 770             sourceBands = new int[numBands];
 771             destBands = new int[numBands];
 772             for (int i = 0; i < numBands; i++)
 773                 destBands[i] = sourceBands[i] = i;
 774         }
 775 
 776         // If the destination is provided, then use it.  Otherwise, create new one
 777         bi = param.getDestination();
 778 
 779         // Get the image data.
 780         WritableRaster raster = null;
 781 
 782         if (bi == null) {
 783             if (sampleModel != null && colorModel != null) {
 784                 sampleModel =
 785                     sampleModel.createCompatibleSampleModel(destinationRegion.x +
 786                                                             destinationRegion.width,
 787                                                             destinationRegion.y +
 788                                                             destinationRegion.height);
 789                 if (seleBand)
 790                     sampleModel = sampleModel.createSubsetSampleModel(sourceBands);
 791                 raster = Raster.createWritableRaster(sampleModel, new Point());
 792                 bi = new BufferedImage(colorModel, raster, false, null);
 793             }
 794         } else {
 795             raster = bi.getWritableTile(0, 0);
 796             sampleModel = bi.getSampleModel();
 797             colorModel = bi.getColorModel();
 798 
 799             noTransform &=  destinationRegion.equals(raster.getBounds());
 800         }
 801 
 802         byte bdata[] = null; // buffer for byte data
 803         short sdata[] = null; // buffer for short data
 804         int idata[] = null; // buffer for int data
 805 
 806         // the sampleModel can be null in case of embedded image
 807         if (sampleModel != null) {
 808             if (sampleModel.getDataType() == DataBuffer.TYPE_BYTE)
 809                 bdata = ((DataBufferByte)raster.getDataBuffer()).getData();
 810             else if (sampleModel.getDataType() == DataBuffer.TYPE_USHORT)
 811                 sdata = ((DataBufferUShort)raster.getDataBuffer()).getData();
 812             else if (sampleModel.getDataType() == DataBuffer.TYPE_INT)
 813                 idata = ((DataBufferInt)raster.getDataBuffer()).getData();
 814         }
 815 
 816         // There should only be one tile.
 817         switch(imageType) {
 818 
 819         case VERSION_2_1_BIT:
 820             // no compression
 821             read1Bit(bdata);
 822             break;
 823 
 824         case VERSION_2_4_BIT:
 825             // no compression
 826             read4Bit(bdata);
 827             break;
 828 
 829         case VERSION_2_8_BIT:
 830             // no compression
 831             read8Bit(bdata);
 832             break;
 833 
 834         case VERSION_2_24_BIT:
 835             // no compression
 836             read24Bit(bdata);
 837             break;
 838 
 839         case VERSION_3_1_BIT:
 840             // 1-bit images cannot be compressed.
 841             read1Bit(bdata);
 842             break;
 843 
 844         case VERSION_3_4_BIT:
 845             switch((int)compression) {
 846             case BI_RGB:
 847                 read4Bit(bdata);
 848                 break;
 849 
 850             case BI_RLE4:
 851                 readRLE4(bdata);
 852                 break;
 853 
 854             default:
 855                 throw new
 856                     IIOException(I18N.getString("BMPImageReader1"));
 857             }
 858             break;
 859 
 860         case VERSION_3_8_BIT:
 861             switch((int)compression) {
 862             case BI_RGB:
 863                 read8Bit(bdata);
 864                 break;
 865 
 866             case BI_RLE8:
 867                 readRLE8(bdata);
 868                 break;
 869 
 870             default:
 871                 throw new
 872                     IIOException(I18N.getString("BMPImageReader1"));
 873             }
 874 
 875             break;
 876 
 877         case VERSION_3_24_BIT:
 878             // 24-bit images are not compressed
 879             read24Bit(bdata);
 880             break;
 881 
 882         case VERSION_3_NT_16_BIT:
 883             read16Bit(sdata);
 884             break;
 885 
 886         case VERSION_3_NT_32_BIT:
 887             read32Bit(idata);
 888             break;
 889 
 890         case VERSION_3_XP_EMBEDDED:
 891         case VERSION_4_XP_EMBEDDED:
 892         case VERSION_5_XP_EMBEDDED:
 893             bi = readEmbedded((int)compression, bi, param);
 894             break;
 895 
 896         case VERSION_4_1_BIT:
 897             read1Bit(bdata);
 898             break;
 899 
 900         case VERSION_4_4_BIT:
 901             switch((int)compression) {
 902 
 903             case BI_RGB:
 904                 read4Bit(bdata);
 905                 break;
 906 
 907             case BI_RLE4:
 908                 readRLE4(bdata);
 909                 break;
 910 
 911             default:
 912                 throw new
 913                     IIOException(I18N.getString("BMPImageReader1"));
 914             }

 915 
 916         case VERSION_4_8_BIT:
 917             switch((int)compression) {
 918 
 919             case BI_RGB:
 920                 read8Bit(bdata);
 921                 break;
 922 
 923             case BI_RLE8:
 924                 readRLE8(bdata);
 925                 break;
 926 
 927             default:
 928                 throw new
 929                     IIOException(I18N.getString("BMPImageReader1"));
 930             }
 931             break;
 932 
 933         case VERSION_4_16_BIT:
 934             read16Bit(sdata);
 935             break;
 936 
 937         case VERSION_4_24_BIT:
 938             read24Bit(bdata);
 939             break;
 940 
 941         case VERSION_4_32_BIT:
 942             read32Bit(idata);
 943             break;
 944         }
 945 
 946         if (abortRequested())
 947             processReadAborted();
 948         else
 949             processImageComplete();
 950 
 951         return bi;
 952     }
 953 
 954     public boolean canReadRaster() {
 955         return true;
 956     }
 957 
 958     public Raster readRaster(int imageIndex,
 959                              ImageReadParam param) throws IOException {
 960         BufferedImage bi = read(imageIndex, param);
 961         return bi.getData();
 962     }
 963 
 964     private void resetHeaderInfo() {
 965         gotHeader = false;
 966         bi = null;
 967         sampleModel = originalSampleModel = null;
 968         colorModel = originalColorModel = null;
 969     }
 970 
 971     public void reset() {
 972         super.reset();
 973         iis = null;
 974         resetHeaderInfo();
 975     }
 976 
 977     // Deal with 1 Bit images using IndexColorModels
 978     private void read1Bit(byte[] bdata) throws IOException {
 979         int bytesPerScanline = (width + 7) / 8;
 980         int padding = bytesPerScanline % 4;
 981         if (padding != 0) {
 982             padding = 4 - padding;
 983         }
 984 
 985         int lineLength = bytesPerScanline + padding;
 986 
 987         if (noTransform) {
 988             int j = isBottomUp ? (height -1)*bytesPerScanline : 0;
 989 
 990             for (int i=0; i<height; i++) {
 991                 if (abortRequested()) {
 992                     break;
 993                 }
 994                 iis.readFully(bdata, j, bytesPerScanline);
 995                 iis.skipBytes(padding);
 996                 j += isBottomUp ? -bytesPerScanline : bytesPerScanline;
 997                 processImageUpdate(bi, 0, i,
 998                                    destinationRegion.width, 1, 1, 1,
 999                                    new int[]{0});
1000                 processImageProgress(100.0F * i/destinationRegion.height);
1001             }
1002         } else {
1003             byte[] buf = new byte[lineLength];
1004             int lineStride =
1005                 ((MultiPixelPackedSampleModel)sampleModel).getScanlineStride();
1006 
1007             if (isBottomUp) {
1008                 int lastLine =
1009                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1010                 iis.skipBytes(lineLength * (height - 1 - lastLine));
1011             } else
1012                 iis.skipBytes(lineLength * sourceRegion.y);
1013 
1014             int skipLength = lineLength * (scaleY - 1);
1015 
1016             // cache the values to avoid duplicated computation
1017             int[] srcOff = new int[destinationRegion.width];
1018             int[] destOff = new int[destinationRegion.width];
1019             int[] srcPos = new int[destinationRegion.width];
1020             int[] destPos = new int[destinationRegion.width];
1021 
1022             for (int i = destinationRegion.x, x = sourceRegion.x, j = 0;
1023                  i < destinationRegion.x + destinationRegion.width;
1024                  i++, j++, x += scaleX) {
1025                 srcPos[j] = x >> 3;
1026                 srcOff[j] = 7 - (x & 7);
1027                 destPos[j] = i >> 3;
1028                 destOff[j] = 7 - (i & 7);
1029             }
1030 
1031             int k = destinationRegion.y * lineStride;
1032             if (isBottomUp)
1033                 k += (destinationRegion.height - 1) * lineStride;
1034 
1035             for (int j = 0, y = sourceRegion.y;
1036                  j < destinationRegion.height; j++, y+=scaleY) {
1037 
1038                 if (abortRequested())
1039                     break;
1040                 iis.read(buf, 0, lineLength);
1041                 for (int i = 0; i < destinationRegion.width; i++) {
1042                     //get the bit and assign to the data buffer of the raster
1043                     int v = (buf[srcPos[i]] >> srcOff[i]) & 1;
1044                     bdata[k + destPos[i]] |= v << destOff[i];
1045                 }
1046 
1047                 k += isBottomUp ? -lineStride : lineStride;
1048                 iis.skipBytes(skipLength);
1049                 processImageUpdate(bi, 0, j,
1050                                    destinationRegion.width, 1, 1, 1,
1051                                    new int[]{0});
1052                 processImageProgress(100.0F*j/destinationRegion.height);
1053             }
1054         }
1055     }
1056 
1057     // Method to read a 4 bit BMP image data
1058     private void read4Bit(byte[] bdata) throws IOException {
1059 
1060         int bytesPerScanline = (width + 1) / 2;
1061 
1062         // Padding bytes at the end of each scanline
1063         int padding = bytesPerScanline % 4;
1064         if (padding != 0)
1065             padding = 4 - padding;
1066 
1067         int lineLength = bytesPerScanline + padding;
1068 
1069         if (noTransform) {
1070             int j = isBottomUp ? (height -1) * bytesPerScanline : 0;
1071 
1072             for (int i=0; i<height; i++) {
1073                 if (abortRequested()) {
1074                     break;
1075                 }
1076                 iis.readFully(bdata, j, bytesPerScanline);
1077                 iis.skipBytes(padding);
1078                 j += isBottomUp ? -bytesPerScanline : bytesPerScanline;
1079                 processImageUpdate(bi, 0, i,
1080                                    destinationRegion.width, 1, 1, 1,
1081                                    new int[]{0});
1082                 processImageProgress(100.0F * i/destinationRegion.height);
1083             }
1084         } else {
1085             byte[] buf = new byte[lineLength];
1086             int lineStride =
1087                 ((MultiPixelPackedSampleModel)sampleModel).getScanlineStride();
1088 
1089             if (isBottomUp) {
1090                 int lastLine =
1091                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1092                 iis.skipBytes(lineLength * (height - 1 - lastLine));
1093             } else
1094                 iis.skipBytes(lineLength * sourceRegion.y);
1095 
1096             int skipLength = lineLength * (scaleY - 1);
1097 
1098             // cache the values to avoid duplicated computation
1099             int[] srcOff = new int[destinationRegion.width];
1100             int[] destOff = new int[destinationRegion.width];
1101             int[] srcPos = new int[destinationRegion.width];
1102             int[] destPos = new int[destinationRegion.width];
1103 
1104             for (int i = destinationRegion.x, x = sourceRegion.x, j = 0;
1105                  i < destinationRegion.x + destinationRegion.width;
1106                  i++, j++, x += scaleX) {
1107                 srcPos[j] = x >> 1;
1108                 srcOff[j] = (1 - (x & 1)) << 2;
1109                 destPos[j] = i >> 1;
1110                 destOff[j] = (1 - (i & 1)) << 2;
1111             }
1112 
1113             int k = destinationRegion.y * lineStride;
1114             if (isBottomUp)
1115                 k += (destinationRegion.height - 1) * lineStride;
1116 
1117             for (int j = 0, y = sourceRegion.y;
1118                  j < destinationRegion.height; j++, y+=scaleY) {
1119 
1120                 if (abortRequested())
1121                     break;
1122                 iis.read(buf, 0, lineLength);
1123                 for (int i = 0; i < destinationRegion.width; i++) {
1124                     //get the bit and assign to the data buffer of the raster
1125                     int v = (buf[srcPos[i]] >> srcOff[i]) & 0x0F;
1126                     bdata[k + destPos[i]] |= v << destOff[i];
1127                 }
1128 
1129                 k += isBottomUp ? -lineStride : lineStride;
1130                 iis.skipBytes(skipLength);
1131                 processImageUpdate(bi, 0, j,
1132                                    destinationRegion.width, 1, 1, 1,
1133                                    new int[]{0});
1134                 processImageProgress(100.0F*j/destinationRegion.height);
1135             }
1136         }
1137     }
1138 
1139     // Method to read 8 bit BMP image data
1140     private void read8Bit(byte[] bdata) throws IOException {
1141 
1142         // Padding bytes at the end of each scanline
1143         int padding = width % 4;
1144         if (padding != 0) {
1145             padding = 4 - padding;
1146         }
1147 
1148         int lineLength = width + padding;
1149 
1150         if (noTransform) {
1151             int j = isBottomUp ? (height -1) * width : 0;
1152 
1153             for (int i=0; i<height; i++) {
1154                 if (abortRequested()) {
1155                     break;
1156                 }
1157                 iis.readFully(bdata, j, width);
1158                 iis.skipBytes(padding);
1159                 j += isBottomUp ? -width : width;
1160                 processImageUpdate(bi, 0, i,
1161                                    destinationRegion.width, 1, 1, 1,
1162                                    new int[]{0});
1163                 processImageProgress(100.0F * i/destinationRegion.height);
1164             }
1165         } else {
1166             byte[] buf = new byte[lineLength];
1167             int lineStride =
1168                 ((ComponentSampleModel)sampleModel).getScanlineStride();
1169 
1170             if (isBottomUp) {
1171                 int lastLine =
1172                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1173                 iis.skipBytes(lineLength * (height - 1 - lastLine));
1174             } else
1175                 iis.skipBytes(lineLength * sourceRegion.y);
1176 
1177             int skipLength = lineLength * (scaleY - 1);
1178 
1179             int k = destinationRegion.y * lineStride;
1180             if (isBottomUp)
1181                 k += (destinationRegion.height - 1) * lineStride;
1182             k += destinationRegion.x;
1183 
1184             for (int j = 0, y = sourceRegion.y;
1185                  j < destinationRegion.height; j++, y+=scaleY) {
1186 
1187                 if (abortRequested())
1188                     break;
1189                 iis.read(buf, 0, lineLength);
1190                 for (int i = 0, m = sourceRegion.x;
1191                      i < destinationRegion.width; i++, m += scaleX) {
1192                     //get the bit and assign to the data buffer of the raster
1193                     bdata[k + i] = buf[m];
1194                 }
1195 
1196                 k += isBottomUp ? -lineStride : lineStride;
1197                 iis.skipBytes(skipLength);
1198                 processImageUpdate(bi, 0, j,
1199                                    destinationRegion.width, 1, 1, 1,
1200                                    new int[]{0});
1201                 processImageProgress(100.0F*j/destinationRegion.height);
1202             }
1203         }
1204     }
1205 
1206     // Method to read 24 bit BMP image data
1207     private void read24Bit(byte[] bdata) throws IOException {
1208         // Padding bytes at the end of each scanline
1209         // width * bitsPerPixel should be divisible by 32
1210         int padding = width * 3 % 4;
1211         if ( padding != 0)
1212             padding = 4 - padding;
1213 
1214         int lineStride = width * 3;
1215         int lineLength = lineStride + padding;
1216 
1217         if (noTransform) {
1218             int j = isBottomUp ? (height -1) * width * 3 : 0;
1219 
1220             for (int i=0; i<height; i++) {
1221                 if (abortRequested()) {
1222                     break;
1223                 }
1224                 iis.readFully(bdata, j, lineStride);
1225                 iis.skipBytes(padding);
1226                 j += isBottomUp ? -lineStride : lineStride;
1227                 processImageUpdate(bi, 0, i,
1228                                    destinationRegion.width, 1, 1, 1,
1229                                    new int[]{0});
1230                 processImageProgress(100.0F * i/destinationRegion.height);
1231             }
1232         } else {
1233             byte[] buf = new byte[lineLength];
1234             lineStride =
1235                 ((ComponentSampleModel)sampleModel).getScanlineStride();
1236 
1237             if (isBottomUp) {
1238                 int lastLine =
1239                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1240                 iis.skipBytes(lineLength * (height - 1 - lastLine));
1241             } else
1242                 iis.skipBytes(lineLength * sourceRegion.y);
1243 
1244             int skipLength = lineLength * (scaleY - 1);
1245 
1246             int k = destinationRegion.y * lineStride;
1247             if (isBottomUp)
1248                 k += (destinationRegion.height - 1) * lineStride;
1249             k += destinationRegion.x * 3;
1250 
1251             for (int j = 0, y = sourceRegion.y;
1252                  j < destinationRegion.height; j++, y+=scaleY) {
1253 
1254                 if (abortRequested())
1255                     break;
1256                 iis.read(buf, 0, lineLength);
1257                 for (int i = 0, m = 3 * sourceRegion.x;
1258                      i < destinationRegion.width; i++, m += 3 * scaleX) {
1259                     //get the bit and assign to the data buffer of the raster
1260                     int n = 3 * i + k;
1261                     for (int b = 0; b < destBands.length; b++)
1262                         bdata[n + destBands[b]] = buf[m + sourceBands[b]];
1263                 }
1264 
1265                 k += isBottomUp ? -lineStride : lineStride;
1266                 iis.skipBytes(skipLength);
1267                 processImageUpdate(bi, 0, j,
1268                                    destinationRegion.width, 1, 1, 1,
1269                                    new int[]{0});
1270                 processImageProgress(100.0F*j/destinationRegion.height);
1271             }
1272         }
1273     }
1274 
1275     private void read16Bit(short sdata[]) throws IOException {
1276         // Padding bytes at the end of each scanline
1277         // width * bitsPerPixel should be divisible by 32
1278         int padding = width * 2 % 4;
1279 
1280         if ( padding != 0)
1281             padding = 4 - padding;
1282 
1283         int lineLength = width + padding / 2;
1284 
1285         if (noTransform) {
1286             int j = isBottomUp ? (height -1) * width : 0;
1287             for (int i=0; i<height; i++) {
1288                 if (abortRequested()) {
1289                     break;
1290                 }
1291 
1292                 iis.readFully(sdata, j, width);
1293                 iis.skipBytes(padding);
1294 
1295                 j += isBottomUp ? -width : width;
1296                 processImageUpdate(bi, 0, i,
1297                                    destinationRegion.width, 1, 1, 1,
1298                                    new int[]{0});
1299                 processImageProgress(100.0F * i/destinationRegion.height);
1300             }
1301         } else {
1302             short[] buf = new short[lineLength];
1303             int lineStride =
1304                 ((SinglePixelPackedSampleModel)sampleModel).getScanlineStride();
1305 
1306             if (isBottomUp) {
1307                 int lastLine =
1308                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1309                 iis.skipBytes(lineLength * (height - 1 - lastLine) << 1);
1310             } else
1311                 iis.skipBytes(lineLength * sourceRegion.y << 1);
1312 
1313             int skipLength = lineLength * (scaleY - 1) << 1;
1314 
1315             int k = destinationRegion.y * lineStride;
1316             if (isBottomUp)
1317                 k += (destinationRegion.height - 1) * lineStride;
1318             k += destinationRegion.x;
1319 
1320             for (int j = 0, y = sourceRegion.y;
1321                  j < destinationRegion.height; j++, y+=scaleY) {
1322 
1323                 if (abortRequested())
1324                     break;
1325                 iis.readFully(buf, 0, lineLength);
1326                 for (int i = 0, m = sourceRegion.x;
1327                      i < destinationRegion.width; i++, m += scaleX) {
1328                     //get the bit and assign to the data buffer of the raster
1329                     sdata[k + i] = buf[m];
1330                 }
1331 
1332                 k += isBottomUp ? -lineStride : lineStride;
1333                 iis.skipBytes(skipLength);
1334                 processImageUpdate(bi, 0, j,
1335                                    destinationRegion.width, 1, 1, 1,
1336                                    new int[]{0});
1337                 processImageProgress(100.0F*j/destinationRegion.height);
1338             }
1339         }
1340     }
1341 
1342     private void read32Bit(int idata[]) throws IOException {
1343         if (noTransform) {
1344             int j = isBottomUp ? (height -1) * width : 0;
1345 
1346             for (int i=0; i<height; i++) {
1347                 if (abortRequested()) {
1348                     break;
1349                 }
1350                 iis.readFully(idata, j, width);
1351                 j += isBottomUp ? -width : width;
1352                 processImageUpdate(bi, 0, i,
1353                                    destinationRegion.width, 1, 1, 1,
1354                                    new int[]{0});
1355                 processImageProgress(100.0F * i/destinationRegion.height);
1356             }
1357         } else {
1358             int[] buf = new int[width];
1359             int lineStride =
1360                 ((SinglePixelPackedSampleModel)sampleModel).getScanlineStride();
1361 
1362             if (isBottomUp) {
1363                 int lastLine =
1364                     sourceRegion.y + (destinationRegion.height - 1) * scaleY;
1365                 iis.skipBytes(width * (height - 1 - lastLine) << 2);
1366             } else
1367                 iis.skipBytes(width * sourceRegion.y << 2);
1368 
1369             int skipLength = width * (scaleY - 1) << 2;
1370 
1371             int k = destinationRegion.y * lineStride;
1372             if (isBottomUp)
1373                 k += (destinationRegion.height - 1) * lineStride;
1374             k += destinationRegion.x;
1375 
1376             for (int j = 0, y = sourceRegion.y;
1377                  j < destinationRegion.height; j++, y+=scaleY) {
1378 
1379                 if (abortRequested())
1380                     break;
1381                 iis.readFully(buf, 0, width);
1382                 for (int i = 0, m = sourceRegion.x;
1383                      i < destinationRegion.width; i++, m += scaleX) {
1384                     //get the bit and assign to the data buffer of the raster
1385                     idata[k + i] = buf[m];
1386                 }
1387 
1388                 k += isBottomUp ? -lineStride : lineStride;
1389                 iis.skipBytes(skipLength);
1390                 processImageUpdate(bi, 0, j,
1391                                    destinationRegion.width, 1, 1, 1,
1392                                    new int[]{0});
1393                 processImageProgress(100.0F*j/destinationRegion.height);
1394             }
1395         }
1396     }
1397 
1398     private void readRLE8(byte bdata[]) throws IOException {
1399         // If imageSize field is not provided, calculate it.
1400         int imSize = (int)imageSize;
1401         if (imSize == 0) {
1402             imSize = (int)(bitmapFileSize - bitmapOffset);
1403         }
1404 
1405         int padding = 0;
1406         // If width is not 32 bit aligned, then while uncompressing each
1407         // scanline will have padding bytes, calculate the amount of padding
1408         int remainder = width % 4;
1409         if (remainder != 0) {
1410             padding = 4 - remainder;
1411         }
1412 
1413         // Read till we have the whole image
1414         byte values[] = new byte[imSize];
1415         int bytesRead = 0;
1416         iis.readFully(values, 0, imSize);
1417 
1418         // Since data is compressed, decompress it
1419         decodeRLE8(imSize, padding, values, bdata);
1420     }
1421 
1422     private void decodeRLE8(int imSize,
1423                             int padding,
1424                             byte[] values,
1425                             byte[] bdata) throws IOException {
1426 
1427         byte val[] = new byte[width * height];
1428         int count = 0, l = 0;
1429         int value;
1430         boolean flag = false;
1431         int lineNo = isBottomUp ? height - 1 : 0;
1432         int lineStride =
1433             ((ComponentSampleModel)sampleModel).getScanlineStride();
1434         int finished = 0;
1435 
1436         while (count != imSize) {
1437             value = values[count++] & 0xff;
1438             if (value == 0) {
1439                 switch(values[count++] & 0xff) {
1440 
1441                 case 0:
1442                     // End-of-scanline marker
1443                     if (lineNo >= sourceRegion.y &&
1444                         lineNo < sourceRegion.y + sourceRegion.height) {
1445                         if (noTransform) {
1446                             int pos = lineNo * width;
1447                             for(int i = 0; i < width; i++)
1448                                 bdata[pos++] = val[i];
1449                             processImageUpdate(bi, 0, lineNo,
1450                                                destinationRegion.width, 1, 1, 1,
1451                                                new int[]{0});
1452                             finished++;
1453                         } else if ((lineNo - sourceRegion.y) % scaleY == 0) {
1454                             int currentLine = (lineNo - sourceRegion.y) / scaleY +
1455                                 destinationRegion.y;
1456                             int pos = currentLine * lineStride;
1457                             pos += destinationRegion.x;
1458                             for (int i = sourceRegion.x;
1459                                  i < sourceRegion.x + sourceRegion.width;
1460                                  i += scaleX)
1461                                 bdata[pos++] = val[i];
1462                             processImageUpdate(bi, 0, currentLine,
1463                                                destinationRegion.width, 1, 1, 1,
1464                                                new int[]{0});
1465                             finished++;
1466                         }
1467                     }
1468                     processImageProgress(100.0F * finished / destinationRegion.height);
1469                     lineNo += isBottomUp ? -1 : 1;
1470                     l = 0;
1471 
1472                     if (abortRequested()) {
1473                         flag = true;
1474                     }
1475 
1476                     break;
1477 
1478                 case 1:
1479                     // End-of-RLE marker
1480                     flag = true;
1481                     break;
1482 
1483                 case 2:
1484                     // delta or vector marker
1485                     int xoff = values[count++] & 0xff;
1486                     int yoff = values[count] & 0xff;
1487                     // Move to the position xoff, yoff down
1488                     l += xoff + yoff*width;
1489                     break;
1490 
1491                 default:
1492                     int end = values[count-1] & 0xff;
1493                     for (int i=0; i<end; i++) {
1494                         val[l++] = (byte)(values[count++] & 0xff);
1495                     }
1496 
1497                     // Whenever end pixels can fit into odd number of bytes,
1498                     // an extra padding byte will be present, so skip that.
1499                     if ((end & 1) == 1) {
1500                         count++;
1501                     }
1502                 }
1503             } else {
1504                 for (int i=0; i<value; i++) {
1505                     val[l++] = (byte)(values[count] & 0xff);
1506                 }
1507 
1508                 count++;
1509             }
1510 
1511             // If End-of-RLE data, then exit the while loop
1512             if (flag) {
1513                 break;
1514             }
1515         }
1516     }
1517 
1518     private void readRLE4(byte[] bdata) throws IOException {
1519 
1520         // If imageSize field is not specified, calculate it.
1521         int imSize = (int)imageSize;
1522         if (imSize == 0) {
1523             imSize = (int)(bitmapFileSize - bitmapOffset);
1524         }
1525 
1526         int padding = 0;
1527         // If width is not 32 byte aligned, then while uncompressing each
1528         // scanline will have padding bytes, calculate the amount of padding
1529         int remainder = width % 4;
1530         if (remainder != 0) {
1531             padding = 4 - remainder;
1532         }
1533 
1534         // Read till we have the whole image
1535         byte[] values = new byte[imSize];
1536         iis.readFully(values, 0, imSize);
1537 
1538         // Decompress the RLE4 compressed data.
1539         decodeRLE4(imSize, padding, values, bdata);
1540     }
1541 
1542     private void decodeRLE4(int imSize,
1543                             int padding,
1544                             byte[] values,
1545                             byte[] bdata) throws IOException {
1546         byte[] val = new byte[width];
1547         int count = 0, l = 0;
1548         int value;
1549         boolean flag = false;
1550         int lineNo = isBottomUp ? height - 1 : 0;
1551         int lineStride =
1552             ((MultiPixelPackedSampleModel)sampleModel).getScanlineStride();
1553         int finished = 0;
1554 
1555         while (count != imSize) {
1556 
1557             value = values[count++] & 0xFF;
1558             if (value == 0) {
1559 
1560 
1561                 // Absolute mode
1562                 switch(values[count++] & 0xFF) {
1563 
1564                 case 0:
1565                     // End-of-scanline marker
1566                     // End-of-scanline marker
1567                     if (lineNo >= sourceRegion.y &&
1568                         lineNo < sourceRegion.y + sourceRegion.height) {
1569                         if (noTransform) {
1570                             int pos = lineNo * (width + 1 >> 1);
1571                             for(int i = 0, j = 0; i < width >> 1; i++)
1572                                 bdata[pos++] =
1573                                     (byte)((val[j++] << 4) | val[j++]);
1574                             if ((width & 1) == 1)
1575                                 bdata[pos] |= val[width - 1] << 4;
1576 
1577                             processImageUpdate(bi, 0, lineNo,
1578                                                destinationRegion.width, 1, 1, 1,
1579                                                new int[]{0});
1580                             finished++;
1581                         } else if ((lineNo - sourceRegion.y) % scaleY == 0) {
1582                             int currentLine = (lineNo - sourceRegion.y) / scaleY +
1583                                 destinationRegion.y;
1584                             int pos = currentLine * lineStride;
1585                             pos += destinationRegion.x >> 1;
1586                             int shift = (1 - (destinationRegion.x & 1)) << 2;
1587                             for (int i = sourceRegion.x;
1588                                  i < sourceRegion.x + sourceRegion.width;
1589                                  i += scaleX) {
1590                                 bdata[pos] |= val[i] << shift;
1591                                 shift += 4;
1592                                 if (shift == 4) {
1593                                     pos++;
1594                                 }
1595                                 shift &= 7;
1596                             }
1597                             processImageUpdate(bi, 0, currentLine,
1598                                                destinationRegion.width, 1, 1, 1,
1599                                                new int[]{0});
1600                             finished++;
1601                         }
1602                     }
1603                     processImageProgress(100.0F * finished / destinationRegion.height);
1604                     lineNo += isBottomUp ? -1 : 1;
1605                     l = 0;
1606 
1607                     if (abortRequested()) {
1608                         flag = true;
1609                     }
1610 
1611                     break;
1612 
1613                 case 1:
1614                     // End-of-RLE marker
1615                     flag = true;
1616                     break;
1617 
1618                 case 2:
1619                     // delta or vector marker
1620                     int xoff = values[count++] & 0xFF;
1621                     int yoff = values[count] & 0xFF;
1622                     // Move to the position xoff, yoff down
1623                     l += xoff + yoff*width;
1624                     break;
1625 
1626                 default:
1627                     int end = values[count-1] & 0xFF;
1628                     for (int i=0; i<end; i++) {
1629                         val[l++] = (byte)(((i & 1) == 0) ? (values[count] & 0xf0) >> 4
1630                                           : (values[count++] & 0x0f));
1631                     }
1632 
1633                     // When end is odd, the above for loop does not
1634                     // increment count, so do it now.
1635                     if ((end & 1) == 1) {
1636                         count++;
1637                     }
1638 
1639                     // Whenever end pixels can fit into odd number of bytes,
1640                     // an extra padding byte will be present, so skip that.
1641                     if ((((int)Math.ceil(end/2)) & 1) ==1 ) {
1642                         count++;
1643                     }
1644                     break;
1645                 }
1646             } else {
1647                 // Encoded mode
1648                 int alternate[] = { (values[count] & 0xf0) >> 4,
1649                                     values[count] & 0x0f };
1650                 for (int i=0; (i < value) && (l < width); i++) {
1651                     val[l++] = (byte)alternate[i & 1];
1652                 }
1653 
1654                 count++;
1655             }
1656 
1657             // If End-of-RLE data, then exit the while loop
1658             if (flag) {
1659                 break;
1660             }
1661         }
1662     }
1663 
1664     /** Decodes the jpeg/png image embedded in the bitmap using any jpeg
1665      *  ImageIO-style plugin.
1666      *
1667      * @param bi The destination <code>BufferedImage</code>.
1668      * @param bmpParam The <code>ImageReadParam</code> for decoding this
1669      *          BMP image.  The parameters for subregion, band selection and
1670      *          subsampling are used in decoding the jpeg image.
1671      */
1672 
1673     private BufferedImage readEmbedded(int type,
1674                               BufferedImage bi, ImageReadParam bmpParam)
1675       throws IOException {
1676         String format;
1677         switch(type) {
1678           case BI_JPEG:
1679               format = "JPEG";
1680               break;
1681           case BI_PNG:
1682               format = "PNG";
1683               break;
1684           default:
1685               throw new
1686                   IOException("Unexpected compression type: " + type);
1687         }
1688         ImageReader reader =
1689             ImageIO.getImageReadersByFormatName(format).next();
1690         if (reader == null) {
1691             throw new RuntimeException(I18N.getString("BMPImageReader4") +
1692                                        " " + format);
1693         }
1694         // prepare input
1695         byte[] buff = new byte[(int)imageSize];
1696         iis.read(buff);
1697         reader.setInput(ImageIO.createImageInputStream(new ByteArrayInputStream(buff)));
1698         if (bi == null) {
1699             ImageTypeSpecifier embType = reader.getImageTypes(0).next();
1700             bi = embType.createBufferedImage(destinationRegion.x +
1701                                              destinationRegion.width,
1702                                              destinationRegion.y +
1703                                              destinationRegion.height);
1704         }
1705 
1706         reader.addIIOReadProgressListener(new EmbeddedProgressAdapter() {
1707                 public void imageProgress(ImageReader source,
1708                                           float percentageDone)
1709                 {
1710                     processImageProgress(percentageDone);
1711                 }
1712             });
1713 
1714         reader.addIIOReadUpdateListener(new IIOReadUpdateListener() {
1715                 public void imageUpdate(ImageReader source,
1716                                         BufferedImage theImage,
1717                                         int minX, int minY,
1718                                         int width, int height,
1719                                         int periodX, int periodY,
1720                                         int[] bands)
1721                 {
1722                     processImageUpdate(theImage, minX, minY,
1723                                        width, height,
1724                                        periodX, periodY, bands);
1725                 }
1726                 public void passComplete(ImageReader source,
1727                                          BufferedImage theImage)
1728                 {
1729                     processPassComplete(theImage);
1730                 }
1731                 public void passStarted(ImageReader source,
1732                                         BufferedImage theImage,
1733                                         int pass,
1734                                         int minPass, int maxPass,
1735                                         int minX, int minY,
1736                                         int periodX, int periodY,
1737                                         int[] bands)
1738                 {
1739                     processPassStarted(theImage, pass, minPass, maxPass,
1740                                        minX, minY, periodX, periodY,
1741                                        bands);
1742                 }
1743                 public void thumbnailPassComplete(ImageReader source,
1744                                                   BufferedImage thumb) {}
1745                 public void thumbnailPassStarted(ImageReader source,
1746                                                  BufferedImage thumb,
1747                                                  int pass,
1748                                                  int minPass, int maxPass,
1749                                                  int minX, int minY,
1750                                                  int periodX, int periodY,
1751                                                  int[] bands) {}
1752                 public void thumbnailUpdate(ImageReader source,
1753                                             BufferedImage theThumbnail,
1754                                             int minX, int minY,
1755                                             int width, int height,
1756                                             int periodX, int periodY,
1757                                             int[] bands) {}
1758             });
1759 
1760         reader.addIIOReadWarningListener(new IIOReadWarningListener() {
1761                 public void warningOccurred(ImageReader source, String warning)
1762                 {
1763                     processWarningOccurred(warning);
1764                 }
1765             });
1766 
1767         ImageReadParam param = reader.getDefaultReadParam();
1768         param.setDestination(bi);
1769         param.setDestinationBands(bmpParam.getDestinationBands());
1770         param.setDestinationOffset(bmpParam.getDestinationOffset());
1771         param.setSourceBands(bmpParam.getSourceBands());
1772         param.setSourceRegion(bmpParam.getSourceRegion());
1773         param.setSourceSubsampling(bmpParam.getSourceXSubsampling(),
1774                                    bmpParam.getSourceYSubsampling(),
1775                                    bmpParam.getSubsamplingXOffset(),
1776                                    bmpParam.getSubsamplingYOffset());
1777         reader.read(0, param);
1778         return bi;
1779     }
1780 
1781     private class EmbeddedProgressAdapter implements IIOReadProgressListener {
1782         public void imageComplete(ImageReader src) {}
1783         public void imageProgress(ImageReader src, float percentageDone) {}
1784         public void imageStarted(ImageReader src, int imageIndex) {}
1785         public void thumbnailComplete(ImageReader src) {}
1786         public void thumbnailProgress(ImageReader src, float percentageDone) {}
1787         public void thumbnailStarted(ImageReader src, int iIdx, int tIdx) {}
1788         public void sequenceComplete(ImageReader src) {}
1789         public void sequenceStarted(ImageReader src, int minIndex) {}
1790         public void readAborted(ImageReader src) {}
1791     }
1792 
1793     private static Boolean isLinkedProfileDisabled = null;
1794 
1795     private static boolean isLinkedProfileAllowed() {
1796         if (isLinkedProfileDisabled == null) {
1797             PrivilegedAction<Boolean> a = new PrivilegedAction<Boolean>() {
1798                 public Boolean run() {
1799                     return Boolean.getBoolean("sun.imageio.plugins.bmp.disableLinkedProfiles");
1800                 }
1801             };
1802             isLinkedProfileDisabled = AccessController.doPrivileged(a);
1803         }
1804         return !isLinkedProfileDisabled;
1805     }
1806 
1807     private static Boolean isWindowsPlatform = null;
1808 
1809     /**
1810      * Verifies whether the byte array contans a unc path.
1811      * Non-UNC path examples:
1812      *  c:\path\to\file  - simple notation
1813      *  \\?\c:\path\to\file - long notation
1814      *
1815      * UNC path examples:
1816      *  \\server\share - a UNC path in simple notation
1817      *  \\?\UNC\server\share - a UNC path in long notation
1818      *  \\.\some\device - a path to device.
1819      */
1820     private static boolean isUncOrDevicePath(byte[] p) {
1821         if (isWindowsPlatform == null) {
1822             PrivilegedAction<Boolean> a = new PrivilegedAction<Boolean>() {
1823                 public Boolean run() {
1824                     String osname = System.getProperty("os.name");
1825                     return (osname != null &&
1826                             osname.toLowerCase().startsWith("win"));
1827                 }
1828             };
1829             isWindowsPlatform = AccessController.doPrivileged(a);
1830         }
1831 
1832         if (!isWindowsPlatform) {
1833             /* no need for the check on platforms except windows */
1834             return false;
1835         }
1836 
1837         /* normalize prefix of the path */
1838         if (p[0] == '/') p[0] = '\\';
1839         if (p[1] == '/') p[1] = '\\';
1840         if (p[3] == '/') p[3] = '\\';
1841 
1842 
1843         if ((p[0] == '\\') && (p[1] == '\\')) {
1844             if ((p[2] == '?') && (p[3] == '\\')) {
1845                 // long path: whether unc or local
1846                 return ((p[4] == 'U' || p[4] == 'u') &&
1847                         (p[5] == 'N' || p[5] == 'n') &&
1848                         (p[6] == 'C' || p[6] == 'c'));
1849             } else {
1850                 // device path or short unc notation
1851                 return true;
1852             }
1853         } else {
1854             return false;
1855         }
1856     }
1857 }
--- EOF ---