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