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;
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;
48 throw new java.awt.image.RasterFormatException ("BytePackedRasters must haveMultiPixelPackedSampleModel");
50 }, "java.awt.image.SampleModel,java.awt.image.DataBuffer,java.awt.Rectangle,java.awt.Point,jssun.awt.image.BytePackedRaster");
51 Clazz.defineMethod (c$, "getDataBitOffset",
53 return this.dataBitOffset;
55 Clazz.defineMethod (c$, "getScanlineStride",
57 return this.scanlineStride;
59 Clazz.defineMethod (c$, "getPixelBitStride",
61 return this.pixelBitStride;
63 Clazz.defineMethod (c$, "getDataStorage",
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!");
73 outData = Clazz.newByteArray (this.numDataElements, 0);
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);
82 Clazz.defineMethod (c$, "getDataElements",
83 function (x, y, w, h, outData) {
84 return this.getByteData (x, y, w, h, outData);
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!");
92 outData = Clazz.newByteArray (this.numDataElements * w * h, 0);
95 }var pixbits = this.pixelBitStride;
96 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
97 var index = (y - this.minY) * this.scanlineStride;
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));
107 index += this.scanlineStride;
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;
125 var data = this.data;
126 for (var j = 0; j < h; j++) {
127 var bitnum = scanbit;
130 while ((i < w) && ((bitnum & 7) != 0)) {
131 var shift = this.shiftOffset - (bitnum & 7);
132 outData[outindex++] = (this.bitMask & (data[index + (bitnum >> 3)] >> shift));
136 var inIndex = index + (bitnum >> 3);
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);
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);
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);
186 var shift = this.shiftOffset - (bitnum & 7);
187 outData[outindex++] = (this.bitMask & (data[index + (bitnum >> 3)] >> shift));
190 index += this.scanlineStride;
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!");
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;
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]);
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) {
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;
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);
244 }for (var j = 0; j < height; j++) {
245 var element = outData[outbyte];
247 element |= (inData[inbyte] & mask);
248 outData[outbyte] = element;
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);
262 for (var j = 0; j < height; j++) {
263 System.arraycopy (inData, inbyte, outData, outbyte, copybytes);
267 }var bits = copybytes * 8;
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];
278 element |= (inData[inbyte] & mask);
279 outData[outbyte] = element;
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);
295 }var lastByte = inData.length - 1;
296 for (var j = 0; j < height; j++) {
297 var inData0 = inData[inbyte];
299 if (inbyte < lastByte) {
300 inData1 = inData[inbyte + 1];
301 }var element = outData[outbyte];
303 element |= (((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) >> bitpos) & mask;
304 outData[outbyte] = element;
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;
330 var bits = copybytes * 8;
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];
344 if (inbyte < lastByte) {
345 inData1 = inData[inbyte + 1];
346 }var element = outData[outbyte];
348 element |= ((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) & mask;
349 outData[outbyte] = element;
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]);
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;
371 }if (dstOffY < this.minY) {
372 var skipY = this.minY - dstOffY;
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) {
396 }var pixbits = this.pixelBitStride;
397 var scanbit = this.dataBitOffset + (x - this.minX) * pixbits;
398 var index = (y - this.minY) * this.scanlineStride;
400 var data = this.data;
401 for (var j = 0; j < h; j++) {
402 var bitnum = scanbit;
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;
414 var inIndex = index + (bitnum >> 3);
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;
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;
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;
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;
471 index += this.scanlineStride;
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;
485 var data = this.data;
486 for (var j = 0; j < h; j++) {
487 var bitnum = scanbit;
490 while ((i < w) && ((bitnum & 7) != 0)) {
491 var shift = this.shiftOffset - (bitnum & 7);
492 iArray[outindex++] = this.bitMask & (data[index + (bitnum >> 3)] >> shift);
496 var inIndex = index + (bitnum >> 3);
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;
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;
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;
546 var shift = this.shiftOffset - (bitnum & 7);
547 iArray[outindex++] = this.bitMask & (data[index + (bitnum >> 3)] >> shift);
550 index += this.scanlineStride;
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;
562 var data = this.data;
563 for (var j = 0; j < h; j++) {
564 var bitnum = scanbit;
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;
576 var inIndex = index + (bitnum >> 3);
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;
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;
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;
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;
633 index += this.scanlineStride;
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);
641 }, "~N,~N,~N,~N,~N,~N,~A");
642 Clazz.overrideMethod (c$, "createWritableChild",
643 function (x, y, width, height, x0, y0, bandList) {
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");
653 if (bandList != null) {
654 sm = this.sampleModel.createSubsetSampleModel (bandList);
656 sm = this.sampleModel;
657 }var deltaX = x0 - x;
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",
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));
668 Clazz.defineMethod (c$, "createCompatibleWritableRaster",
670 return this.createCompatibleWritableRaster (this.width, this.height);
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");
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");
696 Clazz.overrideMethod (c$, "toString",
698 return String.instantialize ("BytePackedRaster: width = " + this.width + " height = " + this.height + " #channels " + this.numBands + " xOff = " + this.sampleModelTranslateX + " yOff = " + this.sampleModelTranslateY);