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

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