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