/*

 * Copyright (c) 2010, 2011, 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 "X11SurfaceData.h"

#include <jni.h>

#include <math.h>

#include "Region.h"

#include "fontscalerdefs.h"

#include <X11/extensions/Xrender.h>

#ifdef __linux__

    #include <sys/utsname.h>

#endif

/* On Solaris 10 updates 8, 9, the render.h file defines these

 * protocol values but does not define the structs in Xrender.h.

 * Thus in order to get these always defined on Solaris 10

 * we will undefine the symbols if we have determined via the

 * makefiles that Xrender.h is lacking the structs. This will

 * trigger providing our own definitions as on earlier updates.

 * We could assume that *all* Solaris 10 update versions will lack the updated

 * Xrender.h and do this based solely on O/S being any 5.10 version, but this

 * could still change and we'd be broken again as we'd be re-defining them.

 */

#ifdef SOLARIS10_NO_XRENDER_STRUCTS

#undef X_RenderCreateLinearGradient

#undef X_RenderCreateRadialGradient

#endif

#ifndef X_RenderCreateLinearGradient

typedef struct _XLinearGradient {

    XPointFixed p1;

    XPointFixed p2;

} XLinearGradient;

#endif

#ifndef X_RenderCreateRadialGradient

typedef struct _XCircle {

    XFixed x;

    XFixed y;

    XFixed radius;

} XCircle;

typedef struct _XRadialGradient {

    XCircle inner;

    XCircle outer;

} XRadialGradient;

#endif

#include <dlfcn.h>

#ifdef __solaris__

/* Solaris 10 will not have these symbols at runtime */

typedef Picture (*XRenderCreateLinearGradientFuncType)

                                     (Display *dpy,

                                     const XLinearGradient *gradient,

                                     const XFixed *stops,

                                     const XRenderColor *colors,

                                     int nstops);

typedef Picture (*XRenderCreateRadialGradientFuncType)

                                     (Display *dpy,

                                     const XRadialGradient *gradient,

                                     const XFixed *stops,

                                     const XRenderColor *colors,

                                     int nstops);

static

XRenderCreateLinearGradientFuncType XRenderCreateLinearGradientFunc = NULL;

static

 XRenderCreateRadialGradientFuncType XRenderCreateRadialGradientFunc = NULL;

#endif

#define BUILD_TRANSFORM_MATRIX(TRANSFORM, M00, M01, M02, M10, M11, M12)                        \

    {                                                                                          \

      TRANSFORM.matrix[0][0] = M00;                                                            \

      TRANSFORM.matrix[0][1] = M01;                                                            \

      TRANSFORM.matrix[0][2] = M02;                                                            \

      TRANSFORM.matrix[1][0] = M10;                                                            \

      TRANSFORM.matrix[1][1] = M11;                                                            \

      TRANSFORM.matrix[1][2] = M12;                                                            \

      TRANSFORM.matrix[2][0] = 0;                                                              \

      TRANSFORM.matrix[2][1] = 0;                                                              \

      TRANSFORM.matrix[2][2] = 1<<16;                                                          \

    }

/* The xrender pipleine requires libXrender.so version 0.9.3 or later. */

#define REQUIRED_XRENDER_VER1 0

#define REQUIRED_XRENDER_VER2 9

#define REQUIRED_XRENDER_VER3 3

#define PKGINFO_LINE_LEN_MAX 256

#define PKGINFO_LINE_CNT_MAX 50

/*

 * X protocol uses (u_int16)length to specify the length in 4 bytes quantities

 * of the whole request.  Both XRenderFillRectangles() and XFillRectangles()

 * have provisions to fragment into several requests if the number of rectangles

 * plus the current x request does not fit into 65535*4 bytes.  While

 * XRenderCreateLinearGradient() and XRenderCreateRadialGradient() have

 * provisions to gracefully degrade if the resulting request would exceed

 * 65535*4 bytes.

 *

 * Below, we define a cap of 65535*4 bytes for the maximum X request payload

 * allowed for Non-(XRenderFillRectangles() or XFillRectangles()) API calls,

 * just to be conservative.  This is offset by the size of our maximum x*Req

 * type in this compilation unit, which is xRenderCreateRadiaGradientReq.

 *

 * Note that sizeof(xRenderCreateRadiaGradientReq) = 36

 */

#define MAX_PAYLOAD (262140u - 36u)

