1 /*
2 * Copyright (c) 2011, 2014, 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 #import "jni_util.h"
26
27 #import <Cocoa/Cocoa.h>
28 #import <JavaNativeFoundation/JavaNativeFoundation.h>
29
30 #import "GeomUtilities.h"
31 #import "ThreadUtilities.h"
32
33 #import "sun_lwawt_macosx_CImage.h"
34
35
36 static void CImage_CopyArrayIntoNSImageRep
37 (jint *srcPixels, jint *dstPixels, int width, int height)
38 {
39 int x, y;
40 // TODO: test this on big endian systems (not sure if its correct)...
41 for (y = 0; y < height; y++) {
42 for (x = 0; x < width; x++) {
43 jint pix = srcPixels[x];
44 jint a = (pix >> 24) & 0xff;
45 jint r = (pix >> 16) & 0xff;
46 jint g = (pix >> 8) & 0xff;
47 jint b = (pix ) & 0xff;
48 dstPixels[x] = (b << 24) | (g << 16) | (r << 8) | a;
49 }
50 srcPixels += width; // TODO: use explicit scanStride
51 dstPixels += width;
52 }
53 }
54
55 static void CImage_CopyNSImageIntoArray
56 (NSImage *srcImage, jint *dstPixels, NSRect fromRect, NSRect toRect)
57 {
58 int width = toRect.size.width;
59 int height = toRect.size.height;
60 CGColorSpaceRef colorspace = CGColorSpaceCreateDeviceRGB();
61 CGContextRef cgRef = CGBitmapContextCreate(dstPixels, width, height,
62 8, width * 4, colorspace,
63 kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host);
64 CGColorSpaceRelease(colorspace);
65 NSGraphicsContext *context = [NSGraphicsContext graphicsContextWithGraphicsPort:cgRef flipped:NO];
66 CGContextRelease(cgRef);
67 NSGraphicsContext *oldContext = [[NSGraphicsContext currentContext] retain];
68 [NSGraphicsContext setCurrentContext:context];
69 [srcImage drawInRect:toRect
70 fromRect:fromRect
71 operation:NSCompositeSourceOver
72 fraction:1.0];
73 [NSGraphicsContext setCurrentContext:oldContext];
74 [oldContext release];
75 }
76
77 static NSBitmapImageRep* CImage_CreateImageRep(JNIEnv *env, jintArray buffer, jint width, jint height)
78 {
79 NSBitmapImageRep* imageRep = [[[NSBitmapImageRep alloc] initWithBitmapDataPlanes:NULL
80 pixelsWide:width
81 pixelsHigh:height
82 bitsPerSample:8
83 samplesPerPixel:4
84 hasAlpha:YES
85 isPlanar:NO
86 colorSpaceName:NSDeviceRGBColorSpace
87 bitmapFormat:NSAlphaFirstBitmapFormat
88 bytesPerRow:width*4 // TODO: use explicit scanStride
89 bitsPerPixel:32] autorelease];
90
91 jint *imgData = (jint *)[imageRep bitmapData];
92 if (imgData == NULL) return 0L;
93
94 jint *src = (*env)->GetPrimitiveArrayCritical(env, buffer, NULL);
95 if (src == NULL) return 0L;
96
97 CImage_CopyArrayIntoNSImageRep(src, imgData, width, height);
98
99 (*env)->ReleasePrimitiveArrayCritical(env, buffer, src, JNI_ABORT);
100
101 return imageRep;
102 }
103
104 /*
105 * Class: sun_lwawt_macosx_CImage
106 * Method: nativeCreateNSImageFromArray
107 * Signature: ([III)J
108 */
109 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromArray
110 (JNIEnv *env, jclass klass, jintArray buffer, jint width, jint height)
111 {
112 jlong result = 0L;
113
114 JNF_COCOA_ENTER(env);
115
116 NSBitmapImageRep* imageRep = CImage_CreateImageRep(env, buffer, width, height);
117 if (imageRep) {
118 NSImage *nsImage = [[NSImage alloc] initWithSize:NSMakeSize(width, height)];
119 [nsImage addRepresentation:imageRep];
120 result = ptr_to_jlong(nsImage);
121 }
122
123 JNF_COCOA_EXIT(env);
124
125 return result;
126 }
127
128 /*
129 * Class: sun_lwawt_macosx_CImage
130 * Method: nativeCreateNSImageFromArrays
131 * Signature: ([[I[I[I)J
132 */
133 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromArrays
134 (JNIEnv *env, jclass klass, jobjectArray buffers, jintArray widths, jintArray heights)
135 {
136 jlong result = 0L;
137
138 JNF_COCOA_ENTER(env);
139
140 jsize num = (*env)->GetArrayLength(env, buffers);
141 NSMutableArray * reps = [NSMutableArray arrayWithCapacity: num];
142
143 jint * ws = (*env)->GetIntArrayElements(env, widths, NULL);
144 if (ws != NULL) {
145 jint * hs = (*env)->GetIntArrayElements(env, heights, NULL);
146 if (hs != NULL) {
147 jsize i;
148 for (i = 0; i < num; i++) {
149 jintArray buffer = (*env)->GetObjectArrayElement(env, buffers, i);
150
151 NSBitmapImageRep* imageRep = CImage_CreateImageRep(env, buffer, ws[i], hs[i]);
152 if (imageRep) {
153 [reps addObject: imageRep];
154 }
155 }
156
157 (*env)->ReleaseIntArrayElements(env, heights, hs, JNI_ABORT);
158 }
159 (*env)->ReleaseIntArrayElements(env, widths, ws, JNI_ABORT);
160 }
161 if ([reps count]) {
162 NSImage *nsImage = [[NSImage alloc] initWithSize:NSMakeSize(0, 0)];
163 [nsImage addRepresentations: reps];
164 result = ptr_to_jlong(nsImage);
165 }
166
167 JNF_COCOA_EXIT(env);
168
169 return result;
170 }
171
172 /*
173 * Class: sun_lwawt_macosx_CImage
174 * Method: nativeCreateNSImageFromIconSelector
175 * Signature: (I)J
176 */
177 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromIconSelector
178 (JNIEnv *env, jclass klass, jint selector)
179 {
180 NSImage *image = nil;
181
182 JNF_COCOA_ENTER(env);
183
184 IconRef iconRef;
185 if (noErr == GetIconRef(kOnSystemDisk, kSystemIconsCreator, selector, &iconRef)) {
186 image = [[NSImage alloc] initWithIconRef:iconRef];
187 ReleaseIconRef(iconRef);
188 }
189
190 JNF_COCOA_EXIT(env);
191
192 return ptr_to_jlong(image);
193 }
194
195 /*
196 * Class: sun_lwawt_macosx_CImage
197 * Method: nativeCreateNSImageFromFileContents
198 * Signature: (Ljava/lang/String;)J
199 */
200 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromFileContents
201 (JNIEnv *env, jclass klass, jstring file)
202 {
203 NSImage *image = nil;
204
205 JNF_COCOA_ENTER(env);
206
207 NSString *path = JNFNormalizedNSStringForPath(env, file);
208 image = [[NSImage alloc] initByReferencingFile:path];
209
210 JNF_COCOA_EXIT(env);
211
212 return ptr_to_jlong(image);
213 }
214
215 /*
216 * Class: sun_lwawt_macosx_CImage
217 * Method: nativeCreateNSImageOfFileFromLaunchServices
218 * Signature: (Ljava/lang/String;)J
219 */
220 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageOfFileFromLaunchServices
221 (JNIEnv *env, jclass klass, jstring file)
222 {
223 __block NSImage *image = nil;
224
225 JNF_COCOA_ENTER(env);
226
227 NSString *path = JNFNormalizedNSStringForPath(env, file);
228 [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
229 image = [[[NSWorkspace sharedWorkspace] iconForFile:path] retain];
230 [image setScalesWhenResized:TRUE];
231 }];
232
233 JNF_COCOA_EXIT(env);
234
235 return ptr_to_jlong(image);
236 }
237
238 /*
239 * Class: sun_lwawt_macosx_CImage
240 * Method: nativeCreateNSImageFromImageName
241 * Signature: (Ljava/lang/String;)J
242 */
243 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromImageName
244 (JNIEnv *env, jclass klass, jstring name)
245 {
246 NSImage *image = nil;
247
248 JNF_COCOA_ENTER(env);
249
250 image = [[NSImage imageNamed:JNFJavaToNSString(env, name)] retain];
251
252 JNF_COCOA_EXIT(env);
253
254 return ptr_to_jlong(image);
255 }
256
257 /*
258 * Class: sun_lwawt_macosx_CImage
259 * Method: nativeCopyNSImageIntoArray
260 * Signature: (J[IIIII)V
261 */
262 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CImage_nativeCopyNSImageIntoArray
263 (JNIEnv *env, jclass klass, jlong nsImgPtr, jintArray buffer, jint sw, jint sh,
264 jint dw, jint dh)
265 {
266 JNF_COCOA_ENTER(env);
267
268 NSImage *img = (NSImage *)jlong_to_ptr(nsImgPtr);
269 jint *dst = (*env)->GetPrimitiveArrayCritical(env, buffer, NULL);
270 if (dst) {
271 NSRect fromRect = NSMakeRect(0, 0, sw, sh);
272 NSRect toRect = NSMakeRect(0, 0, dw, dh);
273 CImage_CopyNSImageIntoArray(img, dst, fromRect, toRect);
274 (*env)->ReleasePrimitiveArrayCritical(env, buffer, dst, JNI_ABORT);
275 }
276
277 JNF_COCOA_EXIT(env);
278 }
279
280 /*
281 * Class: sun_lwawt_macosx_CImage
282 * Method: nativeGetNSImageSize
283 * Signature: (J)Ljava/awt/geom/Dimension2D;
284 */
285 JNIEXPORT jobject JNICALL Java_sun_lwawt_macosx_CImage_nativeGetNSImageSize
286 (JNIEnv *env, jclass klass, jlong nsImgPtr)
287 {
288 jobject size = NULL;
289
290 JNF_COCOA_ENTER(env);
291
292 size = NSToJavaSize(env, [(NSImage *)jlong_to_ptr(nsImgPtr) size]);
293
294 JNF_COCOA_EXIT(env);
295
296 return size;
297 }
298
299 /*
300 * Class: sun_lwawt_macosx_CImage
301 * Method: nativeSetNSImageSize
302 * Signature: (JDD)V
303 */
304 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CImage_nativeSetNSImageSize
305 (JNIEnv *env, jclass clazz, jlong image, jdouble w, jdouble h)
306 {
307 if (!image) return;
308 NSImage *i = (NSImage *)jlong_to_ptr(image);
309
310 JNF_COCOA_ENTER(env);
311
312 [i setScalesWhenResized:TRUE];
313 [i setSize:NSMakeSize(w, h)];
314
315 JNF_COCOA_EXIT(env);
316 }
317
318 /*
319 * Class: sun_lwawt_macosx_CImage
320 * Method: nativeResizeNSImageRepresentations
321 * Signature: (JDD)V
322 */
323 JNIEXPORT void JNICALL Java_sun_lwawt_macosx_CImage_nativeResizeNSImageRepresentations
324 (JNIEnv *env, jclass clazz, jlong image, jdouble w, jdouble h)
325 {
326 if (!image) return;
327 NSImage *i = (NSImage *)jlong_to_ptr(image);
328
329 JNF_COCOA_ENTER(env);
330
331 NSImageRep *imageRep = nil;
332 NSArray *imageRepresentations = [i representations];
333 NSEnumerator *imageEnumerator = [imageRepresentations objectEnumerator];
334 while ((imageRep = [imageEnumerator nextObject]) != nil) {
335 [imageRep setSize:NSMakeSize(w, h)];
336 }
337
338 JNF_COCOA_EXIT(env);
339 }
340
341 NSComparisonResult getOrder(BOOL order){
342 return (NSComparisonResult) (order ? NSOrderedAscending : NSOrderedDescending);
343 }
344
345 /*
346 * Class: sun_lwawt_macosx_CImage
347 * Method: nativeGetNSImageRepresentationsCount
348 * Signature: (JDD)[Ljava/awt/geom/Dimension2D;
349 */
350 JNIEXPORT jobjectArray JNICALL
351 Java_sun_lwawt_macosx_CImage_nativeGetNSImageRepresentationSizes
352 (JNIEnv *env, jclass clazz, jlong image, jdouble w, jdouble h)
353 {
354 if (!image) return NULL;
355 jobjectArray jreturnArray = NULL;
356 NSImage *img = (NSImage *)jlong_to_ptr(image);
357
358 JNF_COCOA_ENTER(env);
359
360 NSArray *imageRepresentations = [img representations];
361 if([imageRepresentations count] == 0){
362 return NULL;
363 }
364
365 NSArray *sortedImageRepresentations = [imageRepresentations
366 sortedArrayUsingComparator: ^(id obj1, id obj2) {
367
368 NSImageRep *imageRep1 = (NSImageRep *) obj1;
369 NSImageRep *imageRep2 = (NSImageRep *) obj2;
370 NSSize size1 = [imageRep1 size];
371 NSSize size2 = [imageRep2 size];
372
373 if (NSEqualSizes(size1, size2)) {
374 return getOrder([imageRep1 pixelsWide] <= [imageRep2 pixelsWide] &&
375 [imageRep1 pixelsHigh] <= [imageRep2 pixelsHigh]);
376 }
377
378 return getOrder(size1.width <= size2.width && size1.height <= size2.height);
379 }];
380
381 NSMutableArray *sortedPixelSizes = [[[NSMutableArray alloc] init] autorelease];
382 NSSize lastSize = [[sortedImageRepresentations lastObject] size];
383
384 NSUInteger i = [sortedImageRepresentations indexOfObjectPassingTest:
385 ^BOOL(id obj, NSUInteger idx, BOOL *stop) {
386 NSSize imageRepSize = [obj size];
387 return (w <= imageRepSize.width && h <= imageRepSize.height)
388 || NSEqualSizes(imageRepSize, lastSize);
389 }];
390
391 NSUInteger count = [sortedImageRepresentations count];
392 i = (i == NSNotFound) ? count - 1 : i;
393 NSSize bestFitSize = [[sortedImageRepresentations objectAtIndex: i] size];
394
395 for(; i < count; i++){
396 NSImageRep *imageRep = [sortedImageRepresentations objectAtIndex: i];
397
398 if (!NSEqualSizes([imageRep size], bestFitSize)) {
399 break;
400 }
401
402 NSSize pixelSize = NSMakeSize(
403 [imageRep pixelsWide], [imageRep pixelsHigh]);
404 [sortedPixelSizes addObject: [NSValue valueWithSize: pixelSize]];
405 }
406
407 count = [sortedPixelSizes count];
408 static JNF_CLASS_CACHE(jc_Dimension, "java/awt/Dimension");
409 jreturnArray = JNFNewObjectArray(env, &jc_Dimension, count);
410 CHECK_NULL_RETURN(jreturnArray, NULL);
411
412 for(i = 0; i < count; i++){
413 NSSize pixelSize = [[sortedPixelSizes objectAtIndex: i] sizeValue];
414
415 (*env)->SetObjectArrayElement(env, jreturnArray, i,
416 NSToJavaSize(env, pixelSize));
417 JNU_CHECK_EXCEPTION_RETURN(env, NULL);
418 }
419
420 JNF_COCOA_EXIT(env);
421
422 return jreturnArray;
423 }
424
425 /*
426 * Class: sun_lwawt_macosx_CImage
427 * Method: nativeGetPlatformImageBytes
428 * Signature: ([III)[B
429 */
430 JNIEXPORT jbyteArray JNICALL Java_sun_lwawt_macosx_CImage_nativeGetPlatformImageBytes
431 (JNIEnv *env, jclass klass, jintArray buffer, jint width, jint height)
432 {
433 jbyteArray result = 0L;
434
435 JNF_COCOA_ENTER(env);
436
437 NSBitmapImageRep* imageRep = CImage_CreateImageRep(env, buffer, width, height);
438 if (imageRep) {
439 NSData *tiffImage = [imageRep TIFFRepresentation];
440 jsize tiffSize = (jsize)[tiffImage length];
441 result = (*env)->NewByteArray(env, tiffSize);
442 CHECK_NULL_RETURN(result, nil);
443 jbyte *tiffData = (jbyte *)(*env)->GetPrimitiveArrayCritical(env, result, 0);
444 CHECK_NULL_RETURN(tiffData, nil);
445 [tiffImage getBytes:tiffData];
446 (*env)->ReleasePrimitiveArrayCritical(env, result, tiffData, 0);
447 }
448
449 JNF_COCOA_EXIT(env);
450
451 return result;
452 }
453
454 /*
455 * Class: sun_lwawt_macosx_CImage
456 * Method: nativeCreateNSImageFromBytes
457 * Signature: ([B)J
458 */
459 JNIEXPORT jlong JNICALL Java_sun_lwawt_macosx_CImage_nativeCreateNSImageFromBytes
460 (JNIEnv *env, jclass klass, jbyteArray sourceData)
461 {
462 jlong result = 0L;
463 CHECK_NULL_RETURN(sourceData, 0L);
464
465 JNF_COCOA_ENTER(env);
466
467 jsize sourceSize = (*env)->GetArrayLength(env, sourceData);
468 if (sourceSize == 0) return 0L;
469
470 jbyte *sourceBytes = (*env)->GetPrimitiveArrayCritical(env, sourceData, NULL);
471 CHECK_NULL_RETURN(sourceBytes, 0L);
472 NSData *rawData = [NSData dataWithBytes:sourceBytes length:sourceSize];
473 NSImage *newImage = [[NSImage alloc] initWithData:rawData];
474
475 (*env)->ReleasePrimitiveArrayCritical(env, sourceData, sourceBytes, JNI_ABORT);
476 CHECK_NULL_RETURN(newImage, 0L);
477
478 result = ptr_to_jlong(newImage);
479 JNF_COCOA_EXIT(env);
480
481 return result;
482 }