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 NSOpenGLPFAAllowOfflineRenderers, 237 NSOpenGLPFAClosestPolicy, 238 NSOpenGLPFAWindow, 239 NSOpenGLPFAPixelBuffer, 240 NSOpenGLPFADoubleBuffer, 241 NSOpenGLPFAColorSize, 32, 242 NSOpenGLPFAAlphaSize, 8, 243 NSOpenGLPFADepthSize, 16, 244 NSOpenGLPFAScreenMask, glMask, 245 0 246 }; 247 248 sharedPixelFormat = 249 [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs]; 250 if (sharedPixelFormat == nil) { 251 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLPixelFormat is NULL"); 252 [argValue addObject: [NSNumber numberWithLong: 0L]]; 253 return; 254 } 255 256 sharedContext = 257 [[NSOpenGLContext alloc] 258 initWithFormat:sharedPixelFormat 259 shareContext: NULL]; 260 if (sharedContext == nil) { 261 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLContext is NULL"); 262 [argValue addObject: [NSNumber numberWithLong: 0L]]; 263 return; 264 } 265 } 266 267 #if USE_NSVIEW_FOR_SCRATCH 268 NSRect contentRect = NSMakeRect(0, 0, 64, 64); 269 NSWindow *window = 270 [[NSWindow alloc] 271 initWithContentRect: contentRect 272 styleMask: NSBorderlessWindowMask 273 backing: NSBackingStoreBuffered 274 defer: false]; 275 if (window == nil) { 276 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSWindow is NULL"); 277 [argValue addObject: [NSNumber numberWithLong: 0L]]; 278 return; 279 } 280 281 NSView *scratchSurface = 282 [[NSView alloc] 283 initWithFrame: contentRect]; 284 if (scratchSurface == nil) { 285 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSView is NULL"); 286 [argValue addObject: [NSNumber numberWithLong: 0L]]; 287 return; 288 } 289 [window setContentView: scratchSurface]; 290 #else 291 NSOpenGLPixelBuffer *scratchSurface = 292 [[NSOpenGLPixelBuffer alloc] 293 initWithTextureTarget:GL_TEXTURE_2D 294 textureInternalFormat:GL_RGB 295 textureMaxMipMapLevel:0 296 pixelsWide:64 297 pixelsHigh:64]; 298 #endif 299 300 NSOpenGLContext *context = 301 [[NSOpenGLContext alloc] 302 initWithFormat: sharedPixelFormat 303 shareContext: sharedContext]; 304 if (context == nil) { 305 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSOpenGLContext is NULL"); 306 [argValue addObject: [NSNumber numberWithLong: 0L]]; 307 return; 308 } 309 310 GLint contextVirtualScreen = [context currentVirtualScreen]; 311 #if USE_NSVIEW_FOR_SCRATCH 312 [context setView: scratchSurface]; 313 #else 314 [context 315 setPixelBuffer: scratchSurface 316 cubeMapFace:0 317 mipMapLevel:0 318 currentVirtualScreen: contextVirtualScreen]; 319 #endif 320 [context makeCurrentContext]; 321 322 // get version and extension strings 323 const unsigned char *versionstr = j2d_glGetString(GL_VERSION); 324 if (!OGLContext_IsVersionSupported(versionstr)) { 325 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL 1.2 is required"); 326 [NSOpenGLContext clearCurrentContext]; 327 [argValue addObject: [NSNumber numberWithLong: 0L]]; 328 return; 329 } 330 J2dRlsTraceLn1(J2D_TRACE_INFO, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL version=%s", versionstr); 331 332 jint caps = CAPS_EMPTY; 333 OGLContext_GetExtensionInfo(env, &caps); 334 335 GLint value = 0; 336 [sharedPixelFormat 337 getValues: &value 338 forAttribute: NSOpenGLPFADoubleBuffer 339 forVirtualScreen: contextVirtualScreen]; 340 if (value != 0) { 341 caps |= CAPS_DOUBLEBUFFERED; 342 } 343 344 J2dRlsTraceLn1(J2D_TRACE_INFO, 345 "CGLGraphicsConfig_getCGLConfigInfo: db=%d", 346 (caps & CAPS_DOUBLEBUFFERED) != 0); 347 348 // remove before shipping (?) 349 #if 1 350 [sharedPixelFormat 351 getValues: &value 352 forAttribute: NSOpenGLPFAAccelerated 353 forVirtualScreen: contextVirtualScreen]; 354 if (value == 0) { 355 [sharedPixelFormat 356 getValues: &value 357 forAttribute: NSOpenGLPFARendererID 358 forVirtualScreen: contextVirtualScreen]; 359 fprintf(stderr, "WARNING: GL pipe is running in software mode (Renderer ID=0x%x)\n", (int)value); 360 } 361 #endif 362 363 // 0: the buffers are swapped with no regard to the vertical refresh rate 364 // 1: the buffers are swapped only during the vertical retrace 365 GLint params = swapInterval; 366 [context setValues: ¶ms forParameter: NSOpenGLCPSwapInterval]; 367 368 CGLCtxInfo *ctxinfo = (CGLCtxInfo *)malloc(sizeof(CGLCtxInfo)); 369 if (ctxinfo == NULL) { 370 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for ctxinfo"); 371 [NSOpenGLContext clearCurrentContext]; 372 [argValue addObject: [NSNumber numberWithLong: 0L]]; 373 return; 374 } 375 memset(ctxinfo, 0, sizeof(CGLCtxInfo)); 376 ctxinfo->context = context; 377 ctxinfo->scratchSurface = scratchSurface; 378 379 OGLContext *oglc = (OGLContext *)malloc(sizeof(OGLContext)); 380 if (oglc == 0L) { 381 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for oglc"); 382 [NSOpenGLContext clearCurrentContext]; 383 free(ctxinfo); 384 [argValue addObject: [NSNumber numberWithLong: 0L]]; 385 return; 386 } 387 memset(oglc, 0, sizeof(OGLContext)); 388 oglc->ctxInfo = ctxinfo; 389 oglc->caps = caps; 390 391 // create the CGLGraphicsConfigInfo record for this config 392 CGLGraphicsConfigInfo *cglinfo = (CGLGraphicsConfigInfo *)malloc(sizeof(CGLGraphicsConfigInfo)); 393 if (cglinfo == NULL) { 394 J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: could not allocate memory for cglinfo"); 395 [NSOpenGLContext clearCurrentContext]; 396 free(oglc); 397 free(ctxinfo); 398 [argValue addObject: [NSNumber numberWithLong: 0L]]; 399 return; 400 } 401 memset(cglinfo, 0, sizeof(CGLGraphicsConfigInfo)); 402 cglinfo->screen = displayID; 403 cglinfo->pixfmt = sharedPixelFormat; 404 cglinfo->context = oglc; 405 406 [NSOpenGLContext clearCurrentContext]; 407 [argValue addObject: [NSNumber numberWithLong:ptr_to_jlong(cglinfo)]]; 408 [pool drain]; 409 } 410 @end //GraphicsConfigUtil 411 412 JNIEXPORT jint JNICALL 413 Java_sun_java2d_opengl_CGLGraphicsConfig_getOGLCapabilities 414 (JNIEnv *env, jclass cglgc, jlong configInfo) 415 { 416 J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_getOGLCapabilities"); 417 418 CGLGraphicsConfigInfo *cglinfo = 419 (CGLGraphicsConfigInfo *)jlong_to_ptr(configInfo); 420 if ((cglinfo == NULL) || (cglinfo->context == NULL)) { 421 return CAPS_EMPTY; 422 } else { 423 return cglinfo->context->caps; 424 } 425 } 426 427 JNIEXPORT jint JNICALL 428 Java_sun_java2d_opengl_CGLGraphicsConfig_nativeGetMaxTextureSize 429 (JNIEnv *env, jclass cglgc) 430 { 431 J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_nativeGetMaxTextureSize"); 432 433 __block int max = 0; 434 435 [ThreadUtilities performOnMainThreadWaiting:YES block:^(){ 436 [sharedContext makeCurrentContext]; 437 j2d_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max); 438 [NSOpenGLContext clearCurrentContext]; 439 }]; 440 441 return (jint)max; 442 }