#define MAXUINT (0xffffffffu)

static jboolean IsXRenderAvailable(jboolean verbose, jboolean ignoreLinuxVersion) {

    void *xrenderlib;

    int major_opcode, first_event, first_error;

    jboolean available = JNI_TRUE;

    if (!XQueryExtension(awt_display, "RENDER",

                         &major_opcode, &first_event, &first_error)) {

        return JNI_FALSE;

    }

#ifdef __solaris__

    xrenderlib = dlopen("libXrender.so",RTLD_GLOBAL|RTLD_LAZY);

    if (xrenderlib != NULL) {

      XRenderCreateLinearGradientFunc =

        (XRenderCreateLinearGradientFuncType)

        dlsym(xrenderlib, "XRenderCreateLinearGradient");

      XRenderCreateRadialGradientFunc =

        (XRenderCreateRadialGradientFuncType)

        dlsym(xrenderlib, "XRenderCreateRadialGradient");

      if (XRenderCreateLinearGradientFunc == NULL ||

          XRenderCreateRadialGradientFunc == NULL)

      {

        available = JNI_FALSE;

      }

      dlclose(xrenderlib);

    } else {

      available = JNI_FALSE;

    }

#else

    Dl_info info;

    jboolean versionInfoIsFound = JNI_FALSE;

    memset(&info, 0, sizeof(Dl_info));

    if (dladdr(&XRenderChangePicture, &info) && info.dli_fname != NULL) {

      char pkgInfoPath[FILENAME_MAX];

      char *pkgFileName = "/pkgconfig/xrender.pc";

      size_t pkgFileNameLen = strlen(pkgFileName);

      size_t pos, len = strlen(info.dli_fname);

      pos = len;

      while (pos > 0 && info.dli_fname[pos] != '/') {

        pos -= 1;

      }

      if (pos > 0 && pos < (FILENAME_MAX - pkgFileNameLen - 1)) {

        struct stat stat_info;

        // compose absolute filename to package config

        strncpy(pkgInfoPath, info.dli_fname, pos);

        strcpy(pkgInfoPath + pos, pkgFileName);

        pkgInfoPath[pos + pkgFileNameLen] = '\0';

        // check whether the config file exist and is a regular file

        if ((stat(pkgInfoPath, &stat_info)== 0) &&

            S_ISREG(stat_info.st_mode))

        {

          FILE *fp = fopen(pkgInfoPath, "r");

          if (fp != NULL) {

            char line[PKGINFO_LINE_LEN_MAX];

            int lineCount = PKGINFO_LINE_CNT_MAX;

            char *versionPrefix = "Version: ";

            size_t versionPrefixLen = strlen(versionPrefix);

            // look for version

            while(fgets(line,sizeof(line),fp) != NULL && --lineCount > 0) {

              size_t lineLen = strlen(line);

              if (lineLen > versionPrefixLen &&

                  strncmp(versionPrefix, line, versionPrefixLen) == 0)

              {

                int v1 = 0, v2 = 0, v3 = 0;

                int numNeeded = 3,numProcessed;

                char* version = line + versionPrefixLen;

                numProcessed = sscanf(version, "%d.%d.%d", &v1, &v2, &v3);

                if (numProcessed == numNeeded) {

                  // we successfuly read the library version

                  versionInfoIsFound = JNI_TRUE;

                  if (REQUIRED_XRENDER_VER1 == v1 &&

                      ((REQUIRED_XRENDER_VER2 > v2) ||

                       ((REQUIRED_XRENDER_VER2 == v2) && (REQUIRED_XRENDER_VER3 > v3))))

                  {

                    available = JNI_FALSE;

                    if (verbose) {

                      printf("INFO: the version %d.%d.%d of libXrender.so is "

                             "not supported.\n\tSee release notes for more details.\n",

                             v1, v2, v3);

                      fflush(stdout);

                    }

                  } else {

                    if (verbose) {

                      printf("INFO: The version of libXrender.so "

                             "is detected as %d.%d%d\n", v1, v2, v3);

                      fflush(stdout);

                    }

                  }

                }

                break;

              }

            }

            fclose(fp);

          }

        }

      }

    }

    if (verbose && !versionInfoIsFound) {

      printf("WARNING: The version of libXrender.so cannot be detected.\n,"

             "The pipe line will be enabled, but note that versions less than 0.9.3\n"

             "may cause hangs and crashes\n"

             "\tSee the release notes for more details.\n");

      fflush(stdout);

    }

#endif

#ifdef __linux__

    /*

     * Check for Linux >= 3.5 (Ubuntu 12.04.02 LTS) to avoid hitting

     * https://bugs.freedesktop.org/show_bug.cgi?id=48045

     */

    struct utsname utsbuf;

    if(uname(&utsbuf) >= 0) {

        int major, minor, revision;

        if(sscanf(utsbuf.release, "%i.%i.%i", &major, &minor, &revision) == 3) {

            if(major < 3 || (major == 3 && minor < 5)) {

                if(!ignoreLinuxVersion) {

                    available = JNI_FALSE;

                }

                else if(verbose) {

                 printf("WARNING: Linux < 3.5 detected.\n"

                        "The pipeline will be enabled, but graphical "

                        "artifacts can occur with old graphic drivers.\n"

                        "See the release notes for more details.\n");

                        fflush(stdout);

                }

            }

        }

    }

#endif // __linux__

    return available;

}

