site/j2s/jssun/awt/image/BytePackedRaster.js

   1 Clazz.declarePackage ("jssun.awt.image");
   2 Clazz.load (["jssun.awt.image.SunWritableRaster"], "jssun.awt.image.BytePackedRaster", ["java.lang.ArrayIndexOutOfBoundsException", "java.awt.Point", "$.Rectangle", "java.awt.image.DataBufferByte", "$.MultiPixelPackedSampleModel", "$.RasterFormatException"], function () {
   3 c$ = Clazz.decorateAsClass (function () {
   4 this.dataBitOffset = 0;
   5 this.scanlineStride = 0;
   6 this.pixelBitStride = 0;
   7 this.bitMask = 0;
   8 this.data = null;
   9 this.shiftOffset = 0;
  10 this.type = 0;
  11 this.maxX = 0;
  12 this.maxY = 0;
  13 Clazz.instantialize (this, arguments);
  14 }, jssun.awt.image, "BytePackedRaster", jssun.awt.image.SunWritableRaster);
  15 Clazz.makeConstructor (c$,
  16 function (sampleModel, origin) {
  17 this.construct (sampleModel, sampleModel.createDataBuffer (),  new java.awt.Rectangle (origin.x, origin.y, sampleModel.getWidth (), sampleModel.getHeight ()), origin, null);
  18 }, "java.awt.image.SampleModel,java.awt.Point");
  19 Clazz.makeConstructor (c$,
  20 function (sampleModel, dataBuffer, origin) {
  21 this.construct (sampleModel, dataBuffer,  new java.awt.Rectangle (origin.x, origin.y, sampleModel.getWidth (), sampleModel.getHeight ()), origin, null);
  22 }, "java.awt.image.SampleModel,java.awt.image.DataBuffer,java.awt.Point");
  23 Clazz.makeConstructor (c$,
  24 function (sampleModel, dataBuffer, aRegion, origin, parent) {
  25 Clazz.superConstructor (this, jssun.awt.image.BytePackedRaster, [sampleModel, dataBuffer, aRegion, origin, parent]);
  26 this.maxX = this.minX + this.width;
  27 this.maxY = this.minY + this.height;
  28 if (!(Clazz.instanceOf (dataBuffer, java.awt.image.DataBufferByte))) {
  29 throw  new java.awt.image.RasterFormatException ("BytePackedRasters must havebyte DataBuffers");
  30 }var dbb = dataBuffer;
  31 this.data = jssun.awt.image.SunWritableRaster.stealData (dbb, 0);
  32 if (dbb.getNumBanks () != 1) {
  33 throw  new java.awt.image.RasterFormatException ("DataBuffer for BytePackedRasters must only have 1 bank.");
  34 }var dbOffset = dbb.getOffset ();
  35 if (Clazz.instanceOf (sampleModel, java.awt.image.MultiPixelPackedSampleModel)) {
  36 var mppsm = sampleModel;
  37 this.pixelBitStride = mppsm.getPixelBitStride ();
  38 if (this.pixelBitStride != 1 && this.pixelBitStride != 2 && this.pixelBitStride != 4) {
  39 throw  new java.awt.image.RasterFormatException ("BytePackedRasters must have a bit depth of 1, 2, or 4");
  40 }this.scanlineStride = mppsm.getScanlineStride ();
  41 this.dataBitOffset = mppsm.getDataBitOffset () + dbOffset * 8;
  42 var xOffset = aRegion.x - origin.x;
  43 var yOffset = aRegion.y - origin.y;
  44 this.dataBitOffset += xOffset * this.pixelBitStride + yOffset * this.scanlineStride * 8;
  45 this.bitMask = (1 << this.pixelBitStride) - 1;
  46 this.shiftOffset = 8 - this.pixelBitStride;
  47 } else {
  48 throw  new java.awt.image.RasterFormatException ("BytePackedRasters must haveMultiPixelPackedSampleModel");
  49 }this.verify (false);
  50 }, "java.awt.image.SampleModel,java.awt.image.DataBuffer,java.awt.Rectangle,java.awt.Point,jssun.awt.image.BytePackedRaster");
  51 Clazz.defineMethod (c$, "getDataBitOffset",
  52 function () {
  53 return this.dataBitOffset;
  54 });
  55 Clazz.defineMethod (c$, "getScanlineStride",
  56 function () {
  57 return this.scanlineStride;
  58 });
  59 Clazz.defineMethod (c$, "getPixelBitStride",
  60 function () {
  61 return this.pixelBitStride;
  62 });
  63 Clazz.defineMethod (c$, "getDataStorage",
  64 function () {
  65 return this.data;
  66 });
  67 Clazz.defineMethod (c$, "getDataElements",
  68 function (x, y, obj) {
  69 if ((x < this.minX) || (y < this.minY) || (x >= this.maxX) || (y >= this.maxY)) {
  70 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
  71 }var outData;
  72 if (obj == null) {
  73 outData =  Clazz.newByteArray (this.numDataElements, 0);
  74 } else {
  75 outData = obj;
  76 }var bitnum = this.dataBitOffset + (x - this.minX) * this.pixelBitStride;
  77 var element = this.data[(y - this.minY) * this.scanlineStride + (bitnum >> 3)] & 0xff;
  78 var shift = this.shiftOffset - (bitnum & 7);
  79 outData[0] = ((element >> shift) & this.bitMask);
  80 return outData;
  81 }, "~N,~N,~O");
  82 Clazz.defineMethod (c$, "getDataElements",
  83 function (x, y, w, h, outData) {
  84 return this.getByteData (x, y, w, h, outData);
  85 }, "~N,~N,~N,~N,~O");
  86 Clazz.defineMethod (c$, "getPixelData",
  87 function (x, y, w, h, obj) {
  88 if ((x < this.minX) || (y < this.minY) || (x + w > this.maxX) || (y + h > this.maxY)) {
  89 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
  90 }var outData;
  91 if (obj == null) {
  92 outData =  Clazz.newByteArray (this.numDataElements * w * h, 0);
  93 } else {
  94 outData = obj;
  95 }var pixbits = this.pixelBitStride;
  96 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
  97 var index = (y - this.minY) * this.scanlineStride;
  98 var outindex = 0;
  99 var data = this.data;
 100 for (var j = 0; j < h; j++) {
 101 var bitnum = scanbit;
 102 for (var i = 0; i < w; i++) {
 103 var shift = this.shiftOffset - (bitnum & 7);
 104 outData[outindex++] = (this.bitMask & (data[index + (bitnum >> 3)] >> shift));
 105 bitnum += pixbits;
 106 }
 107 index += this.scanlineStride;
 108 }
 109 return outData;
 110 }, "~N,~N,~N,~N,~O");
 111 Clazz.defineMethod (c$, "getByteData",
 112 function (x, y, w, h, band, outData) {
 113 return this.getByteData (x, y, w, h, outData);
 114 }, "~N,~N,~N,~N,~N,~A");
 115 Clazz.defineMethod (c$, "getByteData",
 116 function (x, y, w, h, outData) {
 117 if ((x < this.minX) || (y < this.minY) || (x + w > this.maxX) || (y + h > this.maxY)) {
 118 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 119 }if (outData == null) {
 120 outData =  Clazz.newByteArray (w * h, 0);
 121 }var pixbits = this.pixelBitStride;
 122 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
 123 var index = (y - this.minY) * this.scanlineStride;
 124 var outindex = 0;
 125 var data = this.data;
 126 for (var j = 0; j < h; j++) {
 127 var bitnum = scanbit;
 128 var element;
 129 var i = 0;
 130 while ((i < w) && ((bitnum & 7) != 0)) {
 131 var shift = this.shiftOffset - (bitnum & 7);
 132 outData[outindex++] = (this.bitMask & (data[index + (bitnum >> 3)] >> shift));
 133 bitnum += pixbits;
 134 i++;
 135 }
 136 var inIndex = index + (bitnum >> 3);
 137 switch (pixbits) {
 138 case 1:
 139 for (; i < w - 7; i += 8) {
 140 element = data[inIndex++];
 141 outData[outindex++] = ((element >> 7) & 1);
 142 outData[outindex++] = ((element >> 6) & 1);
 143 outData[outindex++] = ((element >> 5) & 1);
 144 outData[outindex++] = ((element >> 4) & 1);
 145 outData[outindex++] = ((element >> 3) & 1);
 146 outData[outindex++] = ((element >> 2) & 1);
 147 outData[outindex++] = ((element >> 1) & 1);
 148 outData[outindex++] = (element & 1);
 149 bitnum += 8;
 150 }
 151 break;
 152 case 2:
 153 for (; i < w - 7; i += 8) {
 154 element = data[inIndex++];
 155 outData[outindex++] = ((element >> 6) & 3);
 156 outData[outindex++] = ((element >> 4) & 3);
 157 outData[outindex++] = ((element >> 2) & 3);
 158 outData[outindex++] = (element & 3);
 159 element = data[inIndex++];
 160 outData[outindex++] = ((element >> 6) & 3);
 161 outData[outindex++] = ((element >> 4) & 3);
 162 outData[outindex++] = ((element >> 2) & 3);
 163 outData[outindex++] = (element & 3);
 164 bitnum += 16;
 165 }
 166 break;
 167 case 4:
 168 for (; i < w - 7; i += 8) {
 169 element = data[inIndex++];
 170 outData[outindex++] = ((element >> 4) & 0xf);
 171 outData[outindex++] = (element & 0xf);
 172 element = data[inIndex++];
 173 outData[outindex++] = ((element >> 4) & 0xf);
 174 outData[outindex++] = (element & 0xf);
 175 element = data[inIndex++];
 176 outData[outindex++] = ((element >> 4) & 0xf);
 177 outData[outindex++] = (element & 0xf);
 178 element = data[inIndex++];
 179 outData[outindex++] = ((element >> 4) & 0xf);
 180 outData[outindex++] = (element & 0xf);
 181 bitnum += 32;
 182 }
 183 break;
 184 }
 185 for (; i < w; i++) {
 186 var shift = this.shiftOffset - (bitnum & 7);
 187 outData[outindex++] = (this.bitMask & (data[index + (bitnum >> 3)] >> shift));
 188 bitnum += pixbits;
 189 }
 190 index += this.scanlineStride;
 191 }
 192 return outData;
 193 }, "~N,~N,~N,~N,~A");
 194 Clazz.defineMethod (c$, "setDataElements",
 195 function (x, y, obj) {
 196 if ((x < this.minX) || (y < this.minY) || (x >= this.maxX) || (y >= this.maxY)) {
 197 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 198 }var inData = obj;
 199 var bitnum = this.dataBitOffset + (x - this.minX) * this.pixelBitStride;
 200 var index = (y - this.minY) * this.scanlineStride + (bitnum >> 3);
 201 var shift = this.shiftOffset - (bitnum & 7);
 202 var element = this.data[index];
 203 element &= ~(this.bitMask << shift);
 204 element |= (inData[0] & this.bitMask) << shift;
 205 this.data[index] = element;
 206 this.markDirty ();
 207 }, "~N,~N,~O");
 208 Clazz.defineMethod (c$, "setDataElements",
 209 function (x, y, inRaster) {
 210 if (!(Clazz.instanceOf (inRaster, jssun.awt.image.BytePackedRaster)) || (inRaster).pixelBitStride != this.pixelBitStride) {
 211 Clazz.superCall (this, jssun.awt.image.BytePackedRaster, "setDataElements", [x, y, inRaster]);
 212 return;
 213 }var srcOffX = inRaster.getMinX ();
 214 var srcOffY = inRaster.getMinY ();
 215 var dstOffX = srcOffX + x;
 216 var dstOffY = srcOffY + y;
 217 var width = inRaster.getWidth ();
 218 var height = inRaster.getHeight ();
 219 if ((dstOffX < this.minX) || (dstOffY < this.minY) || (dstOffX + width > this.maxX) || (dstOffY + height > this.maxY)) {
 220 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 221 }this.setDataElements (dstOffX, dstOffY, srcOffX, srcOffY, width, height, inRaster);
 222 }, "~N,~N,java.awt.image.Raster");
 223 Clazz.defineMethod (c$, "setDataElements",
 224  function (dstX, dstY, srcX, srcY, width, height, inRaster) {
 225 if (width <= 0 || height <= 0) {
 226 return;
 227 }var inData = inRaster.data;
 228 var outData = this.data;
 229 var inscan = inRaster.scanlineStride;
 230 var outscan = this.scanlineStride;
 231 var inbit = inRaster.dataBitOffset + 8 * (srcY - inRaster.minY) * inscan + (srcX - inRaster.minX) * inRaster.pixelBitStride;
 232 var outbit = (this.dataBitOffset + 8 * (dstY - this.minY) * outscan + (dstX - this.minX) * this.pixelBitStride);
 233 var copybits = width * this.pixelBitStride;
 234 if ((inbit & 7) == (outbit & 7)) {
 235 var bitpos = outbit & 7;
 236 if (bitpos != 0) {
 237 var bits = 8 - bitpos;
 238 var inbyte = inbit >> 3;
 239 var outbyte = outbit >> 3;
 240 var mask = 0xff >> bitpos;
 241 if (copybits < bits) {
 242 mask &= 0xff << (bits - copybits);
 243 bits = copybits;
 244 }for (var j = 0; j < height; j++) {
 245 var element = outData[outbyte];
 246 element &= ~mask;
 247 element |= (inData[inbyte] & mask);
 248 outData[outbyte] = element;
 249 inbyte += inscan;
 250 outbyte += outscan;
 251 }
 252 inbit += bits;
 253 outbit += bits;
 254 copybits -= bits;
 255 }if (copybits >= 8) {
 256 var inbyte = inbit >> 3;
 257 var outbyte = outbit >> 3;
 258 var copybytes = copybits >> 3;
 259 if (copybytes == inscan && inscan == outscan) {
 260 System.arraycopy (inData, inbyte, outData, outbyte, inscan * height);
 261 } else {
 262 for (var j = 0; j < height; j++) {
 263 System.arraycopy (inData, inbyte, outData, outbyte, copybytes);
 264 inbyte += inscan;
 265 outbyte += outscan;
 266 }
 267 }var bits = copybytes * 8;
 268 inbit += bits;
 269 outbit += bits;
 270 copybits -= bits;
 271 }if (copybits > 0) {
 272 var inbyte = inbit >> 3;
 273 var outbyte = outbit >> 3;
 274 var mask = (0xff00 >> copybits) & 0xff;
 275 for (var j = 0; j < height; j++) {
 276 var element = outData[outbyte];
 277 element &= ~mask;
 278 element |= (inData[inbyte] & mask);
 279 outData[outbyte] = element;
 280 inbyte += inscan;
 281 outbyte += outscan;
 282 }
 283 }} else {
 284 var bitpos = outbit & 7;
 285 if (bitpos != 0 || copybits < 8) {
 286 var bits = 8 - bitpos;
 287 var inbyte = inbit >> 3;
 288 var outbyte = outbit >> 3;
 289 var lshift = inbit & 7;
 290 var rshift = 8 - lshift;
 291 var mask = 0xff >> bitpos;
 292 if (copybits < bits) {
 293 mask &= 0xff << (bits - copybits);
 294 bits = copybits;
 295 }var lastByte = inData.length - 1;
 296 for (var j = 0; j < height; j++) {
 297 var inData0 = inData[inbyte];
 298 var inData1 = 0;
 299 if (inbyte < lastByte) {
 300 inData1 = inData[inbyte + 1];
 301 }var element = outData[outbyte];
 302 element &= ~mask;
 303 element |= (((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) >> bitpos) & mask;
 304 outData[outbyte] = element;
 305 inbyte += inscan;
 306 outbyte += outscan;
 307 }
 308 inbit += bits;
 309 outbit += bits;
 310 copybits -= bits;
 311 }if (copybits >= 8) {
 312 var inbyte = inbit >> 3;
 313 var outbyte = outbit >> 3;
 314 var copybytes = copybits >> 3;
 315 var lshift = inbit & 7;
 316 var rshift = 8 - lshift;
 317 for (var j = 0; j < height; j++) {
 318 var ibyte = inbyte + j * inscan;
 319 var obyte = outbyte + j * outscan;
 320 var inData0 = inData[ibyte];
 321 for (var i = 0; i < copybytes; i++) {
 322 var inData1 = inData[ibyte + 1];
 323 var val = (inData0 << lshift) | ((inData1 & 0xff) >> rshift);
 324 outData[obyte] = val;
 325 inData0 = inData1;
 326 ++ibyte;
 327 ++obyte;
 328 }
 329 }
 330 var bits = copybytes * 8;
 331 inbit += bits;
 332 outbit += bits;
 333 copybits -= bits;
 334 }if (copybits > 0) {
 335 var inbyte = inbit >> 3;
 336 var outbyte = outbit >> 3;
 337 var mask = (0xff00 >> copybits) & 0xff;
 338 var lshift = inbit & 7;
 339 var rshift = 8 - lshift;
 340 var lastByte = inData.length - 1;
 341 for (var j = 0; j < height; j++) {
 342 var inData0 = inData[inbyte];
 343 var inData1 = 0;
 344 if (inbyte < lastByte) {
 345 inData1 = inData[inbyte + 1];
 346 }var element = outData[outbyte];
 347 element &= ~mask;
 348 element |= ((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) & mask;
 349 outData[outbyte] = element;
 350 inbyte += inscan;
 351 outbyte += outscan;
 352 }
 353 }}this.markDirty ();
 354 }, "~N,~N,~N,~N,~N,~N,jssun.awt.image.BytePackedRaster");
 355 Clazz.defineMethod (c$, "setRect",
 356 function (dx, dy, srcRaster) {
 357 if (!(Clazz.instanceOf (srcRaster, jssun.awt.image.BytePackedRaster)) || (srcRaster).pixelBitStride != this.pixelBitStride) {
 358 Clazz.superCall (this, jssun.awt.image.BytePackedRaster, "setRect", [dx, dy, srcRaster]);
 359 return;
 360 }var width = srcRaster.getWidth ();
 361 var height = srcRaster.getHeight ();
 362 var srcOffX = srcRaster.getMinX ();
 363 var srcOffY = srcRaster.getMinY ();
 364 var dstOffX = dx + srcOffX;
 365 var dstOffY = dy + srcOffY;
 366 if (dstOffX < this.minX) {
 367 var skipX = this.minX - dstOffX;
 368 width -= skipX;
 369 srcOffX += skipX;
 370 dstOffX = this.minX;
 371 }if (dstOffY < this.minY) {
 372 var skipY = this.minY - dstOffY;
 373 height -= skipY;
 374 srcOffY += skipY;
 375 dstOffY = this.minY;
 376 }if (dstOffX + width > this.maxX) {
 377 width = this.maxX - dstOffX;
 378 }if (dstOffY + height > this.maxY) {
 379 height = this.maxY - dstOffY;
 380 }this.setDataElements (dstOffX, dstOffY, srcOffX, srcOffY, width, height, srcRaster);
 381 }, "~N,~N,java.awt.image.Raster");
 382 Clazz.defineMethod (c$, "setDataElements",
 383 function (x, y, w, h, obj) {
 384 this.putByteData (x, y, w, h, obj);
 385 }, "~N,~N,~N,~N,~O");
 386 Clazz.defineMethod (c$, "putByteData",
 387 function (x, y, w, h, band, inData) {
 388 this.putByteData (x, y, w, h, inData);
 389 }, "~N,~N,~N,~N,~N,~A");
 390 Clazz.defineMethod (c$, "putByteData",
 391 function (x, y, w, h, inData) {
 392 if ((x < this.minX) || (y < this.minY) || (x + w > this.maxX) || (y + h > this.maxY)) {
 393 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 394 }if (w == 0 || h == 0) {
 395 return;
 396 }var pixbits = this.pixelBitStride;
 397 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
 398 var index = (y - this.minY) * this.scanlineStride;
 399 var outindex = 0;
 400 var data = this.data;
 401 for (var j = 0; j < h; j++) {
 402 var bitnum = scanbit;
 403 var element;
 404 var i = 0;
 405 while ((i < w) && ((bitnum & 7) != 0)) {
 406 var shift = this.shiftOffset - (bitnum & 7);
 407 element = data[index + (bitnum >> 3)];
 408 element &= ~(this.bitMask << shift);
 409 element |= (inData[outindex++] & this.bitMask) << shift;
 410 data[index + (bitnum >> 3)] = element;
 411 bitnum += pixbits;
 412 i++;
 413 }
 414 var inIndex = index + (bitnum >> 3);
 415 switch (pixbits) {
 416 case 1:
 417 for (; i < w - 7; i += 8) {
 418 element = (inData[outindex++] & 1) << 7;
 419 element |= (inData[outindex++] & 1) << 6;
 420 element |= (inData[outindex++] & 1) << 5;
 421 element |= (inData[outindex++] & 1) << 4;
 422 element |= (inData[outindex++] & 1) << 3;
 423 element |= (inData[outindex++] & 1) << 2;
 424 element |= (inData[outindex++] & 1) << 1;
 425 element |= (inData[outindex++] & 1);
 426 data[inIndex++] = element;
 427 bitnum += 8;
 428 }
 429 break;
 430 case 2:
 431 for (; i < w - 7; i += 8) {
 432 element = (inData[outindex++] & 3) << 6;
 433 element |= (inData[outindex++] & 3) << 4;
 434 element |= (inData[outindex++] & 3) << 2;
 435 element |= (inData[outindex++] & 3);
 436 data[inIndex++] = element;
 437 element = (inData[outindex++] & 3) << 6;
 438 element |= (inData[outindex++] & 3) << 4;
 439 element |= (inData[outindex++] & 3) << 2;
 440 element |= (inData[outindex++] & 3);
 441 data[inIndex++] = element;
 442 bitnum += 16;
 443 }
 444 break;
 445 case 4:
 446 for (; i < w - 7; i += 8) {
 447 element = (inData[outindex++] & 0xf) << 4;
 448 element |= (inData[outindex++] & 0xf);
 449 data[inIndex++] = element;
 450 element = (inData[outindex++] & 0xf) << 4;
 451 element |= (inData[outindex++] & 0xf);
 452 data[inIndex++] = element;
 453 element = (inData[outindex++] & 0xf) << 4;
 454 element |= (inData[outindex++] & 0xf);
 455 data[inIndex++] = element;
 456 element = (inData[outindex++] & 0xf) << 4;
 457 element |= (inData[outindex++] & 0xf);
 458 data[inIndex++] = element;
 459 bitnum += 32;
 460 }
 461 break;
 462 }
 463 for (; i < w; i++) {
 464 var shift = this.shiftOffset - (bitnum & 7);
 465 element = data[index + (bitnum >> 3)];
 466 element &= ~(this.bitMask << shift);
 467 element |= (inData[outindex++] & this.bitMask) << shift;
 468 data[index + (bitnum >> 3)] = element;
 469 bitnum += pixbits;
 470 }
 471 index += this.scanlineStride;
 472 }
 473 this.markDirty ();
 474 }, "~N,~N,~N,~N,~A");
 475 Clazz.defineMethod (c$, "getPixels",
 476 function (x, y, w, h, iArray) {
 477 if ((x < this.minX) || (y < this.minY) || (x + w > this.maxX) || (y + h > this.maxY)) {
 478 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 479 }if (iArray == null) {
 480 iArray =  Clazz.newIntArray (w * h, 0);
 481 }var pixbits = this.pixelBitStride;
 482 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
 483 var index = (y - this.minY) * this.scanlineStride;
 484 var outindex = 0;
 485 var data = this.data;
 486 for (var j = 0; j < h; j++) {
 487 var bitnum = scanbit;
 488 var element;
 489 var i = 0;
 490 while ((i < w) && ((bitnum & 7) != 0)) {
 491 var shift = this.shiftOffset - (bitnum & 7);
 492 iArray[outindex++] = this.bitMask & (data[index + (bitnum >> 3)] >> shift);
 493 bitnum += pixbits;
 494 i++;
 495 }
 496 var inIndex = index + (bitnum >> 3);
 497 switch (pixbits) {
 498 case 1:
 499 for (; i < w - 7; i += 8) {
 500 element = data[inIndex++];
 501 iArray[outindex++] = (element >> 7) & 1;
 502 iArray[outindex++] = (element >> 6) & 1;
 503 iArray[outindex++] = (element >> 5) & 1;
 504 iArray[outindex++] = (element >> 4) & 1;
 505 iArray[outindex++] = (element >> 3) & 1;
 506 iArray[outindex++] = (element >> 2) & 1;
 507 iArray[outindex++] = (element >> 1) & 1;
 508 iArray[outindex++] = element & 1;
 509 bitnum += 8;
 510 }
 511 break;
 512 case 2:
 513 for (; i < w - 7; i += 8) {
 514 element = data[inIndex++];
 515 iArray[outindex++] = (element >> 6) & 3;
 516 iArray[outindex++] = (element >> 4) & 3;
 517 iArray[outindex++] = (element >> 2) & 3;
 518 iArray[outindex++] = element & 3;
 519 element = data[inIndex++];
 520 iArray[outindex++] = (element >> 6) & 3;
 521 iArray[outindex++] = (element >> 4) & 3;
 522 iArray[outindex++] = (element >> 2) & 3;
 523 iArray[outindex++] = element & 3;
 524 bitnum += 16;
 525 }
 526 break;
 527 case 4:
 528 for (; i < w - 7; i += 8) {
 529 element = data[inIndex++];
 530 iArray[outindex++] = (element >> 4) & 0xf;
 531 iArray[outindex++] = element & 0xf;
 532 element = data[inIndex++];
 533 iArray[outindex++] = (element >> 4) & 0xf;
 534 iArray[outindex++] = element & 0xf;
 535 element = data[inIndex++];
 536 iArray[outindex++] = (element >> 4) & 0xf;
 537 iArray[outindex++] = element & 0xf;
 538 element = data[inIndex++];
 539 iArray[outindex++] = (element >> 4) & 0xf;
 540 iArray[outindex++] = element & 0xf;
 541 bitnum += 32;
 542 }
 543 break;
 544 }
 545 for (; i < w; i++) {
 546 var shift = this.shiftOffset - (bitnum & 7);
 547 iArray[outindex++] = this.bitMask & (data[index + (bitnum >> 3)] >> shift);
 548 bitnum += pixbits;
 549 }
 550 index += this.scanlineStride;
 551 }
 552 return iArray;
 553 }, "~N,~N,~N,~N,~A");
 554 Clazz.defineMethod (c$, "setPixels",
 555 function (x, y, w, h, iArray) {
 556 if ((x < this.minX) || (y < this.minY) || (x + w > this.maxX) || (y + h > this.maxY)) {
 557 throw  new ArrayIndexOutOfBoundsException ("Coordinate out of bounds!");
 558 }var pixbits = this.pixelBitStride;
 559 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
 560 var index = (y - this.minY) * this.scanlineStride;
 561 var outindex = 0;
 562 var data = this.data;
 563 for (var j = 0; j < h; j++) {
 564 var bitnum = scanbit;
 565 var element;
 566 var i = 0;
 567 while ((i < w) && ((bitnum & 7) != 0)) {
 568 var shift = this.shiftOffset - (bitnum & 7);
 569 element = data[index + (bitnum >> 3)];
 570 element &= ~(this.bitMask << shift);
 571 element |= (iArray[outindex++] & this.bitMask) << shift;
 572 data[index + (bitnum >> 3)] = element;
 573 bitnum += pixbits;
 574 i++;
 575 }
 576 var inIndex = index + (bitnum >> 3);
 577 switch (pixbits) {
 578 case 1:
 579 for (; i < w - 7; i += 8) {
 580 element = (iArray[outindex++] & 1) << 7;
 581 element |= (iArray[outindex++] & 1) << 6;
 582 element |= (iArray[outindex++] & 1) << 5;
 583 element |= (iArray[outindex++] & 1) << 4;
 584 element |= (iArray[outindex++] & 1) << 3;
 585 element |= (iArray[outindex++] & 1) << 2;
 586 element |= (iArray[outindex++] & 1) << 1;
 587 element |= (iArray[outindex++] & 1);
 588 data[inIndex++] = element;
 589 bitnum += 8;
 590 }
 591 break;
 592 case 2:
 593 for (; i < w - 7; i += 8) {
 594 element = (iArray[outindex++] & 3) << 6;
 595 element |= (iArray[outindex++] & 3) << 4;
 596 element |= (iArray[outindex++] & 3) << 2;
 597 element |= (iArray[outindex++] & 3);
 598 data[inIndex++] = element;
 599 element = (iArray[outindex++] & 3) << 6;
 600 element |= (iArray[outindex++] & 3) << 4;
 601 element |= (iArray[outindex++] & 3) << 2;
 602 element |= (iArray[outindex++] & 3);
 603 data[inIndex++] = element;
 604 bitnum += 16;
 605 }
 606 break;
 607 case 4:
 608 for (; i < w - 7; i += 8) {
 609 element = (iArray[outindex++] & 0xf) << 4;
 610 element |= (iArray[outindex++] & 0xf);
 611 data[inIndex++] = element;
 612 element = (iArray[outindex++] & 0xf) << 4;
 613 element |= (iArray[outindex++] & 0xf);
 614 data[inIndex++] = element;
 615 element = (iArray[outindex++] & 0xf) << 4;
 616 element |= (iArray[outindex++] & 0xf);
 617 data[inIndex++] = element;
 618 element = (iArray[outindex++] & 0xf) << 4;
 619 element |= (iArray[outindex++] & 0xf);
 620 data[inIndex++] = element;
 621 bitnum += 32;
 622 }
 623 break;
 624 }
 625 for (; i < w; i++) {
 626 var shift = this.shiftOffset - (bitnum & 7);
 627 element = data[index + (bitnum >> 3)];
 628 element &= ~(this.bitMask << shift);
 629 element |= (iArray[outindex++] & this.bitMask) << shift;
 630 data[index + (bitnum >> 3)] = element;
 631 bitnum += pixbits;
 632 }
 633 index += this.scanlineStride;
 634 }
 635 this.markDirty ();
 636 }, "~N,~N,~N,~N,~A");
 637 Clazz.overrideMethod (c$, "createChild",
 638 function (x, y, width, height, x0, y0, bandList) {
 639 var newRaster = this.createWritableChild (x, y, width, height, x0, y0, bandList);
 640 return newRaster;
 641 }, "~N,~N,~N,~N,~N,~N,~A");
 642 Clazz.overrideMethod (c$, "createWritableChild",
 643 function (x, y, width, height, x0, y0, bandList) {
 644 if (x < this.minX) {
 645 throw  new java.awt.image.RasterFormatException ("x lies outside the raster");
 646 }if (y < this.minY) {
 647 throw  new java.awt.image.RasterFormatException ("y lies outside the raster");
 648 }if ((x + width < x) || (x + width > this.minX + this.width)) {
 649 throw  new java.awt.image.RasterFormatException ("(x + width) is outside of Raster");
 650 }if ((y + height < y) || (y + height > this.minY + this.height)) {
 651 throw  new java.awt.image.RasterFormatException ("(y + height) is outside of Raster");
 652 }var sm;
 653 if (bandList != null) {
 654 sm = this.sampleModel.createSubsetSampleModel (bandList);
 655 } else {
 656 sm = this.sampleModel;
 657 }var deltaX = x0 - x;
 658 var deltaY = y0 - y;
 659 return  new jssun.awt.image.BytePackedRaster (sm, this.dataBuffer,  new java.awt.Rectangle (x0, y0, width, height),  new java.awt.Point (this.sampleModelTranslateX + deltaX, this.sampleModelTranslateY + deltaY), this);
 660 }, "~N,~N,~N,~N,~N,~N,~A");
 661 Clazz.defineMethod (c$, "createCompatibleWritableRaster",
 662 function (w, h) {
 663 if (w <= 0 || h <= 0) {
 664 throw  new java.awt.image.RasterFormatException ("negative " + ((w <= 0) ? "width" : "height"));
 665 }var sm = this.sampleModel.createCompatibleSampleModel (w, h);
 666 return  new jssun.awt.image.BytePackedRaster (sm,  new java.awt.Point (0, 0));
 667 }, "~N,~N");
 668 Clazz.defineMethod (c$, "createCompatibleWritableRaster",
 669 function () {
 670 return this.createCompatibleWritableRaster (this.width, this.height);
 671 });
 672 Clazz.defineMethod (c$, "verify",
 673  function (strictCheck) {
 674 if (this.dataBitOffset < 0) {
 675 throw  new java.awt.image.RasterFormatException ("Data offsets must be >= 0");
 676 }if (this.width <= 0 || this.height <= 0 || this.height > (Clazz.doubleToInt (2147483647 / this.width))) {
 677 throw  new java.awt.image.RasterFormatException ("Invalid raster dimension");
 678 }if ((this.width - 1) > Clazz.doubleToInt (2147483647 / this.pixelBitStride)) {
 679 throw  new java.awt.image.RasterFormatException ("Invalid raster dimension");
 680 }if (this.minX - this.sampleModelTranslateX < 0 || this.minY - this.sampleModelTranslateY < 0) {
 681 throw  new java.awt.image.RasterFormatException ("Incorrect origin/translate: (" + this.minX + ", " + this.minY + ") / (" + this.sampleModelTranslateX + ", " + this.sampleModelTranslateY + ")");
 682 }if (this.scanlineStride < 0 || this.scanlineStride > (Clazz.doubleToInt (2147483647 / this.height))) {
 683 throw  new java.awt.image.RasterFormatException ("Invalid scanline stride");
 684 }if (this.height > 1 || this.minY - this.sampleModelTranslateY > 0) {
 685 if (this.scanlineStride > this.data.length) {
 686 throw  new java.awt.image.RasterFormatException ("Incorrect scanline stride: " + this.scanlineStride);
 687 }}var lastbit = this.dataBitOffset + (this.height - 1) * this.scanlineStride * 8 + (this.width - 1) * this.pixelBitStride + this.pixelBitStride - 1;
 688 if (lastbit < 0 || Clazz.doubleToInt (lastbit / 8) >= this.data.length) {
 689 throw  new java.awt.image.RasterFormatException ("raster dimensions overflow array bounds");
 690 }if (strictCheck) {
 691 if (this.height > 1) {
 692 lastbit = this.width * this.pixelBitStride - 1;
 693 if (Clazz.doubleToInt (lastbit / 8) >= this.scanlineStride) {
 694 throw  new java.awt.image.RasterFormatException ("data for adjacent scanlines overlaps");
 695 }}}}, "~B");
 696 Clazz.overrideMethod (c$, "toString",
 697 function () {
 698 return  String.instantialize ("BytePackedRaster: width = " + this.width + " height = " + this.height + " #channels " + this.numBands + " xOff = " + this.sampleModelTranslateX + " yOff = " + this.sampleModelTranslateY);
 699 });
 700 });