/*
* Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include <stdlib.h>
#include <string.h>
#include "sun_java2d_opengl_GLXGraphicsConfig.h"
#include "jni.h"
#include "jlong.h"
#include "GLXGraphicsConfig.h"
#include "GLXSurfaceData.h"
#include "awt_GraphicsEnv.h"
#include "awt_util.h"
#ifndef HEADLESS
extern Bool usingXinerama;
/**
* This is a globally shared context used when creating textures. When any
* new contexts are created, they specify this context as the "share list"
* context, which means any texture objects created when this shared context
* is current will be available to any other context.
*/
static GLXContext sharedContext = 0;
/**
* Attempts to initialize GLX and the core OpenGL library. For this method
* to return JNI_TRUE, the following must be true:
* - libGL must be loaded successfully (via dlopen)
* - all function symbols from libGL must be available and loaded properly
* - the GLX extension must be available through X11
* - client GLX version must be >= 1.3
* If any of these requirements are not met, this method will return
* JNI_FALSE, indicating there is no hope of using GLX/OpenGL for any
* GraphicsConfig in the environment.
*/
static jboolean
GLXGC_InitGLX()
{
int errorbase, eventbase;
const char *version;
J2dRlsTraceLn(J2D_TRACE_INFO, "GLXGC_InitGLX");
if (!OGLFuncs_OpenLibrary()) {
return JNI_FALSE;
}
if (!OGLFuncs_InitPlatformFuncs() ||
!OGLFuncs_InitBaseFuncs() ||
!OGLFuncs_InitExtFuncs())
{
OGLFuncs_CloseLibrary();
return JNI_FALSE;
}
if (!j2d_glXQueryExtension(awt_display, &errorbase, &eventbase)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitGLX: GLX extension is not present");
OGLFuncs_CloseLibrary();
return JNI_FALSE;
}
version = j2d_glXGetClientString(awt_display, GLX_VERSION);
if (version == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitGLX: could not query GLX version");
OGLFuncs_CloseLibrary();
return JNI_FALSE;
}
// we now only verify that the client GLX version is >= 1.3 (if the
// server does not support GLX 1.3, then we will find that out later
// when we attempt to create a GLXFBConfig)
J2dRlsTraceLn1(J2D_TRACE_INFO,
"GLXGC_InitGLX: client GLX version=%s", version);
if (!((version[0] == '1' && version[2] >= '3') || (version[0] > '1'))) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitGLX: invalid GLX version; 1.3 is required");
OGLFuncs_CloseLibrary();
return JNI_FALSE;
}
return JNI_TRUE;
}
/**
* Returns JNI_TRUE if GLX is available for the current display. Note that
* this method will attempt to initialize GLX (and all the necessary function
* symbols) if it has not been already. The AWT_LOCK must be acquired before
* calling this method.
*/
jboolean
GLXGC_IsGLXAvailable()
{
static jboolean glxAvailable = JNI_FALSE;
static jboolean firstTime = JNI_TRUE;
J2dTraceLn(J2D_TRACE_INFO, "GLXGC_IsGLXAvailable");
if (firstTime) {
glxAvailable = GLXGC_InitGLX();
firstTime = JNI_FALSE;
}
return glxAvailable;
}
/**
* Disposes all memory and resources allocated for the given OGLContext.
*/
static void
GLXGC_DestroyOGLContext(OGLContext *oglc)
{
GLXCtxInfo *ctxinfo;
J2dTraceLn(J2D_TRACE_INFO, "GLXGC_DestroyOGLContext");
if (oglc == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_DestroyOGLContext: context is null");
return;
}
// at this point, this context will be current to its scratch surface
// so the following GL/GLX operations should be safe...
OGLContext_DestroyContextResources(oglc);
ctxinfo = (GLXCtxInfo *)oglc->ctxInfo;
if (ctxinfo != NULL) {
// release the current context before we continue
j2d_glXMakeContextCurrent(awt_display, None, None, NULL);
if (ctxinfo->context != 0) {
j2d_glXDestroyContext(awt_display, ctxinfo->context);
}
if (ctxinfo->scratchSurface != 0) {
j2d_glXDestroyPbuffer(awt_display, ctxinfo->scratchSurface);
}
free(ctxinfo);
}
free(oglc);
}
/**
* Disposes all memory and resources associated with the given
* GLXGraphicsConfigInfo (including its native OGLContext data).
*/
void
OGLGC_DestroyOGLGraphicsConfig(jlong pConfigInfo)
{
GLXGraphicsConfigInfo *glxinfo =
(GLXGraphicsConfigInfo *)jlong_to_ptr(pConfigInfo);
J2dTraceLn(J2D_TRACE_INFO, "OGLGC_DestroyOGLGraphicsConfig");
if (glxinfo == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"OGLGC_DestroyOGLGraphicsConfig: info is null");
return;
}
if (glxinfo->context != NULL) {
GLXGC_DestroyOGLContext(glxinfo->context);
}
free(glxinfo);
}
/**
* Attempts to create a new GLXFBConfig for the requested screen and visual.
* If visualid is 0, this method will iterate through all GLXFBConfigs (if
* any) that match the requested attributes and will attempt to find an
* fbconfig with a minimal combined depth+stencil buffer. Note that we
* currently only need depth capabilities (for shape clipping purposes), but
* glXChooseFBConfig() will often return a list of fbconfigs with the largest
* depth buffer (and stencil) sizes at the top of the list. Therefore, we
* scan through the whole list to find the most VRAM-efficient fbconfig.
* If visualid is non-zero, the GLXFBConfig associated with the given visual
* is chosen (assuming it meets the requested attributes). If there are no
* valid GLXFBConfigs available, this method returns 0.
*/
static GLXFBConfig
GLXGC_InitFBConfig(JNIEnv *env, jint screennum, VisualID visualid)
{
GLXFBConfig *fbconfigs;
GLXFBConfig chosenConfig = 0;
int nconfs, i;
int attrlist[] = {GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT | GLX_PBUFFER_BIT,
GLX_RENDER_TYPE, GLX_RGBA_BIT,
GLX_CONFIG_CAVEAT, GLX_NONE, // avoid "slow" configs
GLX_DEPTH_SIZE, 16, // anything >= 16 will work for us
0};
// this is the initial minimum value for the combined depth+stencil size
// (we initialize it to some absurdly high value; realistic values will
// be much less than this number)
int minDepthPlusStencil = 512;
J2dRlsTraceLn2(J2D_TRACE_INFO, "GLXGC_InitFBConfig: scn=%d vis=0x%x",
screennum, visualid);
// find all fbconfigs for this screen with the provided attributes
fbconfigs = j2d_glXChooseFBConfig(awt_display, screennum,
attrlist, &nconfs);
if ((fbconfigs == NULL) || (nconfs <= 0)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitFBConfig: could not find any valid fbconfigs");
return 0;
}
J2dRlsTraceLn(J2D_TRACE_VERBOSE, " candidate fbconfigs:");
// iterate through the list of fbconfigs, looking for the one that matches
// the requested VisualID and supports RGBA rendering as well as the
// creation of windows and pbuffers
for (i = 0; i < nconfs; i++) {
XVisualInfo *xvi;
VisualID fbvisualid;
GLXFBConfig fbc = fbconfigs[i];
// get VisualID from GLXFBConfig
xvi = j2d_glXGetVisualFromFBConfig(awt_display, fbc);
if (xvi == NULL) {
continue;
}
fbvisualid = xvi->visualid;
XFree(xvi);
if (visualid == 0 || visualid == fbvisualid) {
int dtype, rtype, depth, stencil, db, alpha, gamma;
// get GLX-specific attributes from GLXFBConfig
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_DRAWABLE_TYPE, &dtype);
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_RENDER_TYPE, &rtype);
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_DEPTH_SIZE, &depth);
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_STENCIL_SIZE, &stencil);
// these attributes don't affect our decision, but they are
// interesting for trace logs, so we will query them anyway
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_DOUBLEBUFFER, &db);
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_ALPHA_SIZE, &alpha);
J2dRlsTrace5(J2D_TRACE_VERBOSE,
"[V] id=0x%x db=%d alpha=%d depth=%d stencil=%d valid=",
fbvisualid, db, alpha, depth, stencil);
#ifdef __sparc
/*
* Sun's OpenGL implementation will always
* return at least two GLXFBConfigs (visuals) from
* glXChooseFBConfig(). The first will be a linear (gamma
* corrected) visual; the second will have the same capabilities
* as the first, except it will be a non-linear (non-gamma
* corrected) visual, which is the one we want, otherwise
* everything will look "washed out". So we will reject any
* visuals that have gamma values other than 1.0 (the value
* returned by glXGetFBConfigAttrib() will be scaled
* by 100, so 100 corresponds to a gamma value of 1.0, 220
* corresponds to 2.2, and so on).
*/
j2d_glXGetFBConfigAttrib(awt_display, fbc,
GLX_GAMMA_VALUE_SUN, &gamma);
if (gamma != 100) {
J2dRlsTrace(J2D_TRACE_VERBOSE, "false (linear visual)\n");
continue;
}
#endif /* __sparc */
if ((dtype & GLX_WINDOW_BIT) &&
(dtype & GLX_PBUFFER_BIT) &&
(rtype & GLX_RGBA_BIT) &&
(depth >= 16))
{
if (visualid == 0) {
// when visualid == 0, we loop through all configs
// looking for an fbconfig that has the smallest combined
// depth+stencil size (this keeps VRAM usage to a minimum)
if ((depth + stencil) < minDepthPlusStencil) {
J2dRlsTrace(J2D_TRACE_VERBOSE, "true\n");
minDepthPlusStencil = depth + stencil;
chosenConfig = fbc;
} else {
J2dRlsTrace(J2D_TRACE_VERBOSE,
"false (large depth)\n");
}
continue;
} else {
// in this case, visualid == fbvisualid, which means
// we've found a valid fbconfig corresponding to the
// requested VisualID, so break out of the loop
J2dRlsTrace(J2D_TRACE_VERBOSE, "true\n");
chosenConfig = fbc;
break;
}
} else {
J2dRlsTrace(J2D_TRACE_VERBOSE, "false (bad match)\n");
}
}
}
// free the list of fbconfigs
XFree(fbconfigs);
if (chosenConfig == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitFBConfig: could not find an appropriate fbconfig");
return 0;
}
return chosenConfig;
}
/**
* Returns the X11 VisualID that corresponds to the best GLXFBConfig for the
* given screen. If no valid visual could be found, this method returns zero.
* Note that this method will attempt to initialize GLX (and all the
* necessary function symbols) if it has not been already. The AWT_LOCK
* must be acquired before calling this method.
*/
VisualID
GLXGC_FindBestVisual(JNIEnv *env, jint screen)
{
GLXFBConfig fbc;
XVisualInfo *xvi;
VisualID visualid;
J2dRlsTraceLn1(J2D_TRACE_INFO, "GLXGC_FindBestVisual: scn=%d", screen);
if (!GLXGC_IsGLXAvailable()) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_FindBestVisual: could not initialize GLX");
return 0;
}
fbc = GLXGC_InitFBConfig(env, screen, 0);
if (fbc == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_FindBestVisual: could not find best visual");
return 0;
}
xvi = j2d_glXGetVisualFromFBConfig(awt_display, fbc);
if (xvi == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_FindBestVisual: could not get visual for fbconfig");
return 0;
}
visualid = xvi->visualid;
XFree(xvi);
J2dRlsTraceLn2(J2D_TRACE_INFO,
"GLXGC_FindBestVisual: chose 0x%x as the best visual for screen %d",
visualid, screen);
return visualid;
}
/**
* Creates a scratch pbuffer, which can be used to make a context current
* for extension queries, etc.
*/
static GLXPbuffer
GLXGC_InitScratchPbuffer(GLXFBConfig fbconfig)
{
int pbattrlist[] = {GLX_PBUFFER_WIDTH, 4,
GLX_PBUFFER_HEIGHT, 4,
GLX_PRESERVED_CONTENTS, GL_FALSE,
0};
J2dTraceLn(J2D_TRACE_INFO, "GLXGC_InitScratchPbuffer");
return j2d_glXCreatePbuffer(awt_display, fbconfig, pbattrlist);
}
/**
* Initializes a new OGLContext, which includes the native GLXContext handle
* and some other important information such as the associated GLXFBConfig.
*/
static OGLContext *
GLXGC_InitOGLContext(GLXFBConfig fbconfig, GLXContext context,
GLXPbuffer scratch, jint caps)
{
OGLContext *oglc;
GLXCtxInfo *ctxinfo;
J2dTraceLn(J2D_TRACE_INFO, "GLXGC_InitOGLContext");
oglc = (OGLContext *)malloc(sizeof(OGLContext));
if (oglc == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitOGLContext: could not allocate memory for oglc");
return NULL;
}
memset(oglc, 0, sizeof(OGLContext));
ctxinfo = (GLXCtxInfo *)malloc(sizeof(GLXCtxInfo));
if (ctxinfo == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGC_InitOGLContext: could not allocate memory for ctxinfo");
free(oglc);
return NULL;
}
ctxinfo->fbconfig = fbconfig;
ctxinfo->context = context;
ctxinfo->scratchSurface = scratch;
oglc->ctxInfo = ctxinfo;
oglc->caps = caps;
return oglc;
}
#endif /* !HEADLESS */
/**
* Determines whether the GLX pipeline can be used for a given GraphicsConfig
* provided its screen number and visual ID. If the minimum requirements are
* met, the native GLXGraphicsConfigInfo structure is initialized for this
* GraphicsConfig with the necessary information (GLXFBConfig, etc.)
* and a pointer to this structure is returned as a jlong. If
* initialization fails at any point, zero is returned, indicating that GLX
* cannot be used for this GraphicsConfig (we should fallback on the existing
* X11 pipeline).
*/
JNIEXPORT jlong JNICALL
Java_sun_java2d_opengl_GLXGraphicsConfig_getGLXConfigInfo(JNIEnv *env,
jclass glxgc,
jint screennum,
jint visnum)
{
#ifndef HEADLESS
OGLContext *oglc;
GLXFBConfig fbconfig;
GLXContext context;
GLXPbuffer scratch;
GLXGraphicsConfigInfo *glxinfo;
jint caps = CAPS_EMPTY;
int db;
const unsigned char *versionstr;
J2dRlsTraceLn(J2D_TRACE_INFO, "GLXGraphicsConfig_getGLXConfigInfo");
if (usingXinerama) {
// when Xinerama is enabled, the screen ID needs to be 0
screennum = 0;
}
fbconfig = GLXGC_InitFBConfig(env, screennum, (VisualID)visnum);
if (fbconfig == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: could not create fbconfig");
return 0L;
}
if (sharedContext == 0) {
// create the one shared context
sharedContext = j2d_glXCreateNewContext(awt_display, fbconfig,
GLX_RGBA_TYPE, 0, GL_TRUE);
if (sharedContext == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: could not create shared context");
return 0L;
}
}
// create the GLXContext for this GLXGraphicsConfig
context = j2d_glXCreateNewContext(awt_display, fbconfig,
GLX_RGBA_TYPE, sharedContext,
GL_TRUE);
if (context == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: could not create GLX context");
return 0L;
}
// this is pretty sketchy, but it seems to be the easiest way to create
// some form of GLXDrawable using only the display and a GLXFBConfig
// (in order to make the context current for checking the version,
// extensions, etc)...
scratch = GLXGC_InitScratchPbuffer(fbconfig);
if (scratch == 0) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: could not create scratch pbuffer");
j2d_glXDestroyContext(awt_display, context);
return 0L;
}
// the context must be made current before we can query the
// version and extension strings
j2d_glXMakeContextCurrent(awt_display, scratch, scratch, context);
#ifdef __sparc
/*
* 6438225: The software rasterizer used by Sun's OpenGL libraries
* for certain boards has quality issues, and besides, performance
* of these boards is not high enough to justify the use of the
* OpenGL-based Java 2D pipeline. If we detect one of the following
* boards via the GL_RENDERER string, just give up:
* - FFB[2[+]] ("Creator[3D]")
* - PGX-series ("m64")
* - AFB ("Elite3D")
*/
{
const char *renderer = (const char *)j2d_glGetString(GL_RENDERER);
J2dRlsTraceLn1(J2D_TRACE_VERBOSE,
"GLXGraphicsConfig_getGLXConfigInfo: detected renderer (%s)",
(renderer == NULL) ? "null" : renderer);
if (renderer == NULL ||
strncmp(renderer, "Creator", 7) == 0 ||
strncmp(renderer, "SUNWm64", 7) == 0 ||
strncmp(renderer, "Elite", 5) == 0)
{
J2dRlsTraceLn1(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: unsupported board (%s)",
(renderer == NULL) ? "null" : renderer);
j2d_glXMakeContextCurrent(awt_display, None, None, NULL);
j2d_glXDestroyPbuffer(awt_display, scratch);
j2d_glXDestroyContext(awt_display, context);
return 0L;
}
}
#endif /* __sparc */
versionstr = j2d_glGetString(GL_VERSION);
OGLContext_GetExtensionInfo(env, &caps);
// destroy the temporary resources
j2d_glXMakeContextCurrent(awt_display, None, None, NULL);
J2dRlsTraceLn1(J2D_TRACE_INFO,
"GLXGraphicsConfig_getGLXConfigInfo: OpenGL version=%s",
(versionstr == NULL) ? "null" : (char *)versionstr);
if (!OGLContext_IsVersionSupported(versionstr)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: OpenGL 1.2 is required");
j2d_glXDestroyPbuffer(awt_display, scratch);
j2d_glXDestroyContext(awt_display, context);
return 0L;
}
// get config-specific capabilities
j2d_glXGetFBConfigAttrib(awt_display, fbconfig, GLX_DOUBLEBUFFER, &db);
if (db) {
caps |= CAPS_DOUBLEBUFFERED;
}
// initialize the OGLContext, which wraps the GLXFBConfig and GLXContext
oglc = GLXGC_InitOGLContext(fbconfig, context, scratch, caps);
if (oglc == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"GLXGraphicsConfig_getGLXConfigInfo: could not create oglc");
/**代码未完, 请加载全部代码(NowJava.com).**/