/*

 * Class:     sun_awt_X11GraphicsEnvironment

 * Method:    initGLX

 * Signature: ()Z

 */

JNIEXPORT jboolean JNICALL

Java_sun_awt_X11GraphicsEnvironment_initXRender

(JNIEnv *env, jclass x11ge, jboolean verbose, jboolean ignoreLinuxVersion)

{

#ifndef HEADLESS

    static jboolean xrenderAvailable = JNI_FALSE;

    static jboolean firstTime = JNI_TRUE;

    if (firstTime) {

#ifdef DISABLE_XRENDER_BY_DEFAULT

        if (verbose == JNI_FALSE) {

            xrenderAvailable = JNI_FALSE;

            firstTime = JNI_FALSE;

            return xrenderAvailable;

        }

#endif

        AWT_LOCK();

        xrenderAvailable = IsXRenderAvailable(verbose, ignoreLinuxVersion);

        AWT_UNLOCK();

        firstTime = JNI_FALSE;

    }

    return xrenderAvailable;

#else

    return JNI_FALSE;

#endif /* !HEADLESS */

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_initIDs(JNIEnv *env, jclass cls) {

    char *maskData;

    XImage* defaultImg;

    jfieldID maskImgID;

    jlong fmt8;

    jlong fmt32;

    jfieldID a8ID = (*env)->GetStaticFieldID(env, cls, "FMTPTR_A8", "J");

    if (a8ID == NULL) {

        return;

    }

    jfieldID argb32ID = (*env)->GetStaticFieldID(env, cls, "FMTPTR_ARGB32", "J");

    if (argb32ID == NULL) {

        return;

    }

    if (awt_display == (Display *)NULL) {

        return;

    }

    fmt8 = ptr_to_jlong(XRenderFindStandardFormat(awt_display, PictStandardA8));

    fmt32 = ptr_to_jlong(XRenderFindStandardFormat(awt_display, PictStandardARGB32));

    (*env)->SetStaticLongField(env, cls, a8ID, fmt8);

    (*env)->SetStaticLongField(env, cls, argb32ID, fmt32);

    maskData = (char *) malloc(32*32);

    if (maskData == NULL) {

       return;

    }

    defaultImg = XCreateImage(awt_display, NULL, 8, ZPixmap, 0, maskData, 32, 32, 8, 0);

    defaultImg->data = maskData; //required?

    maskImgID = (*env)->GetStaticFieldID(env, cls, "MASK_XIMG", "J");

    if (maskImgID == NULL) {

       return;

    }

    (*env)->SetStaticLongField(env, cls, maskImgID, ptr_to_jlong(defaultImg));

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_freeGC

 (JNIEnv *env, jobject this, jlong gc) {

    XFreeGC(awt_display, (GC) jlong_to_ptr(gc));

}

JNIEXPORT jlong JNICALL

Java_sun_java2d_xr_XRBackendNative_createGC

 (JNIEnv *env, jobject this, jint drawable) {

  GC xgc = XCreateGC(awt_display, (Drawable) drawable, 0L, NULL);

  return ptr_to_jlong(xgc);

}

JNIEXPORT jint JNICALL

Java_sun_java2d_xr_XRBackendNative_createPixmap(JNIEnv *env, jobject this,

                                                jint drawable, jint depth,

                                                jint width, jint height) {

    return (jint) XCreatePixmap(awt_display, (Drawable) drawable,

                                width, height, depth);

}

JNIEXPORT jint JNICALL

Java_sun_java2d_xr_XRBackendNative_createPictureNative

 (JNIEnv *env, jclass cls, jint drawable, jlong formatPtr) {

  XRenderPictureAttributes pict_attr;

  return XRenderCreatePicture(awt_display, (Drawable) drawable,

                              (XRenderPictFormat *) jlong_to_ptr(formatPtr),

                               0, &pict_attr);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_freePicture

 (JNIEnv *env, jobject this, jint picture) {

      XRenderFreePicture(awt_display, (Picture) picture);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_freePixmap

 (JNIEnv *env, jobject this, jint pixmap) {

   XFreePixmap(awt_display, (Pixmap) pixmap);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_setPictureRepeat

 (JNIEnv *env, jobject this, jint picture, jint repeat) {

    XRenderPictureAttributes pict_attr;

    pict_attr.repeat = repeat;

    XRenderChangePicture (awt_display, (Picture) picture, CPRepeat, &pict_attr);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_setGCExposures

 (JNIEnv *env, jobject this, jlong gc, jboolean exposure) {

    XSetGraphicsExposures(awt_display,

                         (GC) jlong_to_ptr(gc), exposure ? True : False); //TODO: ????

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_setGCForeground

 (JNIEnv *env, jobject this, jlong gc, jint pixel) {

    XSetForeground(awt_display, (GC) jlong_to_ptr(gc), (unsigned long) pixel);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_copyArea

 (JNIEnv *env, jobject this, jint src, jint dst, jlong gc,

  jint srcx, jint srcy, jint width, jint height, jint dstx, jint dsty) {

    XCopyArea(awt_display, (Drawable) src, (Drawable) dst,

             (GC) jlong_to_ptr(gc), srcx, srcy, width, height, dstx, dsty);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_renderComposite

 (JNIEnv *env, jobject this, jbyte op, jint src, jint mask, jint dst,

  jint srcX, jint srcY, jint maskX, jint maskY,

  jint dstX, jint dstY, jint width, jint height) {

    XRenderComposite (awt_display, op,

                      (Picture)src, (Picture)mask, (Picture)dst,

                       srcX, srcY, maskX, maskY, dstX, dstY, width, height);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_renderRectangle

 (JNIEnv *env, jobject this, jint dst, jbyte op,

  jshort red, jshort green, jshort blue, jshort alpha,

  jint x, jint y, jint width, jint height) {

    XRenderColor color;

    color.alpha = alpha;

    color.red = red;

    color.green = green;

    color.blue = blue;

    XRenderFillRectangle(awt_display, op, (Picture) dst, &color,

                         x, y, width, height);

}

JNIEXPORT void JNICALL

Java_sun_java2d_xr_XRBackendNative_XRenderRectanglesNative

 (JNIEnv *env, jclass xsd, jint dst, jbyte op,

  jshort red, jshort green, jshort blue, jshort alpha,

  jintArray rectArray, jint rectCnt) {

    int i;

    jint* rects;

    XRectangle *xRects;

    XRectangle sRects[256];

    XRenderColor color;

    color.alpha = alpha;

    color.red = red;

    color.green = green;

    color.blue = blue;

    if (rectCnt <= 256) {

        xRects = &sRects[0];

    } else {

        if (MAXUINT / sizeof(XRectangle) < (unsigned)rectCnt) {

            /* rectCnt too big, integer overflow */

            return;

        }

        xRects = (XRectangle *) malloc(sizeof(XRectangle) * rectCnt);

        if (xRects == NULL) {

            return;

        }

    }

    if ((rects = (jint *)

         (*env)->GetPrimitiveArrayCritical(env, rectArray, NULL)) == NULL) {

        if (xRects != &sRects[0]) {

            free(xRects);

        }

        return;

    }

    for (i=0; i < rectCnt; i++) {

        xRects[i].x = rects[i*4 + 0];

        xRects[i].y = rects[i*4 + 1];

        xRects[i].width = rects[i*4 + 2];

        xRects[i].height = rects[i*4 + 3];

    }

    XRenderFillRectangles(awt_display, op,

                          (Picture) dst, &color, xRects, rectCnt);

    (*env)->ReleasePrimitiveArrayCritical(env, rectArray, rects, JNI_ABORT);

    if (xRects != &sRects[0]) {

        free(xRects);

    }