1 /*
2 * Copyright (c) 2011, 2015, 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 "sun_java2d_opengl_CGLGraphicsConfig.h"
27
28 #import "CGLGraphicsConfig.h"
29 #import "CGLSurfaceData.h"
30 #import "ThreadUtilities.h"
31
32 #import <stdlib.h>
33 #import <string.h>
34 #import <ApplicationServices/ApplicationServices.h>
35 #import <JavaNativeFoundation/JavaNativeFoundation.h>
36
37 #pragma mark -
38 #pragma mark "--- Mac OS X specific methods for GL pipeline ---"
39
40 /**
41 * Disposes all memory and resources associated with the given
42 * CGLGraphicsConfigInfo (including its native OGLContext data).
43 */
44 void
45 OGLGC_DestroyOGLGraphicsConfig(jlong pConfigInfo)
46 {
47 J2dTraceLn(J2D_TRACE_INFO, "OGLGC_DestroyOGLGraphicsConfig");
48
49 CGLGraphicsConfigInfo *cglinfo =
50 (CGLGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
51 if (cglinfo == NULL) {
52 J2dRlsTraceLn(J2D_TRACE_ERROR,
53 "OGLGC_DestroyOGLGraphicsConfig: info is null");
54 return;
55 }
56
57 OGLContext *oglc = (OGLContext*)cglinfo->context;
58 if (oglc != NULL) {
59 OGLContext_DestroyContextResources(oglc);
60
61 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)oglc->ctxInfo;
62 if (ctxinfo != NULL) {
63 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
64 [NSOpenGLContext clearCurrentContext];
65 [ctxinfo->context clearDrawable];
66 [ctxinfo->context release];
67 if (ctxinfo->scratchSurface != 0) {
68 [ctxinfo->scratchSurface release];
69 }
70 [pool drain];
71 free(ctxinfo);
72 oglc->ctxInfo = NULL;
73 }
74 cglinfo->context = NULL;
75 }
76
77 free(cglinfo);
78 }
79
80 #pragma mark -
81 #pragma mark "--- CGLGraphicsConfig methods ---"
82
83 #ifdef REMOTELAYER
84 mach_port_t JRSRemotePort;
85 int remoteSocketFD = -1;
86
87 static void *JRSRemoteThreadFn(void *data) {
88 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
89
90 // Negotiate a unix domain socket to communicate the
91 // out of band data: to read the mach port server name, and
92 // subsequently write out the layer ID.
93 static char* sock_path = "/tmp/JRSRemoteDemoSocket";
94 struct sockaddr_un address;
95 int socket_fd, nbytes;
96 int BUFLEN = 256;
97 char buffer[BUFLEN];
98
99 remoteSocketFD = socket(PF_LOCAL, SOCK_STREAM, 0);
100 if (remoteSocketFD < 0) {
101 NSLog(@"socket() failed");
102 return NULL;
103 }
104 memset(&address, 0, sizeof(struct sockaddr_un));
105 address.sun_family = AF_UNIX;
106 memcpy(address.sun_path, sock_path, strlen(sock_path)+1);
107 int tries=0, status=-1;
108 while (status !=0 && tries<600) {
109 status = connect(remoteSocketFD, (struct sockaddr *) &address,
110 sizeof(struct sockaddr_un));
111 if (status != 0) {
112 tries++;
113 NSLog(@"connection attempt %d failed.", tries);
114 usleep(5000000);
115 }
116 }
117 if (status != 0) {
118 NSLog(@"failed to connect");
119 return NULL;
120 }
121 nbytes = read(remoteSocketFD, buffer, BUFLEN);
122 NSString* serverString = [[NSString alloc] initWithUTF8String:buffer];
123 CFRetain(serverString);
124 NSLog(@"Read server name %@", serverString);
125 JRSRemotePort = [JRSRenderServer recieveRenderServer:serverString];
126 NSLog(@"Read server port %d", JRSRemotePort);
127
128 [pool drain];
129 return NULL;
130 }
131
132 void sendLayerID(int layerID) {
133 if (JRSRemotePort == 0 || remoteSocketFD < 0) {
134 NSLog(@"No connection to send ID");
135 return;
136 }
137 int BUFLEN = 256;
138 char buffer[BUFLEN];
139 snprintf(buffer, BUFLEN, "%d", layerID);
140 write(remoteSocketFD, buffer, BUFLEN);
141 }
142 #endif /* REMOTELAYER */
143
144 /**
145 * This is a globally shared context used when creating textures. When any
146 * new contexts are created, they specify this context as the "share list"
147 * context, which means any texture objects created when this shared context
148 * is current will be available to any other context in any other thread.
149 */
150 NSOpenGLContext *sharedContext = NULL;
151 NSOpenGLPixelFormat *sharedPixelFormat = NULL;
152
153 /**
154 * Attempts to initialize CGL and the core OpenGL library.
155 */
156 JNIEXPORT jboolean JNICALL
157 Java_sun_java2d_opengl_CGLGraphicsConfig_initCGL
158 (JNIEnv *env, jclass cglgc)
159 {
160 J2dRlsTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_initCGL");
161
162 if (!OGLFuncs_OpenLibrary()) {
163 return JNI_FALSE;
164 }
165
166 if (!OGLFuncs_InitPlatformFuncs() ||
167 !OGLFuncs_InitBaseFuncs() ||
168 !OGLFuncs_InitExtFuncs())
169 {
170 OGLFuncs_CloseLibrary();
171 return JNI_FALSE;
172 }
173 #ifdef REMOTELAYER
174 pthread_t jrsRemoteThread;
175 pthread_create(&jrsRemoteThread, NULL, JRSRemoteThreadFn, NULL);
176 #endif
177 return JNI_TRUE;
178 }
179
180
181 /**
182 * Determines whether the CGL pipeline can be used for a given GraphicsConfig
183 * provided its screen number and visual ID. If the minimum requirements are
184 * met, the native CGLGraphicsConfigInfo structure is initialized for this
185 * GraphicsConfig with the necessary information (pixel format, etc.)
186 * and a pointer to this structure is returned as a jlong. If
187 * initialization fails at any point, zero is returned, indicating that CGL
188 * cannot be used for this GraphicsConfig (we should fallback on an existing
189 * 2D pipeline).
190 */
191 JNIEXPORT jlong JNICALL
192 Java_sun_java2d_opengl_CGLGraphicsConfig_getCGLConfigInfo
193 (JNIEnv *env, jclass cglgc,
194 jint displayID, jint pixfmt, jint swapInterval)
195 {
196 jlong ret = 0L;
197 JNF_COCOA_ENTER(env);
198 NSMutableArray * retArray = [NSMutableArray arrayWithCapacity:3];
199 [retArray addObject: [NSNumber numberWithInt: (int)displayID]];
200 [retArray addObject: [NSNumber numberWithInt: (int)pixfmt]];
201 [retArray addObject: [NSNumber numberWithInt: (int)swapInterval]];
202 if ([NSThread isMainThread]) {
203 [GraphicsConfigUtil _getCGLConfigInfo: retArray];
204 } else {
205 [GraphicsConfigUtil performSelectorOnMainThread: @selector(_getCGLConfigInfo:) withObject: retArray waitUntilDone: YES];
206 }
207 NSNumber * num = (NSNumber *)[retArray objectAtIndex: 0];
208 ret = (jlong)[num longValue];
209 JNF_COCOA_EXIT(env);
210 return ret;
211 }
212
213
214
215 @implementation GraphicsConfigUtil
216 + (void) _getCGLConfigInfo: (NSMutableArray *)argValue {
217 AWT_ASSERT_APPKIT_THREAD;
218
219 jint displayID = (jint)[(NSNumber *)[argValue objectAtIndex: 0] intValue];
220 jint pixfmt = (jint)[(NSNumber *)[argValue objectAtIndex: 1] intValue];
221 jint swapInterval = (jint)[(NSNumber *)[argValue objectAtIndex: 2] intValue];
222 JNIEnv *env = [ThreadUtilities getJNIEnvUncached];
223 [argValue removeAllObjects];
224
225 J2dRlsTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_getCGLConfigInfo");
226
227 NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
228
229 CGOpenGLDisplayMask glMask = (CGOpenGLDisplayMask)pixfmt;
230 if (sharedContext == NULL) {
231 if (glMask == 0) {
232 glMask = CGDisplayIDToOpenGLDisplayMask(displayID);
233 }
234
235 NSOpenGLPixelFormatAttribute attrs[] = {
236 NSOpenGLPFAClosestPolicy,
237 NSOpenGLPFAWindow,
238 NSOpenGLPFAPixelBuffer,
239 NSOpenGLPFADoubleBuffer,
240 NSOpenGLPFAColorSize, 32,
241 NSOpenGLPFAAlphaSize, 8,
242 NSOpenGLPFADepthSize, 16,
243 NSOpenGLPFAScreenMask, glMask,
244 0
245 };
246
247 sharedPixelFormat =
248 [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs];
249 if (sharedPixelFormat == nil) {
250 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLPixelFormat is NULL");
251 [argValue addObject: [NSNumber numberWithLong: 0L]];
252 return;
253 }
254
255 sharedContext =
256 [[NSOpenGLContext alloc]
257 initWithFormat:sharedPixelFormat
258 shareContext: NULL];
259 if (sharedContext == nil) {
260 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLContext is NULL");
261 [argValue addObject: [NSNumber numberWithLong: 0L]];
262 return;
263 }
264 }
265
266 #if USE_NSVIEW_FOR_SCRATCH
267 NSRect contentRect = NSMakeRect(0, 0, 64, 64);
268 NSWindow *window =
269 [[NSWindow alloc]
270 initWithContentRect: contentRect
271 styleMask: NSBorderlessWindowMask
272 backing: NSBackingStoreBuffered
273 defer: false];
274 if (window == nil) {
275 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSWindow is NULL");
276 [argValue addObject: [NSNumber numberWithLong: 0L]];
277 return;
278 }
279
280 NSView *scratchSurface =
281 [[NSView alloc]
282 initWithFrame: contentRect];
283 if (scratchSurface == nil) {
284 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSView is NULL");
285 [argValue addObject: [NSNumber numberWithLong: 0L]];
286 return;
287 }
288 [window setContentView: scratchSurface];
289 #else
290 NSOpenGLPixelBuffer *scratchSurface =
291 [[NSOpenGLPixelBuffer alloc]
292 initWithTextureTarget:GL_TEXTURE_2D
293 textureInternalFormat:GL_RGB
294 textureMaxMipMapLevel:0
295 pixelsWide:64
296 pixelsHigh:64];
297 #endif
298
299 NSOpenGLContext *context =
300 [[NSOpenGLContext alloc]
301 initWithFormat: sharedPixelFormat
302 shareContext: sharedContext];
303 if (context == nil) {
304 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSOpenGLContext is NULL");
305 [argValue addObject: [NSNumber numberWithLong: 0L]];
306 return;
307 }
308
309 GLint contextVirtualScreen = [context currentVirtualScreen];
310 #if USE_NSVIEW_FOR_SCRATCH
311 [context setView: scratchSurface];
312 #else
313 [context
314 setPixelBuffer: scratchSurface
315 cubeMapFace:0
316 mipMapLevel:0
317 currentVirtualScreen: contextVirtualScreen];
318 #endif
319 [context makeCurrentContext];
320
321 // get version and extension strings
322 const unsigned char *versionstr = j2d_glGetString(GL_VERSION);
323 if (!OGLContext_IsVersionSupported(versionstr)) {
324 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL 1.2 is required");
325 [NSOpenGLContext clearCurrentContext];
326 [argValue addObject: [NSNumber numberWithLong: 0L]];
327 return;
328 }
329 J2dRlsTraceLn1(J2D_TRACE_INFO, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL version=%s", versionstr);
330
331 jint caps = CAPS_EMPTY;
332 OGLContext_GetExtensionInfo(env, &caps);
333
334 GLint value = 0;
335 [sharedPixelFormat
336 getValues: &value
337 forAttribute: NSOpenGLPFADoubleBuffer
338 forVirtualScreen: contextVirtualScreen];
339 if (value != 0) {
340 caps |= CAPS_DOUBLEBUFFERED;
341 }
342
343 J2dRlsTraceLn1(J2D_TRACE_INFO,
344 "CGLGraphicsConfig_getCGLConfigInfo: db=%d",
345 (caps & CAPS_DOUBLEBUFFERED) != 0);
346
347 // remove before shipping (?)
348 #if 1
349 [sharedPixelFormat
350 getValues: &value
351 forAttribute: NSOpenGLPFAAccelerated
352 forVirtualScreen: contextVirtualScreen];
353 if (value == 0) {
354 [sharedPixelFormat
355 getValues: &value
356 forAttribute: NSOpenGLPFARendererID
357 forVirtualScreen: contextVirtualScreen];
358 fprintf(stderr, "WARNING: GL pipe is running in software mode (Renderer ID=0x%x)\n", (int)value);
359 }
360 #endif
361
362 // 0: the buffers are swapped with no regard to the vertical refresh rate
363 // 1: the buffers are swapped only during the vertical retrace
364 GLint params = swapInterval;
365 [context setValues: ¶ms forParameter: NSOpenGLCPSwapInterval];
366
367 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)malloc(sizeof(CGLCtxInfo));
368 if (ctxinfo == NULL) {
369 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for ctxinfo");
370 [NSOpenGLContext clearCurrentContext];
371 [argValue addObject: [NSNumber numberWithLong: 0L]];
372 return;
373 }
374 memset(ctxinfo, 0, sizeof(CGLCtxInfo));
375 ctxinfo->context = context;
376 ctxinfo->scratchSurface = scratchSurface;
377
378 OGLContext *oglc = (OGLContext *)malloc(sizeof(OGLContext));
379 if (oglc == 0L) {
380 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for oglc");
381 [NSOpenGLContext clearCurrentContext];
382 free(ctxinfo);
383 [argValue addObject: [NSNumber numberWithLong: 0L]];
384 return;
385 }
386 memset(oglc, 0, sizeof(OGLContext));
387 oglc->ctxInfo = ctxinfo;
388 oglc->caps = caps;
389
390 // create the CGLGraphicsConfigInfo record for this config
391 CGLGraphicsConfigInfo *cglinfo = (CGLGraphicsConfigInfo *)malloc(sizeof(CGLGraphicsConfigInfo));
392 if (cglinfo == NULL) {
393 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: could not allocate memory for cglinfo");
394 [NSOpenGLContext clearCurrentContext];
395 free(oglc);
396 free(ctxinfo);
397 [argValue addObject: [NSNumber numberWithLong: 0L]];
398 return;
399 }
400 memset(cglinfo, 0, sizeof(CGLGraphicsConfigInfo));
401 cglinfo->screen = displayID;
402 cglinfo->pixfmt = sharedPixelFormat;
403 cglinfo->context = oglc;
404
405 [NSOpenGLContext clearCurrentContext];
406 [argValue addObject: [NSNumber numberWithLong:ptr_to_jlong(cglinfo)]];
407 [pool drain];
408 }
409 @end //GraphicsConfigUtil
410
411 JNIEXPORT jint JNICALL
412 Java_sun_java2d_opengl_CGLGraphicsConfig_getOGLCapabilities
413 (JNIEnv *env, jclass cglgc, jlong configInfo)
414 {
415 J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_getOGLCapabilities");
416
417 CGLGraphicsConfigInfo *cglinfo =
418 (CGLGraphicsConfigInfo *)jlong_to_ptr(configInfo);
419 if ((cglinfo == NULL) || (cglinfo->context == NULL)) {
420 return CAPS_EMPTY;
421 } else {
422 return cglinfo->context->caps;
423 }
424 }
425
426 JNIEXPORT jint JNICALL
427 Java_sun_java2d_opengl_CGLGraphicsConfig_nativeGetMaxTextureSize
428 (JNIEnv *env, jclass cglgc)
429 {
430 J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_nativeGetMaxTextureSize");
431
432 __block int max = 0;
433
434 [ThreadUtilities performOnMainThreadWaiting:YES block:^(){
435 [sharedContext makeCurrentContext];
436 j2d_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);
437 [NSOpenGLContext clearCurrentContext];
438 }];
439
440 return (jint)max;
441 }