/*

 * Copyright (c) 1999, 2013, 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 "GraphicsPrimitiveMgr.h"

#include "Region.h"

#include "Trace.h"

/* Needed to define intptr_t */

#include "gdefs.h"

#include "jni_util.h"

#include "jvm_md.h"

#include "awt_Component.h"

#include "awt_GraphicsEnv.h"

#include <dlfcn.h>

#ifndef HEADLESS

/**

 * This file contains support code for loops using the SurfaceData

 * interface to talk to an X11 drawable from native code.

 */

typedef struct _X11RIPrivate {

    jint                lockType;

    jint                lockFlags;

    XImage              *img;

    int                 x, y;

} X11RIPrivate;

#define XSD_MAX(a,b) ((a) > (b) ? (a) : (b))

#define XSD_MIN(a,b) ((a) < (b) ? (a) : (b))

static LockFunc X11SD_Lock;

static GetRasInfoFunc X11SD_GetRasInfo;

static UnlockFunc X11SD_Unlock;

static DisposeFunc X11SD_Dispose;

static GetPixmapBgFunc X11SD_GetPixmapWithBg;

static ReleasePixmapBgFunc X11SD_ReleasePixmapWithBg;

extern int XShmAttachXErrHandler(Display *display, XErrorEvent *xerr);

extern AwtGraphicsConfigDataPtr

    getGraphicsConfigFromComponentPeer(JNIEnv *env, jobject this);

extern struct X11GraphicsConfigIDs x11GraphicsConfigIDs;

static int X11SD_FindClip(SurfaceDataBounds *b, SurfaceDataBounds *bounds,

                          X11SDOps *xsdo);

static int X11SD_ClipToRoot(SurfaceDataBounds *b, SurfaceDataBounds *bounds,

                            X11SDOps *xsdo);

static void X11SD_SwapBytes(X11SDOps *xsdo, XImage *img, int depth, int bpp);

static XImage * X11SD_GetImage(JNIEnv *env, X11SDOps *xsdo,

                               SurfaceDataBounds *bounds,

                               jint lockFlags);

extern jfieldID validID;

static int nativeByteOrder;

static jclass xorCompClass;

jint useMitShmExt = CANT_USE_MITSHM;

jint useMitShmPixmaps = CANT_USE_MITSHM;

jint forceSharedPixmaps = JNI_FALSE;

int mitShmPermissionMask = MITSHM_PERM_OWNER;

/* Cached shared image, one for all surface datas. */

static XImage * cachedXImage;

#endif /* !HEADLESS */

jboolean XShared_initIDs(JNIEnv *env, jboolean allowShmPixmaps)

