1 /*
2 * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #import "ImageSurfaceData.h"
27
28 #import "java_awt_Transparency.h"
29 #import "java_awt_image_BufferedImage.h"
30 #import "sun_awt_image_BufImgSurfaceData.h"
31 #import "sun_java2d_OSXOffScreenSurfaceData.h"
32
33 #import "jni_util.h"
34 #import <JavaNativeFoundation/JavaNativeFoundation.h>
35
36 #import "BufImgSurfaceData.h"
37 #import "ThreadUtilities.h"
38
39
40
41 //#define DEBUG 1
42 #if defined DEBUG
43 #define IMAGE_SURFACE_INLINE
44 #define PRINT(msg) {fprintf(stderr, "%s\n", msg);fflush(stderr);}
45 #else
46 #define IMAGE_SURFACE_INLINE static inline
47 #define PRINT(msg) {}
48 #endif
49
50 // same value as defined in Sun's own code
51 #define XOR_ALPHA_CUTOFF 128
52
53 // for vImage framework headers
54 #include <Accelerate/Accelerate.h>
55
56 static ContextInfo sDefaultContextInfo[sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB+1] =
57 {
58 {YES, YES, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_CUSTOM // special case
59 {YES, YES, 8, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_RGB
60 {YES, YES, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_ARGB
61 {YES, YES, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_ARGB_PRE
62 {YES, YES, 8, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_BGR
63 {YES, NO, 8, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_3BYTE_BGR // use the default ARGB_PRE context synce we have to sync by hand anyway
64 {YES, YES, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_4BYTE_ABGR
65 {YES, YES, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_4BYTE_ABGR_PRE
66 #ifdef __LITTLE_ENDIAN__
67 {YES, YES, 5, 2, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host, NULL}, // TYPE_USHORT_565_RGB
68 {YES, YES, 5, 2, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host, NULL}, // TYPE_USHORT_555_RGB
69 #else
70 {YES, YES, 5, 2, 0, kCGImageAlphaNoneSkipFirst, NULL}, // TYPE_USHORT_565_RGB
71 {YES, YES, 5, 2, 0, kCGImageAlphaNoneSkipFirst, NULL}, // TYPE_USHORT_555_RGB
72 #endif
73 {YES, YES, 8, 1, 0, kCGImageAlphaNone, NULL}, // TYPE_BYTE_GRAY
74 {YES, NO, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_USHORT_GRAY // use the default ARGB_PRE context synce we have to sync by hand anyway
75 {NO, NO, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_BYTE_BINARY mapped to TYPE_CUSTOM
76 {YES, NO, 8, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_BYTE_INDEXED // use the default ARGB_PRE context synce we have to sync by hand anyway
77 {YES, NO, 8, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_3BYTE_RGB
78 };
79
80 static ImageInfo sDefaultImageInfo[sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB+1] =
81 {
82 {8, 32, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_CUSTOM
83 {8, 32, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_RGB
84 {8, 32, 4, 0, kCGImageAlphaFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_ARGB
85 {8, 32, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_ARGB_PRE
86 {8, 32, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_INT_BGR
87 {8, 32, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_3BYTE_BGR
88 {8, 32, 4, 0, kCGImageAlphaFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_4BYTE_ABGR
89 {8, 32, 4, 0, kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_4BYTE_ABGR_PRE
90 #ifdef __LITTLE_ENDIAN__
91 {5, 16, 2, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host, NULL}, // TYPE_USHORT_565_RGB
92 {5, 16, 2, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder16Host, NULL}, // TYPE_USHORT_555_RGB
93 #else
94 {5, 16, 2, 0, kCGImageAlphaNoneSkipFirst, NULL}, // TYPE_USHORT_565_RGB
95 {5, 16, 2, 0, kCGImageAlphaNoneSkipFirst, NULL}, // TYPE_USHORT_555_RGB
96 #endif
97 {8, 8, 1, 0, kCGImageAlphaNone, NULL}, // TYPE_BYTE_GRAY
98 {16, 16, 2, 0, kCGImageAlphaNone | kCGBitmapByteOrder16Host, NULL}, // TYPE_USHORT_GRAY
99 {0, 0, 0, 0, -1, NULL}, // TYPE_BYTE_BINARY mapped to TYPE_CUSTOM
100 {8, 32, 4, 0, kCGImageAlphaFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_BYTE_INDEXED // Fully OPAQUE INDEXED images will use kCGImageAlphaNoneSkipFirst for performance reasosn. see <rdar://4224874>
101 {8, 32, 4, 0, kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host, NULL}, // TYPE_3BYTE_RGB
102 };
103
104 static jfieldID rgbID;
105 static jfieldID mapSizeID;
106 static jfieldID CMpDataID;
107 static jfieldID allGrayID;
108
109
110 static JNF_CLASS_CACHE(jc_OSXOffScreenSurfaceData, "sun/java2d/OSXOffScreenSurfaceData");
111 static JNF_MEMBER_CACHE(jm_syncFromCustom, jc_OSXOffScreenSurfaceData, "syncFromCustom", "()V");
112 static JNF_MEMBER_CACHE(jm_syncToCustom, jc_OSXOffScreenSurfaceData, "syncToCustom", "()V");
113 static JNF_CLASS_CACHE(jc_BufferedImage, "java/awt/image/BufferedImage");
114 static JNF_MEMBER_CACHE(jm_SurfaceData, jc_BufferedImage, "sData", "Lsun/java2d/SurfaceData;");
115 static JNF_CLASS_CACHE(jc_IndexColorModel, "java/awt/image/IndexColorModel");
116 static JNF_MEMBER_CACHE(jm_rgb, jc_IndexColorModel, "rgb", "[I");
117 static JNF_MEMBER_CACHE(jm_transparency, jc_IndexColorModel, "transparency", "I");
118 static JNF_MEMBER_CACHE(jm_transparent_index, jc_IndexColorModel, "transparent_index", "I");
119
120 CGColorSpaceRef gColorspaceRGB = NULL;
121 CGColorSpaceRef gColorspaceGray = NULL;
122
123 IMAGE_SURFACE_INLINE void PrintImageInfo(ImageSDOps* isdo)
124 {
125 fprintf(stderr, "\n");
126 fprintf(stderr, "PrintImageInfo:\n");
127 fprintf(stderr, "\t \n");
128 //fprintf(stderr, "\t magicID=%d\n", (jint)isdo->magicID);
129 //fprintf(stderr, "\n");
130 fprintf(stderr, "\t isdo=%p\n", isdo);
131 fprintf(stderr, "\t \n");
132 fprintf(stderr, "\t contextInfo:\n");
133 fprintf(stderr, "\t useWindowContextReference=%d\n", isdo->contextInfo.useWindowContextReference);
134 fprintf(stderr, "\t canUseJavaPixelsAsContext=%d\n", isdo->contextInfo.canUseJavaPixelsAsContext);
135 fprintf(stderr, "\t bitsPerComponent=%ld\n", (long)isdo->contextInfo.bitsPerComponent);
136 fprintf(stderr, "\t bytesPerPixel=%ld\n", (long)isdo->contextInfo.bytesPerPixel);
137 fprintf(stderr, "\t bytesPerRow=%ld\n", (long)isdo->contextInfo.bytesPerRow);
138 fprintf(stderr, "\t alphaInfo=%ld\n", (long)isdo->contextInfo.alphaInfo);
139 fprintf(stderr, "\t \n");
140 fprintf(stderr, "\t imageInfo:\n");
141 fprintf(stderr, "\t bitsPerComponent=%ld\n", (long)isdo->imageInfo.bitsPerComponent);
142 fprintf(stderr, "\t bitsPerPixel=%ld\n", (long)isdo->imageInfo.bitsPerPixel);
143 fprintf(stderr, "\t bytesPerPixel=%ld\n", (long)isdo->imageInfo.bytesPerPixel);
144 fprintf(stderr, "\t bytesPerRow=%ld\n", (long)isdo->imageInfo.bytesPerRow);
145 fprintf(stderr, "\t alphaInfo=%ld\n", (long)isdo->imageInfo.alphaInfo);
146 fprintf(stderr, "\t \n");
147 fprintf(stderr, "\t isSubImage=%d\n", isdo->isSubImage);
148 fprintf(stderr, "\t \n");
149 fprintf(stderr, "\t java info:\n");
150 fprintf(stderr, "\t array=%p\n", isdo->array);
151 fprintf(stderr, "\t offset=%d\n", (int)isdo->offset);
152 fprintf(stderr, "\t width=%d\n", (int)isdo->width);
153 fprintf(stderr, "\t height=%d\n", (int)isdo->height);
154 fprintf(stderr, "\t javaPixelBytes=%d\n", (int)isdo->javaPixelBytes);
155 fprintf(stderr, "\t javaPixelsBytesPerRow=%d\n", (int)isdo->javaPixelsBytesPerRow);
156 fprintf(stderr, "\t icm=%p\n", isdo->icm);
157 fprintf(stderr, "\t type=%d\n", (int)isdo->type);
158 fprintf(stderr, "\n");
159 fprintf(stderr, "\t cgRef=%p\n", isdo->qsdo.cgRef);
160 fprintf(stderr, "\t nsRef=%p\n", isdo->nsRef);
161 fprintf(stderr, "\n");
162 fprintf(stderr, "\t pixelsLocked=%p\n", isdo->pixelsLocked);
163 fprintf(stderr, "\t pixels=%p\n", isdo->pixels);
164 fprintf(stderr, "\n");
165 fprintf(stderr, "\t indexedColorTable=%p\n", isdo->indexedColorTable);
166 fprintf(stderr, "\t lutData=%p\n", isdo->lutData);
167 fprintf(stderr, "\t lutDataSize=%u\n", (unsigned)isdo->lutDataSize);
168 fprintf(stderr, "\n");
169 fprintf(stderr, "\t nrOfPixelsOwners=%u\n", (unsigned)isdo->nrOfPixelsOwners);
170 fprintf(stderr, "\n");
171 }
172
173 // if there is no image created for isdo.imgRef, it creates and image using the isdo.dataProvider
174 // If there is an image present, this is a no-op
175 void makeSureImageIsCreated(ImageSDOps* isdo)
176 {
177 if (isdo->imgRef == NULL) // create the image
178 {
179 isdo->imgRef = CGImageCreate(isdo->width,
180 isdo->height,
181 isdo->contextInfo.bitsPerComponent,
182 isdo->contextInfo.bytesPerPixel * 8,
183 isdo->contextInfo.bytesPerRow,
184 isdo->contextInfo.colorSpace,
185 isdo->contextInfo.alphaInfo,
186 isdo->dataProvider,
187 NULL,
188 NO,
189 kCGRenderingIntentDefault);
190 }
191 }
192
193 IMAGE_SURFACE_INLINE void customPixelsFromJava(JNIEnv *env, ImageSDOps *isdo)
194 {
195 PRINT(" customPixelsFromJava")
196
197 SurfaceDataOps *sdo = (SurfaceDataOps*)isdo;
198 JNFCallVoidMethod([ThreadUtilities getJNIEnv], sdo->sdObject, jm_syncFromCustom); // AWT_THREADING Safe (known object)
199 }
200
201
202 IMAGE_SURFACE_INLINE void copyBits(jint w, jint h, jint javaPixelsBytesPerRow, Pixel8bit *pixelsSrc, jint dstPixelsBytesPerRow, Pixel8bit *pixelsDst)
203 {
204 PRINT(" copyBits")
205
206 if (javaPixelsBytesPerRow == dstPixelsBytesPerRow)
207 {
208 memcpy(pixelsDst, pixelsSrc, h*javaPixelsBytesPerRow);
209 }
210 else
211 {
212 register jint y;
213 for (y=0; y<h; y++)
214 {
215 memcpy(pixelsDst, pixelsSrc, dstPixelsBytesPerRow);
216
217 pixelsSrc += javaPixelsBytesPerRow;
218 pixelsDst += dstPixelsBytesPerRow;
219 }
220 }
221 }
222
223 IMAGE_SURFACE_INLINE void copySwapRandB_32bit_TYPE_4BYTE(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)
224 {
225 PRINT(" copySwapRandB_32bit_TYPE_4BYTE")
226
227 register Pixel8bit *p8Bit = NULL;
228 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
229 register Pixel32bit pixel, red, blue;
230 register jint x, y;
231
232 for (y=0; y<h; y++)
233 {
234 for (x=0; x<w; x++)
235 {
236 pixel = *pixelsSrc++;
237
238 #ifdef __LITTLE_ENDIAN__
239 pixel = CFSwapInt32BigToHost(pixel); // the jint is in big endian format, we need to swap the bits
240 #endif
241
242 red = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position
243 blue = (pixel & 0x000000ff) << 16; // get original blue and shift to new position
244
245 pixel = (pixel & 0xff00ff00); // erase original red&blue
246
247 pixel = pixel | red | blue; // construct new pixel
248
249 *pixelsDst++ = pixel;
250 }
251 pixelsSrc += skip;
252
253 p8Bit = (Pixel8bit *) pixelsDst;
254 p8Bit += extraBytesPerRow;
255 pixelsDst = (Pixel32bit *) p8Bit;
256 }
257 }
258
259
260 IMAGE_SURFACE_INLINE void copySwapRandB_32bit_TYPE_INT(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)
261 {
262 PRINT(" copySwapRandB_32bit_TYPE_INT")
263
264 register Pixel8bit *p8Bit = NULL;
265 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
266 register Pixel32bit pixel, red, blue;
267 register jint x, y;
268
269 for (y=0; y<h; y++)
270 {
271 for (x=0; x<w; x++)
272 {
273 pixel = *pixelsSrc++;
274
275 red = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position
276 blue = (pixel & 0x000000ff) << 16; // get original blue and shift to new position
277
278 pixel = (pixel & 0xff00ff00); // erase original red&blue
279
280 pixel = pixel | red | blue; // construct new pixel
281
282 *pixelsDst++ = pixel;
283 }
284 pixelsSrc += skip;
285
286 p8Bit = (Pixel8bit *) pixelsDst;
287 p8Bit += extraBytesPerRow;
288 pixelsDst = (Pixel32bit *) p8Bit;
289 }
290 }
291
292
293 IMAGE_SURFACE_INLINE void copyBGR_24bitToXRGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)
294 {
295 PRINT(" copyBGR_24bitToXRGB_32bit")
296
297 register Pixel8bit *p8Bit = NULL;
298 register jint skip = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsSrc units
299 register Pixel32bit red, green, blue, pixel;
300 register jint x, y;
301
302 for (y=0; y<h; y++)
303 {
304 for (x=0; x<w; x++)
305 {
306 pixel = *pixelsSrc++;
307 blue = pixel << 0;
308
309 pixel = *pixelsSrc++;
310 green = pixel << 8;
311
312 pixel = *pixelsSrc++;
313 red = pixel << 16;
314
315 *pixelsDst = red | green | blue;
316
317 *pixelsDst = 0xff000000 | *pixelsDst;
318
319 pixelsDst++;
320 }
321 pixelsSrc += skip;
322
323 p8Bit = (Pixel8bit *) pixelsDst;
324 p8Bit += extraBytesPerRow;
325 pixelsDst = (Pixel32bit *) p8Bit;
326 }
327 }
328
329 IMAGE_SURFACE_INLINE void copyRGB_24bitToXRGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc, Pixel32bit *pixelsDst, size_t extraBytesPerRow)
330 {
331 PRINT(" copyRGB_24bitToXRGB_32bit")
332
333 register Pixel8bit *p8Bit = NULL;
334 register jint skip = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsSrc units
335 register Pixel32bit red, green, blue, pixel;
336 register jint x, y;
337
338 for (y=0; y<h; y++)
339 {
340 for (x=0; x<w; x++)
341 {
342 pixel = *pixelsSrc++;
343 red = pixel << 16;
344
345 pixel = *pixelsSrc++;
346 green = pixel << 8;
347
348 pixel = *pixelsSrc++;
349 blue = pixel << 0;
350
351 *pixelsDst = red | green | blue;
352
353 *pixelsDst = 0xff000000 | *pixelsDst;
354
355 pixelsDst++;
356 }
357 pixelsSrc += skip;
358
359 p8Bit = (Pixel8bit *) pixelsDst;
360 p8Bit += extraBytesPerRow;
361 pixelsDst = (Pixel32bit *) p8Bit;
362 }
363 }
364
365 IMAGE_SURFACE_INLINE void copyIndexed_8bitToARGB_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsSrc,
366 Pixel32bit* lutdata, Pixel32bit *pixelsDst, size_t extraBytesPerRow)
367 {
368 PRINT(" copyIndexed_8bitToARGB_32bit")
369
370 //gznote: how is the performance if the extraBytesPerRow != 0 ?
371 const vImage_Buffer src = {pixelsSrc, h, w, javaPixelsBytesPerRow};
372 const vImage_Buffer dest = {pixelsDst, h, w, w*sizeof(Pixel32bit)+extraBytesPerRow};
373 vImage_Error err = vImageLookupTable_Planar8toPlanarF(&src, &dest, (Pixel_F*)lutdata, kvImageDoNotTile);
374 if (err != kvImageNoError)
375 {
376 fprintf(stderr, "Error in copyIndexed_8bitToARGB_32bit: vImageLookupTable_Planar8toPlanarF returns %ld\n", (long)err);
377 register Pixel8bit *p8Bit = NULL;
378 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
379 register jint x, y;
380 for (y=0; y<h; y++)
381 {
382 for (x=0; x<w; x++)
383 {
384 *pixelsDst++ = lutdata[*pixelsSrc++]; // case 1
385 //*pixelsDst++ = *(lutdata + *pixelsSrc++); // case 2: at best ~1% better than case 1
386 }
387 pixelsSrc += skip;
388
389 p8Bit = (Pixel8bit *) pixelsDst;
390 p8Bit += extraBytesPerRow;
391 pixelsDst = (Pixel32bit *) p8Bit;
392 }
393 }
394 }
395
396 IMAGE_SURFACE_INLINE void copy565_16bitTo555_16bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel16bit *pixelsSrc, Pixel16bit *pixelsDst, size_t extraBytesPerRow)
397 {
398 PRINT(" copy565_16bitTo555_16bit")
399
400 register Pixel8bit *p8Bit = NULL;
401 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
402 register jint green;
403 register Pixel16bit pixel;
404 register jint x, y;
405 for (y=0; y<h; y++)
406 {
407 for (x=0; x<w; x++)
408 {
409 pixel = *pixelsSrc++;
410
411 green = ((pixel >> 5) & 63); // rrrrrggggggbbbbb => shift 5 right = 00000rrrrrgggggg => and 63 = 0000000000gggggg
412 green = ((jint) (((CGFloat) green / 63.0f) * 31.0f)) & 31; // first normalize to value between 0 and 1 and then un-normalize to 5 bit (31 = 0000000000011111)
413
414 *pixelsDst++ = ((pixel&0xf800)>>1) | (green << 5) | (pixel&0x01f);
415 }
416 pixelsSrc += skip;
417
418 p8Bit = (Pixel8bit *) pixelsDst;
419 p8Bit += extraBytesPerRow;
420 pixelsDst = (Pixel16bit *) p8Bit;
421 }
422 }
423
424
425 IMAGE_SURFACE_INLINE void customPixelsToJava(JNIEnv *env, ImageSDOps *isdo)
426 {
427 PRINT(" customPixelsToJava")
428
429 SurfaceDataOps *sdo = (SurfaceDataOps*)isdo;
430 JNFCallVoidMethod([ThreadUtilities getJNIEnv], sdo->sdObject, jm_syncToCustom); // AWT_THREADING Safe (known object)
431 }
432
433 IMAGE_SURFACE_INLINE void removeAlphaPre_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)
434 {
435 PRINT(" removeAlphaPre_32bit")
436
437 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
438 register Pixel32bit pixel, alpha, red, green, blue;
439 register jint x, y;
440
441 for (y=0; y<h; y++)
442 {
443 for (x=0; x<w; x++)
444 {
445 pixel = *pixelsSrc;
446
447 alpha = (pixel >> 24) & 0xff;
448
449 if (alpha != 0)
450 {
451 // get color components
452 red = (pixel >> 16) & 0xff;
453 green = (pixel >> 8) & 0xff;
454 blue = (pixel >> 0) & 0xff;
455
456 // remove alpha pre
457 red = ((red * 0xff) + 0x7f) / alpha;
458 green = ((green * 0xff) + 0x7f) / alpha;
459 blue = ((blue * 0xff) + 0x7f) / alpha;
460
461 // clamp
462 red = (red <= 0xff) ? red : 0xff;
463 green = (green <= 0xff) ? green : 0xff;
464 blue = (blue <= 0xff) ? blue : 0xff;
465
466 *pixelsSrc++ = (alpha<<24) | (red<<16) | (green<<8) | blue; // construct new pixel
467 }
468 else
469 {
470 *pixelsSrc++ = 0;
471 }
472 }
473
474 pixelsSrc += skip;
475 }
476 }
477
478 IMAGE_SURFACE_INLINE void swapRandBAndRemoveAlphaPre_32bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)
479 {
480 PRINT(" swapRandBAndRemoveAlphaPre_32bit")
481
482 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
483 register Pixel32bit pixel, alpha, red, green, blue;
484 register jint x, y;
485
486 for (y=0; y<h; y++)
487 {
488 for (x=0; x<w; x++)
489 {
490 pixel = *pixelsSrc;
491
492 alpha = (pixel & 0xff000000) >> 24;
493
494 if (alpha != 0)
495 {
496 // get color components
497 red = (pixel & 0x00ff0000) >> 16;
498 green = (pixel & 0x0000ff00) >> 8;
499 blue = (pixel & 0x000000ff) >> 0;
500
501 // remove alpha pre
502 red = ((red * 0xff) + 0x7f) / alpha;
503 green = ((green * 0xff) + 0x7f) / alpha;
504 blue = ((blue * 0xff) + 0x7f) / alpha;
505
506 // clamp
507 red = (red <= 0xff) ? red : 0xff;
508 green = (green <= 0xff) ? green : 0xff;
509 blue = (blue <= 0xff) ? blue : 0xff;
510
511 pixel = (alpha<<24) | (blue<<16) | (green<<8) | red; // construct new pixel
512
513 #ifdef __LITTLE_ENDIAN__
514 pixel = CFSwapInt32HostToBig(pixel); // the jint is little endian, we need to swap the bits before we send it back to Java
515 #endif
516
517 *pixelsSrc++ = pixel;
518 }
519 else
520 {
521 *pixelsSrc++ = 0;
522 }
523 }
524
525 pixelsSrc += skip;
526 }
527 }
528
529 IMAGE_SURFACE_INLINE void swapRandB_32bit_TYPE_INT(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)
530 {
531 PRINT(" swapRandB_32bit_TYPE_INT")
532
533 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
534 register Pixel32bit pixel, red, blue;
535 register jint x, y;
536
537 for (y=0; y<h; y++)
538 {
539 for (x=0; x<w; x++)
540 {
541 pixel = *pixelsSrc;
542
543 red = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position
544 blue = (pixel & 0x000000ff) << 16; // get original blue and shift to new position
545
546 pixel = (pixel & 0xff00ff00); // erase original red&blue
547
548 pixel = pixel | red | blue; // construct new pixel
549
550 *pixelsSrc++ = pixel;
551 }
552
553 pixelsSrc += skip;
554 }
555 }
556
557 IMAGE_SURFACE_INLINE void swapRandB_32bit_TYPE_4BYTE(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel32bit *pixelsSrc)
558 {
559 PRINT(" swapRandB_32bit_TYPE_4BYTE")
560
561 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
562 register Pixel32bit pixel, red, blue;
563 register jint x, y;
564
565 for (y=0; y<h; y++)
566 {
567 for (x=0; x<w; x++)
568 {
569 pixel = *pixelsSrc;
570
571 red = (pixel & 0x00ff0000) >> 16; // get original red and shift to new position
572 blue = (pixel & 0x000000ff) << 16; // get original blue and shift to new position
573
574 pixel = (pixel & 0xff00ff00); // erase original red&blue
575
576 pixel = pixel | red | blue; // construct new pixel
577
578 #ifdef __LITTLE_ENDIAN__
579 pixel = CFSwapInt32HostToBig(pixel); // the jint is little endian, we need to swap the bits before we send it back to Java
580 #endif
581
582 *pixelsSrc++ = pixel;
583 }
584
585 pixelsSrc += skip;
586 }
587 }
588
589 IMAGE_SURFACE_INLINE void map555_16bitTo565_16bit(jint w, jint h, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel16bit *pixelsSrc)
590 {
591 PRINT(" map555_16bitTo565_16bit")
592 register jint skip = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
593 register jint green;
594 register Pixel16bit pixel;
595 register jint x, y;
596 for (y=0; y<h; y++)
597 {
598 for (x=0; x<w; x++)
599 {
600 pixel = *pixelsSrc;
601
602 green = ((pixel >> 5) & 31); // rrrrrgggggbbbbb => shift 5 right = 000000rrrrrggggg => and 31 = 00000000000ggggg
603 green = ((jint) (((CGFloat) green / 31.0f) * 63.0f)) & 63; // first normalize between 0 and 1 and then un-normalize to 6 bit (63 = 0000000000111111)
604
605 *pixelsSrc++ = ((pixel&0x7c00)<<1) | (green << 5) | (pixel&0x01f);
606 }
607
608 pixelsSrc += skip;
609 }
610 }
611
612 IMAGE_SURFACE_INLINE void copyARGB_PRE_32bitToBGR_24bit(jint w, jint h, jint nativePixelsBytesPerRow, Pixel32bit *pixelsSrc, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsDst)
613 {
614 PRINT(" copyARGB_PRE_32bitToBGR_24bit")
615
616 static const jint mask = 0x000000ff;
617 register jint skipSrc = (nativePixelsBytesPerRow/sizeof(Pixel32bit))-w; // in pixelsSrc units
618 register jint skipDst = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsDst units
619 register Pixel32bit pixel, alpha, red, green, blue;
620 register jint x, y;
621
622 for (y=0; y<h; y++)
623 {
624 for (x=0; x<w; x++)
625 {
626 pixel = *pixelsSrc;
627
628 alpha = (pixel >> 24) & mask;
629
630 if (alpha != 0)
631 {
632 // extract color components
633 red = (pixel >> 16) & mask;
634 green = (pixel >> 8) & mask;
635 blue = (pixel >> 0) & mask;
636
637 // remove alpha pre
638 red = ((red * 0xff) + 0x7f) / alpha;
639 green = ((green * 0xff) + 0x7f) / alpha;
640 blue = ((blue * 0xff) + 0x7f) / alpha;
641
642 // clamp
643 *pixelsDst++ = (blue <= 0xff) ? blue : 0xff;
644 *pixelsDst++ = (green <= 0xff) ? green : 0xff;
645 *pixelsDst++ = (red <= 0xff) ? red : 0xff;
646 }
647 else
648 {
649 *pixelsDst++ = 0; // blue
650 *pixelsDst++ = 0; // green
651 *pixelsDst++ = 0; // red
652 }
653
654 pixelsSrc++;
655 }
656
657 pixelsSrc += skipSrc;
658 pixelsDst += skipDst;
659 }
660 }
661
662
663 IMAGE_SURFACE_INLINE void copyARGB_PRE_32bitToRGB_24bit(jint w, jint h, jint nativePixelsBytesPerRow, Pixel32bit *pixelsSrc, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsDst)
664 {
665 PRINT(" copyARGB_PRE_32bitToRGB_24bit")
666
667 static const jint mask = 0x000000ff;
668 register jint skipSrc = (nativePixelsBytesPerRow/sizeof(Pixel32bit))-w; // in pixelsSrc units
669 register jint skipDst = ((javaPixelsBytesPerRow/javaPixelBytes)-w)*javaPixelBytes; // in pixelsDst units
670 register Pixel32bit pixel, alpha, red, green, blue;
671 register jint x, y;
672
673 for (y=0; y<h; y++)
674 {
675 for (x=0; x<w; x++)
676 {
677 pixel = *pixelsSrc;
678
679 alpha = (pixel >> 24) & mask;
680
681 if (alpha != 0)
682 {
683 // extract color components
684 red = (pixel >> 16) & mask;
685 green = (pixel >> 8) & mask;
686 blue = (pixel >> 0) & mask;
687
688 // remove alpha pre
689 red = ((red * 0xff) + 0x7f) / alpha;
690 green = ((green * 0xff) + 0x7f) / alpha;
691 blue = ((blue * 0xff) + 0x7f) / alpha;
692
693 // clamp
694 *pixelsDst++ = (red <= 0xff) ? red : 0xff;
695 *pixelsDst++ = (green <= 0xff) ? green : 0xff;
696 *pixelsDst++ = (blue <= 0xff) ? blue : 0xff;
697 }
698 else
699 {
700 *pixelsDst++ = 0; // blue
701 *pixelsDst++ = 0; // green
702 *pixelsDst++ = 0; // red
703 }
704
705 pixelsSrc++;
706 }
707
708 pixelsSrc += skipSrc;
709 pixelsDst += skipDst;
710 }
711 }
712
713
714 // gray = 0.3red + 0.59green + 0.11blue - NTSC standard (according to Luke Wallis)
715 IMAGE_SURFACE_INLINE void copyARGB_PRE_32bitToGray_16bit(jint w, jint h, jint nativePixelsBytesPerRow, Pixel32bit *pixelsSrc, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel16bit *pixelsDst)
716 {
717 PRINT(" copyARGB_PRE_32bitToGray_16bit")
718
719 static const jint mask = 0x000000ff;
720 register jint skipSrc = (nativePixelsBytesPerRow/sizeof(Pixel32bit))-w; // in pixelsSrc units
721 register jint skipDst = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsDst units
722 register Pixel32bit alpha;
723 register Pixel32bit pixel, red, green, blue;
724 register CGFloat pixelFloat;
725 register jint x, y;
726
727 for (y=0; y<h; y++)
728 {
729 for (x=0; x<w; x++)
730 {
731 pixel = *pixelsSrc;
732
733 // gznote: do we remove alpha pre here?
734 alpha = ((pixel >> 24) & mask); //extract
735
736 if (alpha != 0)
737 {
738 red = ((pixel >> 16) & mask); // extract
739 green = ((pixel >> 8) & mask); // extract
740 blue = ((pixel >> 0) & mask); // extract
741
742 alpha *= 0xff; // upsample to 16bit
743 red *= 0xff; // upsample to 16bit
744 green *= 0xff; // upsample to 16bit
745 blue *= 0xff; // upsample to 16bit
746
747 red = ((red * 0xffff) + 0x7fff) / alpha; // remove alpha pre
748 red = (red <= 0xffff) ? red : 0xffff;
749 green = ((green * 0xffff) + 0x7fff) / alpha; // remove alpha pre
750 green = (green <= 0xffff) ? green : 0xffff;
751 blue = ((blue * 0xffff) + 0x7fff) / alpha; // remove alpha pre
752 blue = (blue <= 0xffff) ? blue : 0xffff;
753
754 pixelFloat = red*0.3f + green*0.59f + blue*0.11f; // rgb->gray NTSC conversion
755 }
756 else
757 {
758 pixelFloat = 0;
759 }
760
761 *pixelsDst = (jint)pixelFloat;
762 pixelsDst++;
763
764 pixelsSrc++;
765 }
766
767 pixelsSrc += skipSrc;
768 pixelsDst += skipDst;
769 }
770 }
771
772 // 1. first "dither" the true color down by creating a 16 bit value of the real color that will serve as an index into the cache of indexes
773 // 2. if the cache has a valid entry use it otherwise go through 3 and 4
774 // 3. go through the color table and calculate Euclidian distance between the true color and the indexed colors
775 // 4. map the shortest distance into the one and true index color and stick it into the dst (and cache)
776 IMAGE_SURFACE_INLINE UInt16* copyARGB_PRE_bitToIndexed_8bit(jint w, jint h, jint nativePixelsBytesPerRow, Pixel32bit *pixelsSrc, jint javaPixelsBytesPerRow, jint javaPixelBytes, Pixel8bit *pixelsDst, Pixel32bit* lutdata, UInt32 lutDataSize, UInt16 *indexedColorTable)
777 {
778 PRINT(" copyARGB_PRE_bitToIndexed_8bit")
779 static const UInt32 mask = 0x000000ff;
780
781 static const UInt32 indexSize = 65536; // 2^16 - 16 bits of precision
782 static const UInt32 indexMask = 0x000000f0; // 00000000000000000000000011110000
783 static const UInt16 invalidIndex = 0xffff; // 1111111111111111
784
785 register jint skipSrc = (nativePixelsBytesPerRow/sizeof(Pixel32bit))-w; // in pixelsSrc units
786 register jint skipDst = (javaPixelsBytesPerRow/javaPixelBytes)-w; // in pixelsSrc units
787 register jint indexOfBest, indexOfBestCached = -1;
788 register CGFloat distanceOfBest, distance;
789 register UInt32 p1, p1Cached = 0, p1a, p1r, p1g, p1b, p2;
790 register SInt32 da, dr, dg, db;
791 register jint x, y, i;
792 BOOL cachedValueReady = NO;
793
794 if (indexedColorTable == NULL)
795 {
796 indexedColorTable = (UInt16*)malloc(indexSize*sizeof(UInt16)); // 15 bit precision, each entry capable of holding a 2 byte value
797 // (lower byte for the actual index, higher byte to mark it valid/invalid)
798
799 if (indexedColorTable != NULL)
800 {
801 memset((void*)indexedColorTable, invalidIndex, indexSize*sizeof(UInt16));
802 }
803 else
804 {
805 fprintf(stderr, "ERROR: malloc returns NULL for isdo->indexedColorTable in copyARGB_PRE_bitToIndexed_8bit");
806 return NULL;
807 }
808 }
809
810 register UInt16 cacheIndex;
811
812 for (y=0; y<h; y++)
813 {
814 for (x=0; x<w; x++)
815 {
816 p1 = *pixelsSrc;
817
818 if ((p1Cached != p1) || (cachedValueReady == NO))
819 {
820 p1a = ((p1 >> 24) & mask);
821
822 if (p1a != 0)
823 {
824 // extract color components
825 p1r = ((p1 >> 16) & mask);
826 p1g = ((p1 >> 8) & mask);
827 p1b = ((p1 >> 0) & mask);
828
829 // remove alpha pre
830 p1r = ((p1r * 0xff) + 0x7f) / p1a;
831 p1g = ((p1g * 0xff) + 0x7f) / p1a;
832 p1b = ((p1b * 0xff) + 0x7f) / p1a;
833
834 // clamp
835 p1r = (p1r <= 0xff) ? p1r : 0xff;
836 p1g = (p1g <= 0xff) ? p1g : 0xff;
837 p1b = (p1b <= 0xff) ? p1b : 0xff;
838 }
839 else
840 {
841 p1r = 0;
842 p1g = 0;
843 p1b = 0;
844 }
845
846 cacheIndex = (UInt16)(((p1a & indexMask) << 8) | ((p1r & indexMask) << 4) | ((p1g & indexMask) << 0) | ((p1b & indexMask) >> 4));
847 if (indexedColorTable[cacheIndex] == invalidIndex)
848 {
849 indexOfBest = 0;
850 distanceOfBest = DBL_MAX;
851
852 for (i=0; (unsigned)i<lutDataSize; i++)
853 {
854 p2 = lutdata[i];
855
856 da = p1a - ((p2 >> 24) & mask);
857 dr = p1r - ((p2 >> 16) & mask);
858 dg = p1g - ((p2 >> 8) & mask);
859 db = p1b - ((p2 >> 0) & mask);
860
861 distance = sqrt((da*da)+(dr*dr)+(dg*dg)+(db*db));
862 if (distance < distanceOfBest)
863 {
864 distanceOfBest = distance;
865 indexOfBest = i;
866 }
867 }
868
869 indexedColorTable[cacheIndex] = indexOfBest;
870 }
871 else
872 {
873 indexOfBest = indexedColorTable[cacheIndex];
874 }
875
876 cachedValueReady = YES;
877 p1Cached = p1;
878 indexOfBestCached = indexOfBest;
879 }
880 else
881 {
882 indexOfBest = indexOfBestCached;
883 }
884
885 *pixelsDst = indexOfBest;
886
887 pixelsDst++;
888 pixelsSrc++;
889 }
890 pixelsSrc += skipSrc;
891 pixelsDst += skipDst;
892 }
893
894 return indexedColorTable;
895 }
896
897 // callback from CG telling us it's done with the data. <rdar://problem/4762033>
898 static void releaseDataFromProvider(void *info, const void *data, size_t size)
899 {
900 if (data != NULL)
901 {
902 free((void*)data);
903 }
904 }
905
906 IMAGE_SURFACE_INLINE void createContext(JNIEnv *env, ImageSDOps *isdo)
907 {
908 PRINT("createContext")
909
910 QuartzSDOps *qsdo = (QuartzSDOps*)isdo;
911 if (qsdo->cgRef == NULL) // lazy creation
912 {
913 size_t bitsPerComponent = isdo->contextInfo.bitsPerComponent;
914 CGColorSpaceRef colorSpace = isdo->contextInfo.colorSpace;
915 CGImageAlphaInfo alphaInfo = isdo->contextInfo.alphaInfo;
916
917 size_t bytesPerRow = isdo->contextInfo.bytesPerRow;
918 size_t size = bytesPerRow * isdo->height;
919 isdo->nativePixels = malloc(size);
920
921 if (isdo->nativePixels == NULL)
922 {
923 fprintf(stderr, "malloc failed for size %d bytes in ImageSurfaceData.createContext()\n", (int) size);
924 }
925
926 //fprintf(stderr, "isdo=%p isdo->type=%d, bitsPerComponent=%d, bytesPerRow=%d, colorSpace=%p, alphaInfo=%d, width=%d, height=%d, size=%d\n", isdo, type, (jint)bitsPerComponent, (jint)bytesPerRow, colorSpace, (jint)alphaInfo, (jint) isdo->width, (jint) isdo->height, (jint) size);
927
928 qsdo->cgRef = CGBitmapContextCreate(isdo->nativePixels, isdo->width, isdo->height, bitsPerComponent, bytesPerRow, colorSpace, alphaInfo);
929 isdo->dataProvider = CGDataProviderCreateWithData(NULL, isdo->nativePixels, size, releaseDataFromProvider);
930 }
931
932 //fprintf(stderr, "cgRef=%p\n", qsdo->cgRef);
933 if (qsdo->cgRef == NULL)
934 {
935 fprintf(stderr, "ERROR: (qsdo->cgRef == NULL) in createContext!\n");
936 }
937
938 // intitalize the context to match the Java coordinate system
939
940 // BG, since the context is created above, we can just concat
941 CGContextConcatCTM(qsdo->cgRef, CGAffineTransformMake(1, 0, 0, -1, 0, isdo->height));
942
943 CGContextSaveGState(qsdo->cgRef); // this will make sure we don't go pass device context settings
944 CGContextSaveGState(qsdo->cgRef); // this will put user settings on top, used by LazyStateManagement code
945 qsdo->newContext = YES;
946 }
947
948 IMAGE_SURFACE_INLINE void holdJavaPixels(JNIEnv* env, ImageSDOps* isdo)
949 {
950 PRINT("holdJavaPixels")
951
952 if (isdo->type != java_awt_image_BufferedImage_TYPE_CUSTOM)
953 {
954 Pixel8bit* pixels = NULL;
955 if (isdo->nrOfPixelsOwners == 0)
956 {
957 pixels = (Pixel8bit*)((*env)->GetPrimitiveArrayCritical(env, isdo->array, NULL));
958 if (pixels != NULL)
959 {
960 isdo->pixelsLocked = pixels;
961
962 isdo->pixels = isdo->pixelsLocked + isdo->offset;
963 }
964 else
965 {
966 fprintf(stderr, "ERROR: GetPrimitiveArrayCritical returns NULL for pixels in holdJavaPixels!\n");
967 }
968 }
969 isdo->nrOfPixelsOwners++;
970 }
971 else if (isdo->pixels == NULL)
972 {
973 isdo->pixels = (Pixel8bit*)((*env)->GetDirectBufferAddress(env, isdo->array));
974 }
975 }
976
977 IMAGE_SURFACE_INLINE void unholdJavaPixels(JNIEnv* env, ImageSDOps* isdo)
978 {
979 PRINT("unholdJavaPixels")
980
981 if (isdo->type != java_awt_image_BufferedImage_TYPE_CUSTOM)
982 {
983 isdo->nrOfPixelsOwners--;
984 if (isdo->nrOfPixelsOwners == 0)
985 {
986 isdo->pixels = NULL;
987
988 (*env)->ReleasePrimitiveArrayCritical(env, isdo->array, isdo->pixelsLocked, 0); // Do not use JNI_COMMIT, as that will not free the buffer copy when +ProtectJavaHeap is on.
989 isdo->pixelsLocked = NULL;
990 }
991 }
992 }
993
994 static void imageDataProvider_UnholdJavaPixels(void *info, const void *data, size_t size)
995 {
996 PRINT("imageDataProvider_UnholdJavaPixels")
997
998 ImageSDOps* isdo = (ImageSDOps*)info;
999 unholdJavaPixels([ThreadUtilities getJNIEnv], isdo);
1000 }
1001 static void imageDataProvider_FreeTempPixels(void *info, const void *data, size_t size)
1002 {
1003 PRINT("imageDataProvider_FreeTempPixels")
1004
1005 free((void *)data);
1006 }
1007 IMAGE_SURFACE_INLINE void syncFromJavaPixels(JNIEnv* env, ImageSDOps* isdo)
1008 {
1009 PRINT("syncFromJavaPixels")
1010
1011 // check to see if we have any work to do
1012 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] == 1)
1013 {
1014 // if we do, lock down Java pixels, this halts GarbageCollector!
1015 holdJavaPixels(env, isdo);
1016 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] == 1)
1017 {
1018 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 0;
1019
1020 void *dataProviderData = NULL;
1021 void *dataProviderInfo = NULL;
1022 void *dataProviderCallback = NULL;
1023 size_t dataProviderDataSize = 0;
1024 size_t width = isdo->width;
1025 size_t height = isdo->height;
1026 size_t bitsPerComponent = isdo->imageInfo.bitsPerComponent;
1027 size_t bitsPerPixel = isdo->imageInfo.bitsPerPixel;
1028 size_t bytesPerRow = 0;
1029 size_t extraBytesPerRow = 0; // these are the extra bytesPerRow used for alignement
1030
1031 switch (isdo->type)
1032 {
1033 //case java_awt_image_BufferedImage_TYPE_BYTE_BINARY: // mapped to TYPE_CUSTOM
1034 case java_awt_image_BufferedImage_TYPE_CUSTOM:
1035 holdJavaPixels(env, isdo); // we lock again since we are reusing pixels, but we must ensure CGImageRef immutability
1036 // we can lock these pixels down because they are nio based, so we don't halt the GarbageCollector
1037 bytesPerRow = isdo->javaPixelsBytesPerRow;
1038 dataProviderDataSize = bytesPerRow*isdo->height;
1039 dataProviderData = isdo->pixels;
1040 dataProviderInfo = isdo;
1041 dataProviderCallback = imageDataProvider_UnholdJavaPixels;
1042 break;
1043 default:
1044 bytesPerRow = isdo->imageInfo.bytesPerRow;
1045 dataProviderDataSize = bytesPerRow*height;
1046 dataProviderData = malloc(dataProviderDataSize);
1047 dataProviderInfo = isdo;
1048 dataProviderCallback = imageDataProvider_FreeTempPixels;
1049 }
1050
1051 switch (isdo->type)
1052 {
1053 //case java_awt_image_BufferedImage_TYPE_BYTE_BINARY: // mapped to TYPE_CUSTOM
1054 case java_awt_image_BufferedImage_TYPE_CUSTOM:
1055 customPixelsFromJava(env, isdo);
1056 break;
1057 case java_awt_image_BufferedImage_TYPE_INT_RGB:
1058 case java_awt_image_BufferedImage_TYPE_INT_ARGB:
1059 case java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE:
1060 case java_awt_image_BufferedImage_TYPE_USHORT_555_RGB:
1061 case java_awt_image_BufferedImage_TYPE_USHORT_GRAY:
1062 case java_awt_image_BufferedImage_TYPE_BYTE_GRAY:
1063 copyBits(width, height, isdo->javaPixelsBytesPerRow, (Pixel8bit*)isdo->pixels, bytesPerRow, dataProviderData);
1064 break;
1065 case java_awt_image_BufferedImage_TYPE_INT_BGR:
1066 copySwapRandB_32bit_TYPE_INT(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels, dataProviderData, extraBytesPerRow);
1067 break;
1068 case java_awt_image_BufferedImage_TYPE_4BYTE_ABGR:
1069 case java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE:
1070 copySwapRandB_32bit_TYPE_4BYTE(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels, dataProviderData, extraBytesPerRow);
1071 break;
1072 case java_awt_image_BufferedImage_TYPE_3BYTE_BGR:
1073 copyBGR_24bitToXRGB_32bit(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels, dataProviderData, extraBytesPerRow);
1074 break;
1075 case sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB:
1076 copyRGB_24bitToXRGB_32bit(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels, dataProviderData, extraBytesPerRow);
1077 break;
1078 case java_awt_image_BufferedImage_TYPE_USHORT_565_RGB:
1079 copy565_16bitTo555_16bit(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel16bit*)isdo->pixels, dataProviderData, extraBytesPerRow);
1080 break;
1081 case java_awt_image_BufferedImage_TYPE_BYTE_INDEXED:
1082 copyIndexed_8bitToARGB_32bit(width, height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels, isdo->lutData, dataProviderData, extraBytesPerRow);
1083 break;
1084 default:
1085 break;
1086 }
1087
1088 CGDataProviderRef provider = CGDataProviderCreateWithData(dataProviderInfo, dataProviderData, dataProviderDataSize, dataProviderCallback);
1089 CGImageRef javaImg = CGImageCreate(width, height, bitsPerComponent, bitsPerPixel, bytesPerRow,
1090 isdo->imageInfo.colorSpace, isdo->imageInfo.alphaInfo, provider, NULL, NO, kCGRenderingIntentDefault);
1091 //fprintf(stderr, "javaImg=%p\n", javaImg);
1092 CGDataProviderRelease(provider);
1093
1094 if (javaImg != NULL)
1095 {
1096 QuartzSDOps *qsdo = (QuartzSDOps*)isdo;
1097
1098 if (isdo->imgRef != NULL)
1099 {
1100 CGImageRelease(isdo->imgRef);
1101 isdo->imgRef = NULL;
1102 }
1103
1104 if (qsdo->cgRef == NULL)
1105 {
1106 createContext(env, isdo);
1107 }
1108
1109 if (qsdo->cgRef != NULL)
1110 {
1111 CGContextSaveGState(qsdo->cgRef);
1112 CGAffineTransform currCTM = CGContextGetCTM(qsdo->cgRef);
1113 CGAffineTransform inverse = CGAffineTransformInvert(currCTM);
1114 CGContextConcatCTM(qsdo->cgRef, inverse);
1115 CGContextConcatCTM(qsdo->cgRef, CGAffineTransformMake(1, 0, 0, 1, 0, 0));
1116 CGContextSetBlendMode(qsdo->cgRef, kCGBlendModeCopy);
1117 CGContextSetAlpha(qsdo->cgRef, 1.0f);
1118 CGContextDrawImage(qsdo->cgRef, CGRectMake(0, 0, width, height), javaImg);
1119 CGContextFlush(qsdo->cgRef);
1120 CGContextRestoreGState(qsdo->cgRef);
1121 CGImageRelease(javaImg);
1122 }
1123 else
1124 {
1125 fprintf(stderr, "ERROR: (cgRef == NULL) in syncFromJavaPixels!\n");
1126 }
1127 }
1128 else
1129 {
1130 //fprintf(stderr, "isdo->type=%d, isdo->width=%d, isdo->height=%d, isdo->imageInfo.bitsPerComponent=%d, isdo->imageInfo.bytesPerPixel=%d, isdo->imageInfo.bitsPerPixel=%d, isdo->imageInfo.bytesPerRow=%d, isdo->imageInfo.colorSpace=%p, isdo->imageInfo.alphaInfo=%d\n",
1131 //(jint)isdo->type, (jint)isdo->width, (jint)isdo->height, (jint)isdo->imageInfo.bitsPerComponent, (jint)isdo->imageInfo.bytesPerPixel, (jint)isdo->imageInfo.bitsPerPixel, (jint)isdo->imageInfo.bytesPerRow, isdo->imageInfo.colorSpace, (jint)isdo->imageInfo.alphaInfo);
1132 fprintf(stderr, "ERROR: (javaImg == NULL) in syncFromJavaPixels!\n");
1133 }
1134 }
1135
1136 unholdJavaPixels(env, isdo);
1137 }
1138 }
1139
1140 IMAGE_SURFACE_INLINE void processPixels(ImageSDOps* isdo, jint x, jint y, jint width, jint height, void (*processPixelsCallback) (ImageSDOps *, jint, Pixel32bit *, jint, jint, jint, jint))
1141 {
1142 processPixelsCallback(isdo, (jint) isdo->contextInfo.bytesPerRow, (Pixel32bit *) isdo->nativePixels, x, y, width, height);
1143 }
1144
1145 IMAGE_SURFACE_INLINE void syncToJavaPixels_processPixelsCallback(ImageSDOps* isdo, jint nativePixelsBytesPerRow, Pixel32bit *dataSrc, jint x, jint y, jint width, jint height)
1146 {
1147 switch (isdo->type)
1148 {
1149 case java_awt_image_BufferedImage_TYPE_3BYTE_BGR:
1150 copyARGB_PRE_32bitToBGR_24bit(isdo->width, isdo->height, nativePixelsBytesPerRow, dataSrc, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels);
1151 break;
1152 case sun_java2d_OSXOffScreenSurfaceData_TYPE_3BYTE_RGB:
1153 copyARGB_PRE_32bitToRGB_24bit(isdo->width, isdo->height, nativePixelsBytesPerRow, dataSrc, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels);
1154 break;
1155 case java_awt_image_BufferedImage_TYPE_USHORT_GRAY:
1156 copyARGB_PRE_32bitToGray_16bit(isdo->width, isdo->height, nativePixelsBytesPerRow, dataSrc, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel16bit*)isdo->pixels);
1157 break;
1158 case java_awt_image_BufferedImage_TYPE_BYTE_INDEXED:
1159 isdo->indexedColorTable = copyARGB_PRE_bitToIndexed_8bit(isdo->width, isdo->height, nativePixelsBytesPerRow, dataSrc, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, isdo->pixels, isdo->lutData, isdo->lutDataSize, isdo->indexedColorTable);
1160 break;
1161 default:
1162 break;
1163 }
1164 }
1165
1166
1167 IMAGE_SURFACE_INLINE void syncToJavaPixels(JNIEnv* env, ImageSDOps* isdo)
1168 {
1169 PRINT("syncToJavaPixels")
1170
1171 holdJavaPixels(env, isdo);
1172
1173 QuartzSDOps *qsdo = (QuartzSDOps*)isdo;
1174 if (qsdo->cgRef == NULL)
1175 {
1176 createContext(env, isdo);
1177 }
1178
1179 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNativePixelsChangedIndex] = 0;
1180
1181 if (isdo->contextInfo.canUseJavaPixelsAsContext == YES)
1182 {
1183
1184 jint srcBytesPerRow = isdo->contextInfo.bytesPerRow;
1185 jint dstBytesPerRow = isdo->javaPixelsBytesPerRow;
1186 jint h = isdo->height;
1187 Pixel8bit *pixelsSrc = isdo->nativePixels;
1188 Pixel8bit *pixelsDst = isdo->pixels;
1189
1190 if (srcBytesPerRow == dstBytesPerRow)
1191 {
1192 memcpy(pixelsDst, pixelsSrc, h * dstBytesPerRow);
1193 }
1194 else
1195 {
1196 jint widthInBytes = isdo->width * isdo->contextInfo.bytesPerPixel;
1197 jint y;
1198 for (y=0; y < h; y++)
1199 {
1200 memcpy(pixelsDst, pixelsSrc, widthInBytes);
1201
1202 pixelsSrc += srcBytesPerRow;
1203 pixelsDst += dstBytesPerRow;
1204 }
1205 }
1206
1207 switch (isdo->type)
1208 {
1209 //case java_awt_image_BufferedImage_TYPE_BYTE_BINARY: // mapped to TYPE_CUSTOM
1210 case java_awt_image_BufferedImage_TYPE_CUSTOM:
1211 customPixelsToJava(env, isdo);
1212 break;
1213 case java_awt_image_BufferedImage_TYPE_INT_ARGB:
1214 removeAlphaPre_32bit(isdo->width, isdo->height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels);
1215 break;
1216 case java_awt_image_BufferedImage_TYPE_4BYTE_ABGR:
1217 swapRandBAndRemoveAlphaPre_32bit(isdo->width, isdo->height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels);
1218 break;
1219 case java_awt_image_BufferedImage_TYPE_INT_BGR:
1220 swapRandB_32bit_TYPE_INT(isdo->width, isdo->height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels);
1221 break;
1222 case java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE:
1223 swapRandB_32bit_TYPE_4BYTE(isdo->width, isdo->height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel32bit*)isdo->pixels);
1224 break;
1225 case java_awt_image_BufferedImage_TYPE_USHORT_565_RGB:
1226 map555_16bitTo565_16bit(isdo->width, isdo->height, isdo->javaPixelsBytesPerRow, isdo->javaPixelBytes, (Pixel16bit*)isdo->pixels);
1227 break;
1228 default:
1229 break;
1230 }
1231 }
1232 else
1233 {
1234 processPixels(isdo, 0, 0, isdo->width, isdo->height, &syncToJavaPixels_processPixelsCallback);
1235 }
1236
1237 unholdJavaPixels(env, isdo);
1238 }
1239
1240
1241 IMAGE_SURFACE_INLINE jboolean xorSurfacePixels(JNIEnv *env, jobject dstIsd, jobject srcIsd, jint colorXOR, jint x, jint y, jint w, jint h)
1242 {
1243 PRINT("xorSurfacePixels")
1244
1245 jboolean handled = JNI_FALSE;
1246
1247 JNF_COCOA_ENTER(env);
1248 ImageSDOps* srcIsdo = LockImagePixels(env, srcIsd);
1249 ImageSDOps* dstIsdo = LockImagePixels(env, dstIsd);
1250
1251 if ((x < 0) || (y < 0) || (x+w > dstIsdo->width) || (y+h > dstIsdo->height) || (w > srcIsdo->width) || (h > srcIsdo->height))
1252 {
1253 #ifdef PRINT_WARNINGS
1254 fprintf(stderr, "xorSurfacePixels INVALID parameters: x=%d, y=%d, w=%d, h=%d\n", x, y, w, h);
1255 fprintf(stderr, " dstIsdo->width=%d, dstIsdo->height=%d, biqsdoPixels->width=%d, biqsdoPixels->height=%d\n",
1256 dstIsdo->width, dstIsdo->height, srcIsdo->width, srcIsdo->height);
1257 #endif
1258 UnlockImagePixels(env, srcIsdo);
1259 UnlockImagePixels(env, dstIsdo);
1260
1261 return JNI_FALSE;
1262 }
1263
1264 jint offset = (dstIsdo->width*y)+x;
1265 register Pixel32bit* dstPixels = (Pixel32bit*)dstIsdo->pixels;
1266 register jint skip = dstIsdo->width - w;
1267 register Pixel32bit* srcPixels = (Pixel32bit*)srcIsdo->pixels;
1268 register jint skipPixels = srcIsdo->width - w;
1269 register jint i, j;
1270
1271 dstPixels += offset;
1272
1273 switch (dstIsdo->type)
1274 {
1275 case java_awt_image_BufferedImage_TYPE_INT_RGB:
1276 case java_awt_image_BufferedImage_TYPE_INT_ARGB:
1277 case java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE:
1278 {
1279 dstIsdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1280
1281 if (dstIsdo->type == java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE)
1282 {
1283 Pixel8bit alpha = (colorXOR>>24)&0xff;
1284 Pixel8bit red = (colorXOR>>16)&0xff;
1285 red = (jint)(((CGFloat)red/255.0f * (CGFloat)alpha/255.0f)*255.0f);
1286 Pixel8bit green = (colorXOR>>8)&0xff;
1287 green = (jint)(((CGFloat)green/255.0f * (CGFloat)alpha/255.0f)*255.0f);
1288 Pixel8bit blue = (colorXOR>>0)&0xff;
1289 blue = (jint)(((CGFloat)blue/255.0f * (CGFloat)alpha/255.0f)*255.0f);
1290 colorXOR = (alpha<<24) | (red<<16) | (green<<8) | blue; // the color is now alpha premultiplied
1291 }
1292
1293 for (i=0; i<h; i++)
1294 {
1295 for (j=0; j<w; j++)
1296 {
1297 Pixel32bit srcPixel = *srcPixels;
1298 Pixel8bit pixelAlpha = (srcPixel>>24);
1299 if (pixelAlpha > XOR_ALPHA_CUTOFF)
1300 {
1301 *dstPixels = (*dstPixels ^ (srcPixel ^ colorXOR));
1302 }
1303 dstPixels++; srcPixels++;
1304 }
1305
1306 dstPixels += skip;
1307 srcPixels += skipPixels;
1308 }
1309
1310 handled = JNI_TRUE;
1311 break;
1312 }
1313 default:
1314 {
1315 handled = JNI_FALSE;
1316 #if defined(PRINT_WARNINGS)
1317 fprintf(stderr, "WARNING: unknown type (%d) in compositeXOR\n", dstIsdo->type);
1318 PrintImageInfo(dstIsdo);
1319 #endif
1320 }
1321 }
1322
1323 UnlockImagePixels(env, srcIsdo);
1324 UnlockImagePixels(env, dstIsdo);
1325
1326 JNF_COCOA_EXIT(env);
1327 return handled;
1328 }
1329
1330 IMAGE_SURFACE_INLINE jboolean clearSurfacePixels(JNIEnv *env, jobject bisd, jint w, jint h)
1331 {
1332 PRINT("clearSurfacePixels")
1333 jboolean handled = JNI_FALSE;
1334
1335 JNF_COCOA_ENTER(env);
1336
1337 ImageSDOps *isdo = LockImagePixels(env, bisd);
1338
1339 if (isdo->type == java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE)
1340 {
1341 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1342
1343 w = (w < isdo->width) ? w : isdo->width;
1344 h = (h < isdo->height) ? h : isdo->height;
1345
1346 register Pixel32bit* data = (Pixel32bit*)isdo->pixels;
1347 register jint i;
1348 if ((w < isdo->width) || (h < isdo->height)) //cmcnote: necessary to special-case for small height? wouldn't 4*w*h do it?
1349 {
1350 register jint skip = isdo->width;
1351 register jint row = 4*w;
1352 for (i=0; i<h; i++)
1353 {
1354 bzero(data, row);
1355 data += skip;
1356 }
1357 }
1358 else
1359 {
1360 bzero(data, 4*w*h);
1361 }
1362
1363 handled = JNI_TRUE;
1364 }
1365 UnlockImagePixels(env, isdo);
1366
1367 JNF_COCOA_EXIT(env);
1368
1369 return handled;
1370 }
1371
1372 static void ImageSD_startCGContext(JNIEnv *env, QuartzSDOps *qsdo, SDRenderType renderType)
1373 {
1374 PRINT("ImageSD_startCGContext")
1375
1376 ImageSDOps *isdo = (ImageSDOps*)qsdo;
1377
1378 pthread_mutex_lock(&isdo->lock);
1379
1380 if (isdo->imgRef != NULL)
1381 {
1382 CGImageRelease(isdo->imgRef);
1383 isdo->imgRef = NULL;
1384 }
1385
1386 if (qsdo->cgRef == NULL)
1387 {
1388 createContext(env, isdo);
1389 }
1390 else
1391 {
1392 qsdo->newContext = NO;
1393 }
1394
1395 if (qsdo->cgRef != NULL)
1396 {
1397 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kImageStolenIndex] == 1)
1398 {
1399 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1400 }
1401
1402 // sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex can be set right above or somewhere else
1403 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] == 1)
1404 {
1405 syncFromJavaPixels(env, isdo);
1406 }
1407
1408 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNativePixelsChangedIndex] = 1;
1409
1410 SetUpCGContext(env, qsdo, renderType);
1411 }
1412 }
1413 static void ImageSD_finishCGContext(JNIEnv *env, QuartzSDOps *qsdo)
1414 {
1415 PRINT("ImageSD_finishCGContext")
1416
1417 ImageSDOps *isdo = (ImageSDOps*)qsdo;
1418
1419 if (qsdo->cgRef != NULL)
1420 {
1421 CompleteCGContext(env, qsdo);
1422
1423 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kImageStolenIndex] == 1)
1424 {
1425 syncToJavaPixels(env, isdo);
1426 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1427 }
1428 }
1429
1430 pthread_mutex_unlock(&isdo->lock);
1431 }
1432
1433 static void ImageSD_dispose(JNIEnv *env, SurfaceDataOps *ops)
1434 {
1435 PRINT("ImageSD_dispose")
1436
1437 // copied from BufImg_Dispose in BufImgSurfaceData.c
1438 {
1439 /* ops is assumed non-null as it is checked in SurfaceData_DisposeOps */
1440 BufImgSDOps *bisdo = (BufImgSDOps *)ops;
1441 (*env)->DeleteWeakGlobalRef(env, bisdo->array);
1442 if (bisdo->lutarray != NULL) {
1443 (*env)->DeleteWeakGlobalRef(env, bisdo->lutarray);
1444 }
1445 if (bisdo->icm != NULL) {
1446 (*env)->DeleteWeakGlobalRef(env, bisdo->icm);
1447 }
1448 }
1449
1450 QuartzSDOps *qsdo = (QuartzSDOps *)ops;
1451
1452 if (qsdo->graphicsStateInfo.batchedLines != NULL)
1453 {
1454 free(qsdo->graphicsStateInfo.batchedLines);
1455 qsdo->graphicsStateInfo.batchedLines = NULL;
1456 }
1457
1458 JNFDeleteGlobalRef(env, qsdo->javaGraphicsStatesObjects);
1459
1460 if (qsdo->cgRef != NULL)
1461 {
1462 CGContextRelease(qsdo->cgRef);
1463 qsdo->cgRef = NULL;
1464 }
1465
1466 ImageSDOps *isdo = (ImageSDOps *)ops;
1467
1468 if (isdo->dataProvider != NULL)
1469 {
1470 CGDataProviderRelease(isdo->dataProvider);
1471 isdo->dataProvider = NULL;
1472 }
1473 if (isdo->imgRef != NULL)
1474 {
1475 CGImageRelease(isdo->imgRef);
1476 isdo->imgRef = NULL;
1477 }
1478 if (isdo->indexedColorTable != NULL)
1479 {
1480 free(isdo->indexedColorTable);
1481 isdo->indexedColorTable = NULL;
1482 }
1483 if (isdo->lutData != NULL)
1484 {
1485 free(isdo->lutData);
1486 isdo->indexedColorTable = NULL;
1487 }
1488 if (isdo->array != NULL)
1489 {
1490 JNFDeleteGlobalRef(env, isdo->array);
1491 isdo->array = NULL;
1492 }
1493 if (isdo->icm != NULL)
1494 {
1495 JNFDeleteGlobalRef(env, isdo->icm);
1496 isdo->icm = NULL;
1497 }
1498
1499 if (isdo->nsRef) {
1500 [isdo->nsRef release];
1501 isdo->nsRef = nil;
1502 }
1503
1504 pthread_mutex_destroy(&isdo->lock);
1505 }
1506
1507 // used by XOR (Java pixels must be up to date)
1508 ImageSDOps* LockImagePixels(JNIEnv* env, jobject imageSurfaceData)
1509 {
1510 PRINT("LockImagePixels")
1511
1512 ImageSDOps* isdo = (ImageSDOps*)SurfaceData_GetOps(env, imageSurfaceData);
1513
1514 pthread_mutex_lock(&isdo->lock);
1515
1516 holdJavaPixels(env, isdo);
1517
1518 // if we need to access this image's pixels we need to convert native pixels (if any) back to Java
1519 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNativePixelsChangedIndex] == 1)
1520 {
1521 syncToJavaPixels(env, isdo);
1522 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1523 }
1524
1525 return isdo;
1526 }
1527 void UnlockImagePixels(JNIEnv* env, ImageSDOps* isdo)
1528 {
1529 PRINT("UnlockImagePixels")
1530 // don't do that since the native pixels haven't changed (Java pixels == native pixels)
1531 //syncToJavaPixels(env, isdo);
1532
1533 unholdJavaPixels(env, isdo);
1534
1535 pthread_mutex_unlock(&isdo->lock);
1536 }
1537
1538 // used by drawImage (native pixels must be up to date)
1539 ImageSDOps* LockImage(JNIEnv* env, jobject imageSurfaceData)
1540 {
1541 PRINT("LockImage")
1542
1543 ImageSDOps* isdo = (ImageSDOps*)SurfaceData_GetOps(env, imageSurfaceData);
1544
1545 pthread_mutex_lock(&isdo->lock);
1546
1547 // if we need to access this image's pixels we need to convert native pixels (if any) back to Java
1548 // for those images whose context type doesn't match layer type or is a custom image
1549 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kImageStolenIndex] == 1)
1550 {
1551 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1552 }
1553
1554 // sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex can be set right above or somewhere else
1555 if (isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] == 1)
1556 {
1557 syncFromJavaPixels(env, isdo);
1558 }
1559
1560 return isdo;
1561 }
1562 void UnlockImage(JNIEnv* env, ImageSDOps* isdo)
1563 {
1564 PRINT("UnlockImage")
1565
1566 // don't do that since the native pixels haven't changed (Java pixels == native pixels)
1567 //syncToJavaPixels(env, isdo);
1568
1569 pthread_mutex_unlock(&isdo->lock);
1570 }
1571
1572 JNIEXPORT jobject JNICALL Java_sun_awt_image_BufImgSurfaceData_getSurfaceData
1573 (JNIEnv *env, jclass bisd, jobject bufImg)
1574 {
1575 static jfieldID sDataID = 0;
1576 if (sDataID == 0)
1577 {
1578 static char *bimgName = "java/awt/image/BufferedImage";
1579 jclass bimg = (*env)->FindClass(env, bimgName);
1580 CHECK_NULL_RETURN(bimg, NULL);
1581 sDataID = (*env)->GetFieldID(env, bimg, "sData", "Lsun/java2d/SurfaceData;");
1582 CHECK_NULL_RETURN(sDataID, NULL);
1583 }
1584
1585 return (*env)->GetObjectField(env, bufImg, sDataID);
1586 }
1587
1588 JNIEXPORT void JNICALL Java_sun_awt_image_BufImgSurfaceData_setSurfaceData
1589 (JNIEnv *env, jclass bisd, jobject bufImg, jobject sData)
1590 {
1591 static jfieldID sDataID = 0;
1592 if (sDataID == 0)
1593 {
1594 static char *bimgName = "java/awt/image/BufferedImage";
1595 jclass bimg = (*env)->FindClass(env, bimgName);
1596 CHECK_NULL(bimg);
1597 sDataID = (*env)->GetFieldID(env, bimg, "sData", "Lsun/java2d/SurfaceData;");
1598 CHECK_NULL(sDataID);
1599 }
1600
1601 (*env)->SetObjectField(env, bufImg, sDataID, sData);
1602 }
1603
1604 JNIEXPORT void JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_initIDs(JNIEnv *env, jclass bisd)
1605 {
1606 //PRINT("initIDs")
1607 // copied from Java_sun_awt_image_BufImgSurfaceData_initIDs in BufImgSurfaceData.c
1608 {
1609 static char *icmName = "java/awt/image/IndexColorModel";
1610 jclass icm;
1611
1612 if (sizeof(BufImgRIPrivate) > SD_RASINFO_PRIVATE_SIZE) {
1613 JNU_ThrowInternalError(env, "Private RasInfo structure too large!");
1614 return;
1615 }
1616
1617 CHECK_NULL(icm = (*env)->FindClass(env, icmName));
1618 CHECK_NULL(rgbID = (*env)->GetFieldID(env, icm, "rgb", "[I"));
1619 CHECK_NULL(allGrayID = (*env)->GetFieldID(env, icm, "allgrayopaque", "Z"));
1620 CHECK_NULL(mapSizeID = (*env)->GetFieldID(env, icm, "map_size", "I"));
1621 CHECK_NULL(CMpDataID = (*env)->GetFieldID(env, icm, "pData", "J"));
1622 }
1623
1624 gColorspaceRGB = CGColorSpaceCreateWithName(kCGColorSpaceGenericRGB);
1625 gColorspaceGray = CGColorSpaceCreateWithName(kCGColorSpaceGenericGray);
1626 //fprintf(stderr, "gColorspaceRGB=%p, gColorspaceGray=%p\n", gColorspaceRGB, gColorspaceGray);
1627 }
1628
1629 JNIEXPORT jobject JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_getSurfaceData
1630 (JNIEnv *env, jclass bisd, jobject bufImg)
1631 {
1632 PRINT("getSurfaceData")
1633
1634 return JNFGetObjectField(env, bufImg, jm_SurfaceData);
1635 }
1636
1637 JNIEXPORT void JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_setSurfaceData
1638 (JNIEnv *env, jclass bisd, jobject bufImg, jobject sData)
1639 {
1640 PRINT("setSurfaceData")
1641
1642 JNFSetObjectField(env, bufImg, jm_SurfaceData, sData);
1643 }
1644
1645 static jint ImageSD_Lock(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo, jint lockflags)
1646 {
1647 ImageSDOps *isdo = (ImageSDOps*)ops;
1648 pthread_mutex_lock(&isdo->lock);
1649
1650 // copied from BufImg_Lock in BufImgSurfaceData.c
1651 {
1652 BufImgSDOps *bisdo = (BufImgSDOps *)ops;
1653 BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);
1654
1655 if ((lockflags & (SD_LOCK_LUT)) != 0 && !bisdo->lutarray) {
1656 /* REMIND: Should this be an InvalidPipe exception? */
1657 JNU_ThrowNullPointerException(env, "Attempt to lock missing colormap");
1658 return SD_FAILURE;
1659 }
1660 // TODO:BG
1661 /*
1662 if ((lockflags & SD_LOCK_INVCOLOR) != 0 ||
1663 (lockflags & SD_LOCK_INVGRAY) != 0)
1664 {
1665 bipriv->cData = BufImg_SetupICM(env, bisdo);
1666 if (bipriv->cData == NULL) {
1667 JNU_ThrowNullPointerException(env, "Could not initialize "
1668 "inverse tables");
1669 return SD_FAILURE;
1670 }
1671 } else {
1672 bipriv->cData = NULL;
1673 }
1674 */
1675 bipriv->cData = NULL;
1676
1677 bipriv->lockFlags = lockflags;
1678 bipriv->base = NULL;
1679 bipriv->lutbase = NULL;
1680
1681 SurfaceData_IntersectBounds(&pRasInfo->bounds, &bisdo->rasbounds);
1682
1683 /* TODO:BG
1684 if ((bipriv->lockFlags & SD_LOCK_WRITE) &&
1685 bisdo->sdOps.dirty != TRUE) {
1686 SurfaceData_MarkDirty(env, &bisdo->sdOps);
1687 } */
1688 return SD_SUCCESS;
1689 }
1690 }
1691 static void ImageSD_Unlock(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo)
1692 {
1693 ImageSDOps *isdo = (ImageSDOps*)ops;
1694
1695 // For every ImageSD_Unlock, we need to be conservative and mark the pixels
1696 // as modified by the Sun2D renderer.
1697 isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kNeedToSyncFromJavaPixelsIndex] = 1;
1698
1699 pthread_mutex_unlock(&isdo->lock);
1700 }
1701 static void ImageSD_GetRasInfo(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo)
1702 {
1703 // copied from BufImg_GetRasInfo in BufImgSurfaceData.c
1704 {
1705 BufImgSDOps *bisdo = (BufImgSDOps *)ops;
1706 BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);
1707
1708 if ((bipriv->lockFlags & (SD_LOCK_RD_WR)) != 0) {
1709 bipriv->base =
1710 (*env)->GetPrimitiveArrayCritical(env, bisdo->array, NULL);
1711 }
1712 if ((bipriv->lockFlags & (SD_LOCK_LUT)) != 0) {
1713 bipriv->lutbase =
1714 (*env)->GetPrimitiveArrayCritical(env, bisdo->lutarray, NULL);
1715 }
1716
1717 if (bipriv->base == NULL) {
1718 pRasInfo->rasBase = NULL;
1719 pRasInfo->pixelStride = 0;
1720 pRasInfo->scanStride = 0;
1721 } else {
1722 pRasInfo->rasBase = (void *)
1723 (((uintptr_t) bipriv->base) + bisdo->offset);
1724 pRasInfo->pixelStride = bisdo->pixStr;
1725 pRasInfo->scanStride = bisdo->scanStr;
1726 }
1727 if (bipriv->lutbase == NULL) {
1728 pRasInfo->lutBase = NULL;
1729 pRasInfo->lutSize = 0;
1730 } else {
1731 pRasInfo->lutBase = bipriv->lutbase;
1732 pRasInfo->lutSize = bisdo->lutsize;
1733 }
1734 if (bipriv->cData == NULL) {
1735 pRasInfo->invColorTable = NULL;
1736 pRasInfo->redErrTable = NULL;
1737 pRasInfo->grnErrTable = NULL;
1738 pRasInfo->bluErrTable = NULL;
1739 } else {
1740 pRasInfo->invColorTable = bipriv->cData->img_clr_tbl;
1741 pRasInfo->redErrTable = bipriv->cData->img_oda_red;
1742 pRasInfo->grnErrTable = bipriv->cData->img_oda_green;
1743 pRasInfo->bluErrTable = bipriv->cData->img_oda_blue;
1744 pRasInfo->invGrayTable = bipriv->cData->pGrayInverseLutData;
1745 }
1746 }
1747 }
1748 static void ImageSD_Release(JNIEnv *env, SurfaceDataOps *ops, SurfaceDataRasInfo *pRasInfo)
1749 {
1750 // copied from BufImg_Release in BufImgSurfaceData.c
1751 {
1752 BufImgSDOps *bisdo = (BufImgSDOps *)ops;
1753 BufImgRIPrivate *bipriv = (BufImgRIPrivate *) &(pRasInfo->priv);
1754
1755 if (bipriv->base != NULL) {
1756 jint mode = (((bipriv->lockFlags & (SD_LOCK_WRITE)) != 0)
1757 ? 0 : JNI_ABORT);
1758 (*env)->ReleasePrimitiveArrayCritical(env, bisdo->array,
1759 bipriv->base, mode);
1760 }
1761 if (bipriv->lutbase != NULL) {
1762 (*env)->ReleasePrimitiveArrayCritical(env, bisdo->lutarray,
1763 bipriv->lutbase, JNI_ABORT);
1764 }
1765 }
1766 }
1767
1768 JNIEXPORT void JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_initRaster(JNIEnv *env, jobject bisd, jobject array, jint offset, jint width, jint height,
1769 jint pixelStride, jint scanStride, jobject icm, jint type,
1770 jobject jGraphicsState, jobjectArray jGraphicsStateObject, jobject jImageInfo)
1771 {
1772 PRINT("Java_sun_java2d_OSXOffScreenSurfaceData_initRaster")
1773
1774 ImageSDOps* isdo = (ImageSDOps*)SurfaceData_InitOps(env, bisd, sizeof(ImageSDOps));
1775
1776 pthread_mutexattr_t attr;
1777 pthread_mutexattr_init(&attr);
1778 pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
1779 pthread_mutex_init(&isdo->lock, &attr);
1780 pthread_mutex_lock(&isdo->lock);
1781 pthread_mutexattr_destroy(&attr);
1782
1783 // copied (and modified) from Java_sun_awt_image_BufImgSurfaceData_initRaster in BufImgSurfaceData.c
1784 {
1785 BufImgSDOps *bisdo =
1786 //(BufImgSDOps*)SurfaceData_InitOps(env, bisd, sizeof(BufImgSDOps));
1787 (BufImgSDOps*)isdo;
1788 //bisdo->sdOps.Lock = BufImg_Lock;
1789 //bisdo->sdOps.GetRasInfo = BufImg_GetRasInfo;
1790 //bisdo->sdOps.Release = BufImg_Release;
1791 //bisdo->sdOps.Unlock = NULL;
1792 //bisdo->sdOps.Dispose = BufImg_Dispose;
1793
1794 bisdo->array = (*env)->NewWeakGlobalRef(env, array);
1795 if (array != NULL) CHECK_NULL(bisdo->array);
1796 bisdo->offset = offset;
1797 //bisdo->scanStr = scanStr;
1798 bisdo->scanStr = scanStride;
1799 //bisdo->pixStr = pixStr;
1800 bisdo->pixStr = pixelStride;
1801 if (!icm) {
1802 bisdo->lutarray = NULL;
1803 bisdo->lutsize = 0;
1804 bisdo->icm = NULL;
1805 } else {
1806 jobject lutarray = (*env)->GetObjectField(env, icm, rgbID);
1807 bisdo->lutarray = (*env)->NewWeakGlobalRef(env, lutarray);
1808 if (lutarray != NULL) CHECK_NULL(bisdo->lutarray);
1809 bisdo->lutsize = (*env)->GetIntField(env, icm, mapSizeID);
1810 bisdo->icm = (*env)->NewWeakGlobalRef(env, icm);
1811 if (icm != NULL) CHECK_NULL(bisdo->icm);
1812 }
1813 bisdo->rasbounds.x1 = 0;
1814 bisdo->rasbounds.y1 = 0;
1815 bisdo->rasbounds.x2 = width;
1816 bisdo->rasbounds.y2 = height;
1817 }
1818
1819 isdo->nrOfPixelsOwners = 0;
1820
1821 isdo->contextInfo = sDefaultContextInfo[type];
1822 isdo->imageInfo = sDefaultImageInfo[type];
1823
1824 isdo->contextInfo.bytesPerRow = width*isdo->contextInfo.bytesPerPixel;
1825 isdo->imageInfo.bytesPerRow = width*isdo->imageInfo.bytesPerPixel;
1826
1827 switch (type)
1828 {
1829 case java_awt_image_BufferedImage_TYPE_BYTE_GRAY:
1830 isdo->contextInfo.colorSpace = isdo->imageInfo.colorSpace = gColorspaceGray;
1831 break;
1832 case java_awt_image_BufferedImage_TYPE_USHORT_GRAY:
1833 isdo->contextInfo.colorSpace = gColorspaceRGB;
1834 isdo->imageInfo.colorSpace = gColorspaceGray;
1835 break;
1836 default:
1837 isdo->contextInfo.colorSpace = isdo->imageInfo.colorSpace = gColorspaceRGB;
1838 break;
1839 }
1840 isdo->isSubImage = (offset%scanStride != 0) || (scanStride != (pixelStride*width));
1841
1842 // parameters specifying this image given to us from Java
1843 isdo->javaImageInfo = (jint*)((*env)->GetDirectBufferAddress(env, jImageInfo));
1844 isdo->array = (array != NULL) ? JNFNewGlobalRef(env, array) : NULL;
1845 isdo->offset = offset;
1846 isdo->width = width;
1847 isdo->height = height;
1848 isdo->javaPixelBytes = pixelStride;
1849 isdo->javaPixelsBytesPerRow = scanStride;
1850 isdo->icm = (icm != NULL) ? JNFNewGlobalRef(env, icm) : NULL;
1851 isdo->type = type;
1852
1853 if ((isdo->javaImageInfo[sun_java2d_OSXOffScreenSurfaceData_kImageStolenIndex] == 1) ||
1854 (isdo->type == java_awt_image_BufferedImage_TYPE_CUSTOM))
1855 {
1856 // don't waste (precious, precious) VRAM on stolen or custom images that will be slow no matter what
1857 isdo->contextInfo.useWindowContextReference = NO;
1858 }
1859
1860 // needed by TYPE_BYTE_INDEXED
1861 isdo->indexedColorTable = NULL;
1862 isdo->lutData = NULL;
1863 isdo->lutDataSize = 0;
1864 if ((type == java_awt_image_BufferedImage_TYPE_BYTE_INDEXED) && ((*env)->IsSameObject(env, icm, NULL) == NO))
1865 {
1866 jarray lutarray = JNFGetObjectField(env, icm, jm_rgb);
1867 isdo->lutDataSize = (*env)->GetArrayLength(env, lutarray);
1868 if (isdo->lutDataSize > 0)
1869 {
1870 jint transparency = JNFGetIntField(env, icm, jm_transparency);
1871 jint transparent_index = -1;
1872 if (transparency == java_awt_Transparency_BITMASK)
1873 {
1874 transparent_index = JNFGetIntField(env, icm, jm_transparent_index);
1875 }
1876
1877 Pixel32bit* lutdata = (Pixel32bit*)((*env)->GetPrimitiveArrayCritical(env, lutarray, NULL));
1878 if (lutdata != NULL)
1879 {
1880 isdo->lutData = NULL;
1881
1882 isdo->lutData = malloc(isdo->lutDataSize * sizeof(Pixel32bit));
1883 if (isdo->lutData != NULL)
1884 {
1885 if (transparency == java_awt_Transparency_BITMASK)
1886 {
1887 Pixel32bit* src = lutdata;
1888 Pixel32bit* dst = isdo->lutData;
1889 jint i;
1890 for (i=0; (unsigned)i<isdo->lutDataSize; i++)
1891 {
1892 if (i != transparent_index)
1893 {
1894 *dst = *src;
1895 // rdar://problem/3390518 - don't force all indexed colors
1896 // to be fully opaque. They could be set up for us.
1897 // we used to call: *dst = 0xff000000 | *src;
1898 // but that was forcing colors to be opaque when developers
1899 // could have set the alpha.
1900 }
1901 else
1902 {
1903 *dst = 0x00000000; // mark as translucent color
1904 }
1905 dst++; src++;
1906 }
1907 }
1908 else //if ((transparency == java_awt_Transparency_OPAQUE) || (transparency == java_awt_Transparency_TRANSLUCENT))
1909 {
1910 jint mask = 0x00000000;
1911 // <rdar://4224874> If the color model is OPAQUE than we need to create an opaque image for performance purposes.
1912 // the default alphaInfo for INDEXED images is kCGImageAlphaFirst. Therefore we need to special case this.
1913 if ((transparency == java_awt_Transparency_OPAQUE))
1914 {
1915 isdo->imageInfo.alphaInfo = kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host;
1916 mask = 0xff000000; // this is just a safeguard to make sure we fill the alpha
1917 }
1918
1919 Pixel32bit* src = lutdata;
1920 Pixel32bit* dst = isdo->lutData;
1921 jint i;
1922 for (i=0; (unsigned)i<isdo->lutDataSize; i++)
1923 {
1924 *dst = *src | mask;
1925 dst++; src++;
1926 }
1927 }
1928
1929 (*env)->ReleasePrimitiveArrayCritical(env, lutarray, lutdata, 0);
1930 }
1931 else
1932 {
1933 fprintf(stderr, "ERROR: malloc returns NULL for isdo->lutData in initRaster!\n");
1934 }
1935 }
1936 else
1937 {
1938 fprintf(stderr, "ERROR: GetPrimitiveArrayCritical returns NULL for lutdata in initRaster!\n");
1939 }
1940 }
1941 (*env)->DeleteLocalRef(env, lutarray);
1942 }
1943
1944 QuartzSDOps *qsdo = (QuartzSDOps*)isdo;
1945 qsdo->BeginSurface = ImageSD_startCGContext;
1946 qsdo->FinishSurface = ImageSD_finishCGContext;
1947
1948 qsdo->javaGraphicsStates = (jint*)((*env)->GetDirectBufferAddress(env, jGraphicsState));
1949 qsdo->javaGraphicsStatesObjects = JNFNewGlobalRef(env, jGraphicsStateObject);
1950
1951 qsdo->graphicsStateInfo.batchedLines = NULL;
1952 qsdo->graphicsStateInfo.batchedLinesCount = 0;
1953
1954 SurfaceDataOps *sdo = (SurfaceDataOps*)qsdo;
1955 sdo->Lock = ImageSD_Lock;
1956 sdo->Unlock = ImageSD_Unlock;
1957 sdo->GetRasInfo = ImageSD_GetRasInfo;
1958 sdo->Release = ImageSD_Release;
1959 sdo->Setup = NULL;
1960 sdo->Dispose = ImageSD_dispose;
1961
1962 pthread_mutex_unlock(&isdo->lock);
1963
1964 //PrintImageInfo(isdo);
1965 }
1966
1967 JNIEXPORT void JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_initCustomRaster(JNIEnv* env, jobject bisd, jobject array, jint width, jint height,
1968 jobject jGraphicsState, jobject jGraphicsStateObject, jobject jImageInfo)
1969 {
1970 PRINT("Java_sun_java2d_OSXOffScreenSurfaceData_initCustomRaster")
1971 jint offset = 0;
1972 jint pixelStride = 4;
1973 jint scanStride = pixelStride*width;
1974 jobject icm = NULL;
1975 jint type = java_awt_image_BufferedImage_TYPE_CUSTOM;
1976
1977 Java_sun_java2d_OSXOffScreenSurfaceData_initRaster(env, bisd, array, offset, width, height, pixelStride, scanStride, icm, type, jGraphicsState, jGraphicsStateObject, jImageInfo);
1978 }
1979
1980 JNIEXPORT void JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_syncToJavaPixels(JNIEnv *env, jobject bisd)
1981 {
1982 PRINT("Java_sun_java2d_OSXOffScreenSurfaceData_syncToJavaPixels")
1983
1984 syncToJavaPixels(env, (ImageSDOps*)SurfaceData_GetOps(env, bisd));
1985 }
1986
1987 JNIEXPORT jboolean JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_xorSurfacePixels
1988 (JNIEnv *env, jobject dstIsd, jobject srcIsd, jint colorXOR, jint x, jint y, jint w, jint h)
1989 {
1990 PRINT("Java_sun_java2d_OSXOffScreenSurfaceData_xorSurfacePixels")
1991 return xorSurfacePixels(env, dstIsd, srcIsd, colorXOR, x, y, w, h);
1992 }
1993
1994 JNIEXPORT jboolean JNICALL Java_sun_java2d_OSXOffScreenSurfaceData_clearSurfacePixels
1995 (JNIEnv *env, jobject bisd, jint w, jint h)
1996 {
1997 PRINT("Java_sun_java2d_OSXOffScreenSurfaceData_clearSurfacePixels")
1998 return clearSurfacePixels(env, bisd, w, h);
1999
2000 }