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
9 this.shiftOffset = 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
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
53 return this.dataBitOffset;
\r
55 Clazz.defineMethod (c$, "getScanlineStride",
\r
57 return this.scanlineStride;
\r
59 Clazz.defineMethod (c$, "getPixelBitStride",
\r
61 return this.pixelBitStride;
\r
63 Clazz.defineMethod (c$, "getDataStorage",
\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
73 outData = Clazz.newByteArray (this.numDataElements, 0);
\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
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
92 outData = Clazz.newByteArray (this.numDataElements * w * h, 0);
\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
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
107 index += this.scanlineStride;
\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
125 var data = this.data;
\r
126 for (var j = 0; j < h; j++) {
\r
127 var bitnum = scanbit;
\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
136 var inIndex = index + (bitnum >> 3);
\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
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
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
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
190 index += this.scanlineStride;
\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
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
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
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
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
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
244 }for (var j = 0; j < height; j++) {
\r
245 var element = outData[outbyte];
\r
247 element |= (inData[inbyte] & mask);
\r
248 outData[outbyte] = element;
\r
250 outbyte += outscan;
\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
262 for (var j = 0; j < height; j++) {
\r
263 System.arraycopy (inData, inbyte, outData, outbyte, copybytes);
\r
265 outbyte += outscan;
\r
267 }var bits = copybytes * 8;
\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
278 element |= (inData[inbyte] & mask);
\r
279 outData[outbyte] = element;
\r
281 outbyte += outscan;
\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
295 }var lastByte = inData.length - 1;
\r
296 for (var j = 0; j < height; j++) {
\r
297 var inData0 = inData[inbyte];
\r
299 if (inbyte < lastByte) {
\r
300 inData1 = inData[inbyte + 1];
\r
301 }var element = outData[outbyte];
\r
303 element |= (((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) >> bitpos) & mask;
\r
304 outData[outbyte] = element;
\r
306 outbyte += outscan;
\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
330 var bits = copybytes * 8;
\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
344 if (inbyte < lastByte) {
\r
345 inData1 = inData[inbyte + 1];
\r
346 }var element = outData[outbyte];
\r
348 element |= ((inData0 << lshift) | ((inData1 & 0xff) >> rshift)) & mask;
\r
349 outData[outbyte] = element;
\r
351 outbyte += outscan;
\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
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
370 dstOffX = this.minX;
\r
371 }if (dstOffY < this.minY) {
\r
372 var skipY = this.minY - dstOffY;
\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
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
400 var data = this.data;
\r
401 for (var j = 0; j < h; j++) {
\r
402 var bitnum = scanbit;
\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
414 var inIndex = index + (bitnum >> 3);
\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
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
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
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
471 index += this.scanlineStride;
\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
485 var data = this.data;
\r
486 for (var j = 0; j < h; j++) {
\r
487 var bitnum = scanbit;
\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
496 var inIndex = index + (bitnum >> 3);
\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
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
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
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
550 index += this.scanlineStride;
\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
562 var data = this.data;
\r
563 for (var j = 0; j < h; j++) {
\r
564 var bitnum = scanbit;
\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
576 var inIndex = index + (bitnum >> 3);
\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
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
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
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
633 index += this.scanlineStride;
\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
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
653 if (bandList != null) {
\r
654 sm = this.sampleModel.createSubsetSampleModel (bandList);
\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
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
668 Clazz.defineMethod (c$, "createCompatibleWritableRaster",
\r
670 return this.createCompatibleWritableRaster (this.width, this.height);
\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
696 Clazz.overrideMethod (c$, "toString",
\r
698 return String.instantialize ("BytePackedRaster: width = " + this.width + " height = " + this.height + " #channels " + this.numBands + " xOff = " + this.sampleModelTranslateX + " yOff = " + this.sampleModelTranslateY);
\r