{

#ifndef HEADLESS

   union {

        char c[4];

        int i;

    } endian;

    endian.i = 0xff000000;

    nativeByteOrder = (endian.c[0]) ? MSBFirst : LSBFirst;

    cachedXImage = NULL;

    if (sizeof(X11RIPrivate) > SD_RASINFO_PRIVATE_SIZE) {

        JNU_ThrowInternalError(env, "Private RasInfo structure too large!");

        return JNI_FALSE;

    }

#ifdef MITSHM

    if (getenv("NO_AWT_MITSHM") == NULL &&

        getenv("NO_J2D_MITSHM") == NULL) {

        char * force;

        char * permission = getenv("J2D_MITSHM_PERMISSION");

        if (permission != NULL) {

            if (strcmp(permission, "common") == 0) {

                mitShmPermissionMask = MITSHM_PERM_COMMON;

            }

        }

        TryInitMITShm(env, &useMitShmExt, &useMitShmPixmaps);

        if(allowShmPixmaps) {

          useMitShmPixmaps = (useMitShmPixmaps == CAN_USE_MITSHM);

          force = getenv("J2D_PIXMAPS");

          if (force != NULL) {

              if (useMitShmPixmaps && (strcmp(force, "shared") == 0)) {

                  forceSharedPixmaps = JNI_TRUE;

              } else if (strcmp(force, "server") == 0) {

                  useMitShmPixmaps = JNI_FALSE;

              }

          }

        }else {

          useMitShmPixmaps = JNI_FALSE;

        }

    }

#endif /* MITSHM */

#endif /* !HEADLESS */

    return JNI_TRUE;

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    initIDs

 * Signature: (Ljava/lang/Class;Z)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_x11_X11SurfaceData_initIDs(JNIEnv *env, jclass xsd,

                                           jclass XORComp)

{

#ifndef HEADLESS

  if(XShared_initIDs(env, JNI_TRUE))

  {

    xorCompClass = (*env)->NewGlobalRef(env, XORComp);

  }

#endif /* !HEADLESS */

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    isDrawableValid

 * Signature: ()Z

 */

JNIEXPORT jboolean JNICALL

Java_sun_java2d_x11_XSurfaceData_isDrawableValid(JNIEnv *env, jobject this)

{

    jboolean ret = JNI_FALSE;

#ifndef HEADLESS

    X11SDOps *xsdo = X11SurfaceData_GetOps(env, this);

    AWT_LOCK();

    if (xsdo->drawable != 0 || X11SD_InitWindow(env, xsdo) == SD_SUCCESS) {

        ret = JNI_TRUE;

    }

    AWT_UNLOCK();

#endif /* !HEADLESS */

    return ret;

}

/*

 * Class: sun_java2d_x11_X11SurfaceData

 * Method: isShmPMAvailable

 * Signature: ()Z

 */

JNIEXPORT jboolean JNICALL

Java_sun_java2d_x11_X11SurfaceData_isShmPMAvailable(JNIEnv *env, jobject this)

{

#if defined(HEADLESS) || !defined(MITSHM)

    return JNI_FALSE;

#else

    return (jboolean)useMitShmPixmaps;

#endif /* HEADLESS, MITSHM */

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    initOps

 * Signature: (Ljava/lang/Object;I)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_x11_XSurfaceData_initOps(JNIEnv *env, jobject xsd,

                                           jobject peer,

                                           jobject graphicsConfig, jint depth)

{

#ifndef HEADLESS

    X11SDOps *xsdo = (X11SDOps*)SurfaceData_InitOps(env, xsd, sizeof(X11SDOps));

    jboolean hasException;

    if (xsdo == NULL) {

        JNU_ThrowOutOfMemoryError(env, "Initialization of SurfaceData failed.");

        return;

    }

    xsdo->sdOps.Lock = X11SD_Lock;

    xsdo->sdOps.GetRasInfo = X11SD_GetRasInfo;

    xsdo->sdOps.Unlock = X11SD_Unlock;

    xsdo->sdOps.Dispose = X11SD_Dispose;

    xsdo->GetPixmapWithBg = X11SD_GetPixmapWithBg;

    xsdo->ReleasePixmapWithBg = X11SD_ReleasePixmapWithBg;

    if (peer != NULL) {

        xsdo->drawable = JNU_CallMethodByName(env, &hasException, peer, "getWindow", "()J").j;

        if (hasException) {

            return;

        }

    } else {

        xsdo->drawable = 0;

    }

    xsdo->depth = depth;

    xsdo->isPixmap = JNI_FALSE;

    xsdo->bitmask = 0;

    xsdo->bgPixel = 0;

    xsdo->isBgInitialized = JNI_FALSE;

#ifdef MITSHM

    xsdo->shmPMData.shmSegInfo = NULL;

    xsdo->shmPMData.xRequestSent = JNI_FALSE;

    xsdo->shmPMData.pmSize = 0;

    xsdo->shmPMData.usingShmPixmap = JNI_FALSE;

    xsdo->shmPMData.pixmap = 0;

    xsdo->shmPMData.shmPixmap = 0;

    xsdo->shmPMData.numBltsSinceRead = 0;

    xsdo->shmPMData.pixelsReadSinceBlt = 0;

    xsdo->shmPMData.numBltsThreshold = 2;

#endif /* MITSHM */

    xsdo->configData = (AwtGraphicsConfigDataPtr)

        JNU_GetLongFieldAsPtr(env,

                              graphicsConfig,

                              x11GraphicsConfigIDs.aData);

    if (xsdo->configData == NULL) {

        JNU_ThrowNullPointerException(env,

                                      "Native GraphicsConfig data block missing");

        return;

    }

    if (depth > 12) {

        xsdo->pixelmask = (xsdo->configData->awt_visInfo.red_mask |

                           xsdo->configData->awt_visInfo.green_mask |

                           xsdo->configData->awt_visInfo.blue_mask);

    } else if (depth == 12) {

        xsdo->pixelmask = 0xfff;

    } else {

        xsdo->pixelmask = 0xff;

    }

    xsdo->xrPic = None;

#endif /* !HEADLESS */

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    flushNativeSurface

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_x11_XSurfaceData_flushNativeSurface(JNIEnv *env, jobject xsd)

{

#ifndef HEADLESS

    SurfaceDataOps *ops = SurfaceData_GetOps(env, xsd);

    if (ops != NULL) {

        X11SD_Dispose(env, ops);

    }

#endif /* !HEADLESS */

}

JNIEXPORT X11SDOps * JNICALL

X11SurfaceData_GetOps(JNIEnv *env, jobject sData)

{

#ifdef HEADLESS

    return NULL;

#else

    SurfaceDataOps *ops = SurfaceData_GetOps(env, sData);

    if (ops != NULL && ops->Lock != X11SD_Lock) {

        SurfaceData_ThrowInvalidPipeException(env, "not an X11 SurfaceData");

        ops = NULL;

    }

    return (X11SDOps *) ops;

#endif /* !HEADLESS */

}

/*

 * Method for disposing X11SD-specific data

 */

static void

X11SD_Dispose(JNIEnv *env, SurfaceDataOps *ops)

{

#ifndef HEADLESS

    /* ops is assumed non-null as it is checked in SurfaceData_DisposeOps */

    X11SDOps * xsdo = (X11SDOps*)ops;

    AWT_LOCK();

    xsdo->invalid = JNI_TRUE;

    if (xsdo->xrPic != None) {

        XRenderFreePicture(awt_display, xsdo->xrPic);

        xsdo->xrPic = None;

     }

    if (xsdo->isPixmap == JNI_TRUE && xsdo->drawable != 0) {

#ifdef MITSHM

        if (xsdo->shmPMData.shmSegInfo != NULL) {

            X11SD_DropSharedSegment(xsdo->shmPMData.shmSegInfo);

            xsdo->shmPMData.shmSegInfo = NULL;

        }

        if (xsdo->shmPMData.pixmap) {

            XFreePixmap(awt_display, xsdo->shmPMData.pixmap);

            xsdo->shmPMData.pixmap = 0;

        }

        if (xsdo->shmPMData.shmPixmap) {

            XFreePixmap(awt_display, xsdo->shmPMData.shmPixmap);

            xsdo->shmPMData.shmPixmap = 0;

        }

#else

        XFreePixmap(awt_display, xsdo->drawable);

#endif /* MITSHM */

        xsdo->drawable = 0;

    }

    if (xsdo->bitmask != 0) {

        XFreePixmap(awt_display, xsdo->bitmask);

        xsdo->bitmask = 0;

    }

    if (xsdo->javaGC != NULL) {

        XFreeGC(awt_display, xsdo->javaGC);

        xsdo->javaGC = NULL;

    }

    if (xsdo->cachedGC != NULL) {

        XFreeGC(awt_display, xsdo->cachedGC);

        xsdo->cachedGC = NULL;

    }

    if(xsdo->xrPic != None) {

      XRenderFreePicture(awt_display, xsdo->xrPic);

    }

    AWT_UNLOCK();

#endif /* !HEADLESS */

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    setInvalid

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_x11_XSurfaceData_setInvalid(JNIEnv *env, jobject xsd)

{

#ifndef HEADLESS

    X11SDOps *xsdo = (X11SDOps *) SurfaceData_GetOps(env, xsd);

    if (xsdo != NULL) {

        xsdo->invalid = JNI_TRUE;

    }

#endif /* !HEADLESS */

}

jboolean XShared_initSurface(JNIEnv *env, X11SDOps *xsdo, jint depth, jint width, jint height, jlong drawable)

{

#ifndef HEADLESS

    if (drawable != (jlong)0) {

        /* Double-buffering */

        xsdo->drawable = drawable;

        xsdo->isPixmap = JNI_FALSE;

    } else {

        /*

         * width , height must be nonzero otherwise XCreatePixmap

         * generates BadValue in error_handler

         */

        if (width <= 0 || height <= 0 || width > 32767 || height > 32767) {

            JNU_ThrowOutOfMemoryError(env,

                                  "Can't create offscreen surface");

            return JNI_FALSE;

        }

        xsdo->isPixmap = JNI_TRUE;

        xsdo->pmWidth = width;

        xsdo->pmHeight = height;

#ifdef MITSHM

        xsdo->shmPMData.pmSize = width * height * depth;

        xsdo->shmPMData.pixelsReadThreshold = width * height / 8;

        if (forceSharedPixmaps) {

            AWT_LOCK();

            xsdo->drawable = X11SD_CreateSharedPixmap(xsdo);

            AWT_UNLOCK();

            JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE);

            if (xsdo->drawable) {

                xsdo->shmPMData.usingShmPixmap = JNI_TRUE;

                xsdo->shmPMData.shmPixmap = xsdo->drawable;

                return JNI_TRUE;

            }

        }

#endif /* MITSHM */

        AWT_LOCK();

        xsdo->drawable =

            XCreatePixmap(awt_display,

                          RootWindow(awt_display,

                                     xsdo->configData->awt_visInfo.screen),

                          width, height, depth);

        AWT_UNLOCK();

        JNU_CHECK_EXCEPTION_RETURN(env, JNI_FALSE);

#ifdef MITSHM

        xsdo->shmPMData.usingShmPixmap = JNI_FALSE;

        xsdo->shmPMData.pixmap = xsdo->drawable;

#endif /* MITSHM */

    }

    if (xsdo->drawable == 0) {

        JNU_ThrowOutOfMemoryError(env,

                                  "Can't create offscreen surface");

        return JNI_FALSE;

    }

#endif /* !HEADLESS */

    return JNI_TRUE;

}

/*

 * Class:     sun_java2d_x11_X11SurfaceData

 * Method:    initSurface

 * Signature: ()V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_x11_X11SurfaceData_initSurface(JNIEnv *env, jclass xsd,

                                               jint depth,

                                               jint width, jint height,

                                               jlong drawable)

{

#ifndef HEADLESS

    X11SDOps *xsdo = X11SurfaceData_GetOps(env, xsd);

    if (xsdo == NULL) {

        return;

    }

    if (xsdo->configData->awt_cmap == (Colormap)NULL) {

        awtJNI_CreateColorData(env, xsdo->configData, 1);

        JNU_CHECK_EXCEPTION(env);

    }

    /* color_data will be initialized in awtJNI_CreateColorData for

       8-bit visuals */

    xsdo->cData = xsdo->configData->color_data;

    XShared_initSurface(env, xsdo, depth, width, height, drawable);

    xsdo->xrPic = None;

#endif /* !HEADLESS */

}

#ifndef HEADLESS

#ifdef MITSHM

void X11SD_DropSharedSegment(XShmSegmentInfo *shminfo)

{

    if (shminfo != NULL) {

        XShmDetach(awt_display, shminfo);

        shmdt(shminfo->shmaddr);

/*      REMIND: we don't need shmctl(shminfo->shmid, IPC_RMID, 0); here. */

/*      Check X11SD_CreateSharedImage() for the explanation */

    }

}

XImage* X11SD_CreateSharedImage(X11SDOps *xsdo,

                                   jint width, jint height)

{

    XImage *img = NULL;

    XShmSegmentInfo *shminfo;

    shminfo = malloc(sizeof(XShmSegmentInfo));

    if (shminfo == NULL) {

        return NULL;

    }

    memset(shminfo, 0, sizeof(XShmSegmentInfo));

    img = XShmCreateImage(awt_display, xsdo->configData->awt_visInfo.visual,

                          xsdo->depth, ZPixmap, NULL, shminfo,

                          width, height);

    if (img == NULL) {

        free((void *)shminfo);

        return NULL;

    }

    shminfo->shmid =

        shmget(IPC_PRIVATE, height * img->bytes_per_line,

               IPC_CREAT|mitShmPermissionMask);