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

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