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: &params 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 }
--- EOF ---