1 /*

     2  * Copyright (c) 2019, 2019, 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_metal_MetalGraphicsConfig.h"

    27 

    28 #import "MetalGraphicsConfig.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 Metal 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 "--- MetalGraphicsConfig 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_metal_MetalGraphicsConfig_getMetalConfigInfo

   193     (JNIEnv *env, jclass metalgc,

   194      jint displayID, jint pixfmt)

   195 {

   196     //fprintf(stdout, "Jay : MetalGraphicsConfig_getMetalConfigInfo\n");fflush(stdout);

   197   jlong ret = 0L;

   198   JNF_COCOA_ENTER(env);

   199   NSMutableArray * retArray = [NSMutableArray arrayWithCapacity:2];

   200   [retArray addObject: [NSNumber numberWithInt: (int)displayID]];

   201   [retArray addObject: [NSNumber numberWithInt: (int)pixfmt]];

   202   //if ([NSThread isMainThread]) {

   203       //[GraphicsConfigUtil _getCGLConfigInfo: retArray];

   204   //} else {

   205       [MetalGraphicsConfigUtil performSelectorOnMainThread: @selector(_getMetalConfigInfo:) 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 @implementation MetalGraphicsConfigUtil

   214 + (void) _getMetalConfigInfo: (NSMutableArray *)argValue {

   215     AWT_ASSERT_APPKIT_THREAD;

   216 

   217     //fprintf(stdout, "Jay : MetalGraphicsConfig_MetalGraphicsConfigUtil\n");fflush(stdout);

   218     jint displayID = (jint)[(NSNumber *)[argValue objectAtIndex: 0] intValue];

   219     jint pixfmt = (jint)[(NSNumber *)[argValue objectAtIndex: 1] intValue];

   220     JNIEnv *env = [ThreadUtilities getJNIEnvUncached];

   221     [argValue removeAllObjects];

   222 

   223     //J2dRlsTraceLn(J2D_TRACE_INFO, "MetalGraphicsConfig_getMetalConfigInfo");

   224 

   225     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];

   226 

   227     /*CGOpenGLDisplayMask glMask = (CGOpenGLDisplayMask)pixfmt;

   228     if (sharedContext == NULL) {

   229         if (glMask == 0) {

   230             glMask = CGDisplayIDToOpenGLDisplayMask(displayID);

   231         }

   232 

   233         NSOpenGLPixelFormatAttribute attrs[] = {

   234             NSOpenGLPFAAllowOfflineRenderers,

   235             NSOpenGLPFAClosestPolicy,

   236             NSOpenGLPFAWindow,

   237             NSOpenGLPFAPixelBuffer,

   238             NSOpenGLPFADoubleBuffer,

   239             NSOpenGLPFAColorSize, 32,

   240             NSOpenGLPFAAlphaSize, 8,

   241             NSOpenGLPFADepthSize, 16,

   242             NSOpenGLPFAScreenMask, glMask,

   243             0

   244         };

   245 

   246         sharedPixelFormat =

   247             [[NSOpenGLPixelFormat alloc] initWithAttributes:attrs];

   248         if (sharedPixelFormat == nil) {

   249             J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLPixelFormat is NULL");

   250             [argValue addObject: [NSNumber numberWithLong: 0L]];

   251             return;

   252         }

   253 

   254         sharedContext =

   255             [[NSOpenGLContext alloc]

   256                 initWithFormat:sharedPixelFormat

   257                 shareContext: NULL];

   258         if (sharedContext == nil) {

   259             J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: shared NSOpenGLContext is NULL");

   260             [argValue addObject: [NSNumber numberWithLong: 0L]];

   261             return;

   262         }

   263     }*/

   264     id<MTLDevice> device = MTLCreateSystemDefaultDevice();

   265     

   266     id<MTLCommandQueue> commandQueue = [device newCommandQueue];

   267     

   268     // Jay : Looks like no need to create MetaLayer here and we were creating

   269     // scratch surface only to make OGL context current. So no need to create any layer for

   270     // Metal. Just create device and commandQueue for Metal.

   271     //defaultLibrary = [device newDefaultLibrary];

   272     /*CAMetalLayer *metalLayer = [CAMetalLayer layer];

   273     metalLayer.device = device;

   274     metalLayer.pixelFormat = MTLPixelFormatBGRA8Unorm;*/

   275     

   276 #if USE_NSVIEW_FOR_SCRATCH

   277     /*NSRect contentRect = NSMakeRect(0, 0, 64, 64);

   278     NSWindow *window =

   279         [[NSWindow alloc]

   280             initWithContentRect: contentRect

   281             styleMask: NSBorderlessWindowMask

   282             backing: NSBackingStoreBuffered

   283             defer: false];

   284     if (window == nil) {

   285         J2dRlsTraceLn(J2D_TRACE_ERROR, "MetalGraphicsConfig_getMetalConfigInfo: NSWindow is NULL");

   286         [argValue addObject: [NSNumber numberWithLong: 0L]];

   287         return;

   288     }

   289 

   290     NSView *scratchSurface =

   291         [[NSView alloc]

   292             initWithFrame: contentRect];

   293     if (scratchSurface == nil) {

   294         J2dRlsTraceLn(J2D_TRACE_ERROR, "MetalGraphicsConfig_getMetalConfigInfo: NSView is NULL");

   295         [argValue addObject: [NSNumber numberWithLong: 0L]];

   296         return;

   297     }

   298     [window setContentView: scratchSurface];*/

   299 #else

   300     /*NSOpenGLPixelBuffer *scratchSurface =

   301         [[NSOpenGLPixelBuffer alloc]

   302             initWithTextureTarget:GL_TEXTURE_2D

   303             textureInternalFormat:GL_RGB

   304             textureMaxMipMapLevel:0

   305             pixelsWide:64

   306             pixelsHigh:64];*/

   307 #endif

   308 

   309     /*NSOpenGLContext *context =

   310         [[NSOpenGLContext alloc]

   311             initWithFormat: sharedPixelFormat

   312             shareContext: sharedContext];

   313     if (context == nil) {

   314         J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: NSOpenGLContext is NULL");

   315         [argValue addObject: [NSNumber numberWithLong: 0L]];

   316         return;

   317     }

   318 

   319     GLint contextVirtualScreen = [context currentVirtualScreen];*/

   320 #if USE_NSVIEW_FOR_SCRATCH

   321     //[context setView: scratchSurface];

   322     // Jay : no need of scratch layer for metal

   323     //metalLayer.frame = scratchSurface.layer.frame;

   324     //[scratchSurface.layer addSublayer: metalLayer];

   325 #else

   326     /*[context

   327         setPixelBuffer: scratchSurface

   328         cubeMapFace:0

   329         mipMapLevel:0

   330         currentVirtualScreen: contextVirtualScreen];*/

   331 #endif

   332     /*[context makeCurrentContext];

   333 

   334     // get version and extension strings

   335     const unsigned char *versionstr = j2d_glGetString(GL_VERSION);

   336     if (!OGLContext_IsVersionSupported(versionstr)) {

   337         J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL 1.2 is required");

   338         [NSOpenGLContext clearCurrentContext];

   339         [argValue addObject: [NSNumber numberWithLong: 0L]];

   340         return;

   341     }

   342     J2dRlsTraceLn1(J2D_TRACE_INFO, "CGLGraphicsConfig_getCGLConfigInfo: OpenGL version=%s", versionstr);

   343 

   344     jint caps = CAPS_EMPTY;

   345     OGLContext_GetExtensionInfo(env, &caps);

   346 

   347     GLint value = 0;

   348     [sharedPixelFormat

   349         getValues: &value

   350         forAttribute: NSOpenGLPFADoubleBuffer

   351         forVirtualScreen: contextVirtualScreen];

   352     if (value != 0) {

   353         caps |= CAPS_DOUBLEBUFFERED;

   354     }

   355 

   356     J2dRlsTraceLn1(J2D_TRACE_INFO,

   357                    "CGLGraphicsConfig_getCGLConfigInfo: db=%d",

   358                    (caps & CAPS_DOUBLEBUFFERED) != 0);*/

   359 

   360     // remove before shipping (?)

   361 #if 1

   362     /*[sharedPixelFormat

   363         getValues: &value

   364         forAttribute: NSOpenGLPFAAccelerated

   365         forVirtualScreen: contextVirtualScreen];

   366     if (value == 0) {

   367         [sharedPixelFormat

   368             getValues: &value

   369             forAttribute: NSOpenGLPFARendererID

   370             forVirtualScreen: contextVirtualScreen];

   371         fprintf(stderr, "WARNING: GL pipe is running in software mode (Renderer ID=0x%x)\n", (int)value);

   372     }*/

   373 #endif

   374 

   375     // 0: the buffers are swapped with no regard to the vertical refresh rate

   376     // 1: the buffers are swapped only during the vertical retrace

   377     /*GLint params = swapInterval;

   378     [context setValues: &params forParameter: NSOpenGLCPSwapInterval];

   379 

   380     CGLCtxInfo *ctxinfo = (CGLCtxInfo *)malloc(sizeof(CGLCtxInfo));

   381     if (ctxinfo == NULL) {

   382         J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for ctxinfo");

   383         [NSOpenGLContext clearCurrentContext];

   384         [argValue addObject: [NSNumber numberWithLong: 0L]];

   385         return;

   386     }

   387     memset(ctxinfo, 0, sizeof(CGLCtxInfo));

   388     ctxinfo->context = context;

   389     ctxinfo->scratchSurface = scratchSurface;

   390 

   391     OGLContext *oglc = (OGLContext *)malloc(sizeof(OGLContext));

   392     if (oglc == 0L) {

   393         J2dRlsTraceLn(J2D_TRACE_ERROR, "CGLGC_InitOGLContext: could not allocate memory for oglc");

   394         [NSOpenGLContext clearCurrentContext];

   395         free(ctxinfo);

   396         [argValue addObject: [NSNumber numberWithLong: 0L]];

   397         return;

   398     }

   399     memset(oglc, 0, sizeof(OGLContext));

   400     oglc->ctxInfo = ctxinfo;

   401     oglc->caps = caps;*/

   402 

   403     // create the CGLGraphicsConfigInfo record for this config

   404     MetalGraphicsConfigInfo *metalinfo = (MetalGraphicsConfigInfo *)malloc(sizeof(MetalGraphicsConfigInfo));

   405     if (metalinfo == NULL) {

   406         //J2dRlsTraceLn(J2D_TRACE_ERROR, "MetalGraphicsConfig_getMetalConfigInfo: could not allocate memory for cglinfo");

   407         //[NSOpenGLContext clearCurrentContext];

   408         //free(oglc);

   409         //free(ctxinfo);

   410         //[argValue addObject: [NSNumber numberWithLong: 0L]];

   411         return;

   412     }

   413     memset(metalinfo, 0, sizeof(MetalGraphicsConfigInfo));

   414     metalinfo->screen = displayID;

   415     metalinfo->device = device;

   416     metalinfo->commandQueue = commandQueue;

   417 

   418     //[NSOpenGLContext clearCurrentContext];

   419     [argValue addObject: [NSNumber numberWithLong:ptr_to_jlong(metalinfo)]];

   420     [pool drain];

   421 }

   422 @end //GraphicsConfigUtil

   423 

   424 /*JNIEXPORT jint JNICALL

   425 Java_sun_java2d_opengl_CGLGraphicsConfig_getOGLCapabilities

   426     (JNIEnv *env, jclass cglgc, jlong configInfo)

   427 {

   428     J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_getOGLCapabilities");

   429 

   430     CGLGraphicsConfigInfo *cglinfo =

   431         (CGLGraphicsConfigInfo *)jlong_to_ptr(configInfo);

   432     if ((cglinfo == NULL) || (cglinfo->context == NULL)) {

   433         return CAPS_EMPTY;

   434     } else {

   435         return cglinfo->context->caps;

   436     }

   437 }

   438 

   439 JNIEXPORT jint JNICALL

   440 Java_sun_java2d_opengl_CGLGraphicsConfig_nativeGetMaxTextureSize

   441     (JNIEnv *env, jclass cglgc)

   442 {

   443     J2dTraceLn(J2D_TRACE_INFO, "CGLGraphicsConfig_nativeGetMaxTextureSize");

   444 

   445     __block int max = 0;

   446 

   447     [ThreadUtilities performOnMainThreadWaiting:YES block:^(){

   448         [sharedContext makeCurrentContext];

   449         j2d_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max);

   450         [NSOpenGLContext clearCurrentContext];

   451     }];

   452 

   453     return (jint)max;

   454 }*/