1 /*
   2  * Copyright (c) 2003, 2008, 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 #include <jlong.h>
  27 
  28 #include "sun_java2d_opengl_GLXSurfaceData.h"
  29 
  30 #include "OGLRenderQueue.h"
  31 #include "GLXGraphicsConfig.h"
  32 #include "GLXSurfaceData.h"
  33 #include "awt_Component.h"
  34 #include "awt_GraphicsEnv.h"
  35 
  36 /**
  37  * The methods in this file implement the native windowing system specific
  38  * layer (GLX) for the OpenGL-based Java 2D pipeline.
  39  */
  40 
  41 #ifndef HEADLESS
  42 
  43 extern LockFunc       OGLSD_Lock;
  44 extern GetRasInfoFunc OGLSD_GetRasInfo;
  45 extern UnlockFunc     OGLSD_Unlock;
  46 extern DisposeFunc    OGLSD_Dispose;
  47 
  48 extern struct MComponentPeerIDs mComponentPeerIDs;
  49 
  50 extern void
  51     OGLSD_SetNativeDimensions(JNIEnv *env, OGLSDOps *oglsdo, jint w, jint h);
  52 
  53 jboolean surfaceCreationFailed = JNI_FALSE;
  54 
  55 #endif /* !HEADLESS */
  56 
  57 JNIEXPORT void JNICALL
  58 Java_sun_java2d_opengl_GLXSurfaceData_initOps(JNIEnv *env, jobject glxsd,
  59                                               jobject peer, jlong aData)
  60 {
  61 #ifndef HEADLESS
  62     OGLSDOps *oglsdo = (OGLSDOps *)SurfaceData_InitOps(env, glxsd,
  63                                                        sizeof(OGLSDOps));
  64     GLXSDOps *glxsdo = (GLXSDOps *)malloc(sizeof(GLXSDOps));
  65 
  66     J2dTraceLn(J2D_TRACE_INFO, "GLXSurfaceData_initOps");
  67 
  68     if (oglsdo == NULL) {
  69         JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");
  70         return;
  71     }
  72 
  73     if (glxsdo == NULL) {
  74         JNU_ThrowOutOfMemoryError(env, "creating native GLX ops");
  75         return;
  76     }
  77 
  78     oglsdo->privOps = glxsdo;
  79 
  80     oglsdo->sdOps.Lock       = OGLSD_Lock;
  81     oglsdo->sdOps.GetRasInfo = OGLSD_GetRasInfo;
  82     oglsdo->sdOps.Unlock     = OGLSD_Unlock;
  83     oglsdo->sdOps.Dispose    = OGLSD_Dispose;
  84 
  85     oglsdo->drawableType = OGLSD_UNDEFINED;
  86     oglsdo->activeBuffer = GL_FRONT;
  87     oglsdo->needsInit = JNI_TRUE;
  88 
  89 #ifdef XAWT
  90     if (peer != NULL) {
  91         glxsdo->window = JNU_CallMethodByName(env, NULL, peer,
  92                                               "getContentWindow", "()J").j;
  93     } else {
  94         glxsdo->window = 0;
  95     }
  96 #else
  97     if (peer != NULL) {
  98         struct ComponentData *cdata;
  99         cdata = (struct ComponentData *)
 100             JNU_GetLongFieldAsPtr(env, peer, mComponentPeerIDs.pData);
 101         if (cdata == NULL) {
 102             free(glxsdo);
 103             JNU_ThrowNullPointerException(env, "Component data missing");
 104             return;
 105         }
 106         if (cdata->widget == NULL) {
 107             free(glxsdo);
 108             JNU_ThrowInternalError(env, "Widget is NULL in initOps");
 109             return;
 110         }
 111         glxsdo->widget = cdata->widget;
 112     } else {
 113         glxsdo->widget = NULL;
 114     }
 115 #endif
 116 
 117     glxsdo->configData = (AwtGraphicsConfigDataPtr)jlong_to_ptr(aData);
 118     if (glxsdo->configData == NULL) {
 119         free(glxsdo);
 120         JNU_ThrowNullPointerException(env,
 121                                  "Native GraphicsConfig data block missing");
 122         return;
 123     }
 124 
 125     if (glxsdo->configData->glxInfo == NULL) {
 126         free(glxsdo);
 127         JNU_ThrowNullPointerException(env, "GLXGraphicsConfigInfo missing");
 128         return;
 129     }
 130 #endif /* HEADLESS */
 131 }
 132 
 133 #ifndef HEADLESS
 134 
 135 /**
 136  * This function disposes of any native windowing system resources associated
 137  * with this surface.  For instance, if the given OGLSDOps is of type
 138  * OGLSD_PBUFFER, this method implementation will destroy the actual pbuffer
 139  * surface.
 140  */
 141 void
 142 OGLSD_DestroyOGLSurface(JNIEnv *env, OGLSDOps *oglsdo)
 143 {
 144     GLXSDOps *glxsdo = (GLXSDOps *)oglsdo->privOps;
 145 
 146     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_DestroyOGLSurface");
 147 
 148     if (oglsdo->drawableType == OGLSD_PBUFFER) {
 149         if (glxsdo->drawable != 0) {
 150             j2d_glXDestroyPbuffer(awt_display, glxsdo->drawable);
 151             glxsdo->drawable = 0;
 152         }
 153     } else if (oglsdo->drawableType == OGLSD_WINDOW) {
 154         // X Window is free'd later by AWT code...
 155     }
 156 }
 157 
 158 /**
 159  * Makes the given context current to its associated "scratch" surface.  If
 160  * the operation is successful, this method will return JNI_TRUE; otherwise,
 161  * returns JNI_FALSE.
 162  */
 163 static jboolean
 164 GLXSD_MakeCurrentToScratch(JNIEnv *env, OGLContext *oglc)
 165 {
 166     GLXCtxInfo *ctxInfo;
 167 
 168     J2dTraceLn(J2D_TRACE_INFO, "GLXSD_MakeCurrentToScratch");
 169 
 170     if (oglc == NULL) {
 171         J2dRlsTraceLn(J2D_TRACE_ERROR,
 172                       "GLXSD_MakeCurrentToScratch: context is null");
 173         return JNI_FALSE;
 174     }
 175 
 176     ctxInfo = (GLXCtxInfo *)oglc->ctxInfo;
 177     if (!j2d_glXMakeContextCurrent(awt_display,
 178                                    ctxInfo->scratchSurface,
 179                                    ctxInfo->scratchSurface,
 180                                    ctxInfo->context))
 181     {
 182         J2dRlsTraceLn(J2D_TRACE_ERROR,
 183                       "GLXSD_MakeCurrentToScratch: could not make current");
 184         return JNI_FALSE;
 185     }
 186 
 187     return JNI_TRUE;
 188 }
 189 
 190 /**
 191  * Returns a pointer (as a jlong) to the native GLXGraphicsConfigInfo
 192  * associated with the given OGLSDOps.  This method can be called from
 193  * shared code to retrieve the native GraphicsConfig data in a platform-
 194  * independent manner.
 195  */
 196 jlong
 197 OGLSD_GetNativeConfigInfo(OGLSDOps *oglsdo)
 198 {
 199     GLXSDOps *glxsdo;
 200 
 201     if (oglsdo == NULL) {
 202         J2dRlsTraceLn(J2D_TRACE_ERROR,
 203                       "OGLSD_GetNativeConfigInfo: ops are null");
 204         return 0L;
 205     }
 206 
 207     glxsdo = (GLXSDOps *)oglsdo->privOps;
 208     if (glxsdo == NULL) {
 209         J2dRlsTraceLn(J2D_TRACE_ERROR,
 210                       "OGLSD_GetNativeConfigInfo: glx ops are null");
 211         return 0L;
 212     }
 213 
 214     if (glxsdo->configData == NULL) {
 215         J2dRlsTraceLn(J2D_TRACE_ERROR,
 216                       "OGLSD_GetNativeConfigInfo: config data is null");
 217         return 0L;
 218     }
 219 
 220     return ptr_to_jlong(glxsdo->configData->glxInfo);
 221 }
 222 
 223 /**
 224  * Makes the given GraphicsConfig's context current to its associated
 225  * "scratch" surface.  If there is a problem making the context current,
 226  * this method will return NULL; otherwise, returns a pointer to the
 227  * OGLContext that is associated with the given GraphicsConfig.
 228  */
 229 OGLContext *
 230 OGLSD_SetScratchSurface(JNIEnv *env, jlong pConfigInfo)
 231 {
 232     GLXGraphicsConfigInfo *glxInfo =
 233         (GLXGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
 234     OGLContext *oglc;
 235 
 236     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SetScratchContext");
 237 
 238     if (glxInfo == NULL) {
 239         J2dRlsTraceLn(J2D_TRACE_ERROR,
 240                       "OGLSD_SetScratchContext: glx config info is null");
 241         return NULL;
 242     }
 243 
 244     oglc = glxInfo->context;
 245     if (!GLXSD_MakeCurrentToScratch(env, oglc)) {
 246         return NULL;
 247     }
 248 
 249     if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
 250         // the GL_EXT_framebuffer_object extension is present, so this call
 251         // will ensure that we are bound to the scratch pbuffer (and not
 252         // some other framebuffer object)
 253         j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 254     }
 255 
 256     return oglc;
 257 }
 258 
 259 /**
 260  * Makes a context current to the given source and destination
 261  * surfaces.  If there is a problem making the context current, this method
 262  * will return NULL; otherwise, returns a pointer to the OGLContext that is
 263  * associated with the destination surface.
 264  */
 265 OGLContext *
 266 OGLSD_MakeOGLContextCurrent(JNIEnv *env, OGLSDOps *srcOps, OGLSDOps *dstOps)
 267 {
 268     GLXSDOps *dstGLXOps = (GLXSDOps *)dstOps->privOps;
 269     OGLContext *oglc;
 270 
 271     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_MakeOGLContextCurrent");
 272 
 273     oglc = dstGLXOps->configData->glxInfo->context;
 274     if (oglc == NULL) {
 275         J2dRlsTraceLn(J2D_TRACE_ERROR,
 276                       "OGLSD_MakeOGLContextCurrent: context is null");
 277         return NULL;
 278     }
 279 
 280     if (dstOps->drawableType == OGLSD_FBOBJECT) {
 281         OGLContext *currentContext = OGLRenderQueue_GetCurrentContext();
 282 
 283         // first make sure we have a current context (if the context isn't
 284         // already current to some drawable, we will make it current to
 285         // its scratch surface)
 286         if (oglc != currentContext) {
 287             if (!GLXSD_MakeCurrentToScratch(env, oglc)) {
 288                 return NULL;
 289             }
 290         }
 291 
 292         // now bind to the fbobject associated with the destination surface;
 293         // this means that all rendering will go into the fbobject destination
 294         // (note that we unbind the currently bound texture first; this is
 295         // recommended procedure when binding an fbobject)
 296         j2d_glBindTexture(dstOps->textureTarget, 0);
 297         j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, dstOps->fbobjectID);
 298     } else {
 299         GLXSDOps *srcGLXOps = (GLXSDOps *)srcOps->privOps;
 300         GLXCtxInfo *ctxinfo = (GLXCtxInfo *)oglc->ctxInfo;
 301 
 302         // make the context current
 303         if (!j2d_glXMakeContextCurrent(awt_display,
 304                                        dstGLXOps->drawable,
 305                                        srcGLXOps->drawable,
 306                                        ctxinfo->context))
 307         {
 308             J2dRlsTraceLn(J2D_TRACE_ERROR,
 309                 "OGLSD_MakeOGLContextCurrent: could not make current");
 310             return NULL;
 311         }
 312 
 313         if (OGLC_IS_CAP_PRESENT(oglc, CAPS_EXT_FBOBJECT)) {
 314             // the GL_EXT_framebuffer_object extension is present, so we
 315             // must bind to the default (windowing system provided)
 316             // framebuffer
 317             j2d_glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 318         }
 319     }
 320 
 321     return oglc;
 322 }
 323 
 324 /**
 325  * This function initializes a native window surface and caches the window
 326  * bounds in the given OGLSDOps.  Returns JNI_TRUE if the operation was
 327  * successful; JNI_FALSE otherwise.
 328  */
 329 jboolean
 330 OGLSD_InitOGLWindow(JNIEnv *env, OGLSDOps *oglsdo)
 331 {
 332     GLXSDOps *glxsdo;
 333     Window window;
 334 #ifdef XAWT
 335     XWindowAttributes attr;
 336 #else
 337     Widget widget;
 338 #endif
 339 
 340     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_InitOGLWindow");
 341 
 342     if (oglsdo == NULL) {
 343         J2dRlsTraceLn(J2D_TRACE_ERROR,
 344                       "OGLSD_InitOGLWindow: ops are null");
 345         return JNI_FALSE;
 346     }
 347 
 348     glxsdo = (GLXSDOps *)oglsdo->privOps;
 349     if (glxsdo == NULL) {
 350         J2dRlsTraceLn(J2D_TRACE_ERROR,
 351                       "OGLSD_InitOGLWindow: glx ops are null");
 352         return JNI_FALSE;
 353     }
 354 
 355 #ifdef XAWT
 356     window = glxsdo->window;
 357     if (window == 0) {
 358         J2dRlsTraceLn(J2D_TRACE_ERROR,
 359                       "OGLSD_InitOGLWindow: window is invalid");
 360         return JNI_FALSE;
 361     }
 362 
 363     XGetWindowAttributes(awt_display, window, &attr);
 364     oglsdo->width = attr.width;
 365     oglsdo->height = attr.height;
 366 #else
 367     widget = glxsdo->widget;
 368     if (widget == NULL) {
 369         J2dTraceLn(J2D_TRACE_WARNING, "OGLSD_InitOGLWindow: widget is null");
 370     }
 371 
 372     if (!XtIsRealized(widget)) {
 373         J2dRlsTraceLn(J2D_TRACE_ERROR,
 374                       "OGLSD_InitOGLWindow: widget is unrealized");
 375         return JNI_FALSE;
 376     }
 377 
 378     window = XtWindow(widget);
 379     oglsdo->width = widget->core.width;
 380     oglsdo->height = widget->core.height;
 381 #endif
 382 
 383     oglsdo->drawableType = OGLSD_WINDOW;
 384     oglsdo->isOpaque = JNI_TRUE;
 385     oglsdo->xOffset = 0;
 386     oglsdo->yOffset = 0;
 387     glxsdo->drawable = window;
 388     glxsdo->xdrawable = window;
 389 
 390     J2dTraceLn2(J2D_TRACE_VERBOSE, "  created window: w=%d h=%d",
 391                 oglsdo->width, oglsdo->height);
 392 
 393     return JNI_TRUE;
 394 }
 395 
 396 static int
 397 GLXSD_BadAllocXErrHandler(Display *display, XErrorEvent *xerr)
 398 {
 399     int ret = 0;
 400     if (xerr->error_code == BadAlloc) {
 401         surfaceCreationFailed = JNI_TRUE;
 402     } else {
 403         ret = (*xerror_saved_handler)(display, xerr);
 404     }
 405     return ret;
 406 }
 407 
 408 JNIEXPORT jboolean JNICALL
 409 Java_sun_java2d_opengl_GLXSurfaceData_initPbuffer
 410     (JNIEnv *env, jobject glxsd,
 411      jlong pData, jlong pConfigInfo,
 412      jboolean isOpaque,
 413      jint width, jint height)
 414 {
 415     OGLSDOps *oglsdo = (OGLSDOps *)jlong_to_ptr(pData);
 416     GLXGraphicsConfigInfo *glxinfo =
 417         (GLXGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
 418     GLXSDOps *glxsdo;
 419     GLXPbuffer pbuffer;
 420     int attrlist[] = {GLX_PBUFFER_WIDTH, 0,
 421                       GLX_PBUFFER_HEIGHT, 0,
 422                       GLX_PRESERVED_CONTENTS, GL_FALSE, 0};
 423 
 424     J2dTraceLn3(J2D_TRACE_INFO,
 425                 "GLXSurfaceData_initPbuffer: w=%d h=%d opq=%d",
 426                 width, height, isOpaque);
 427 
 428     if (oglsdo == NULL) {
 429         J2dRlsTraceLn(J2D_TRACE_ERROR,
 430                       "GLXSurfaceData_initPbuffer: ops are null");
 431         return JNI_FALSE;
 432     }
 433 
 434     glxsdo = (GLXSDOps *)oglsdo->privOps;
 435     if (glxsdo == NULL) {
 436         J2dRlsTraceLn(J2D_TRACE_ERROR,
 437                       "GLXSurfaceData_initPbuffer: glx ops are null");
 438         return JNI_FALSE;
 439     }
 440 
 441     if (glxinfo == NULL) {
 442         J2dRlsTraceLn(J2D_TRACE_ERROR,
 443                       "GLXSurfaceData_initPbuffer: glx config info is null");
 444         return JNI_FALSE;
 445     }
 446 
 447     attrlist[1] = width;
 448     attrlist[3] = height;
 449 
 450     surfaceCreationFailed = JNI_FALSE;
 451     EXEC_WITH_XERROR_HANDLER(
 452         GLXSD_BadAllocXErrHandler,
 453         pbuffer = j2d_glXCreatePbuffer(awt_display,
 454                                        glxinfo->fbconfig, attrlist));
 455     if ((pbuffer == 0) || surfaceCreationFailed) {
 456         J2dRlsTraceLn(J2D_TRACE_ERROR,
 457             "GLXSurfaceData_initPbuffer: could not create glx pbuffer");
 458         return JNI_FALSE;
 459     }
 460 
 461     oglsdo->drawableType = OGLSD_PBUFFER;
 462     oglsdo->isOpaque = isOpaque;
 463     oglsdo->width = width;
 464     oglsdo->height = height;
 465     oglsdo->xOffset = 0;
 466     oglsdo->yOffset = 0;
 467 
 468     glxsdo->drawable = pbuffer;
 469     glxsdo->xdrawable = 0;
 470 
 471     OGLSD_SetNativeDimensions(env, oglsdo, width, height);
 472 
 473     return JNI_TRUE;
 474 }
 475 
 476 void
 477 OGLSD_SwapBuffers(JNIEnv *env, jlong window)
 478 {
 479     J2dTraceLn(J2D_TRACE_INFO, "OGLSD_SwapBuffers");
 480 
 481     if (window == 0L) {
 482         J2dRlsTraceLn(J2D_TRACE_ERROR,
 483                       "OGLSD_SwapBuffers: window is null");
 484         return;
 485     }
 486 
 487     j2d_glXSwapBuffers(awt_display, (Window)window);
 488 }
 489 
 490 #endif /* !HEADLESS */
--- EOF ---