/*

 * 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

{

    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

{

    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);