java2d/loops/DrawPolygons.c

/*
 * Copyright (c) 2000, 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 "jni_util.h"

#include "GraphicsPrimitiveMgr.h"
#include "LineUtils.h"

#include "sun_java2d_loops_DrawPolygons.h"

static void
RefineBounds(SurfaceDataBounds *bounds, jint transX, jint transY,
             jint *xPointsPtr, jint *yPointsPtr, jint pointsNeeded)
{
    jint xmin, ymin, xmax, ymax;
    if (pointsNeeded > 0) {
        xmin = xmax = transX + *xPointsPtr++;
        ymin = ymax = transY + *yPointsPtr++;
        while (--pointsNeeded > 0) {
            jint x = transX + *xPointsPtr++;
            jint y = transY + *yPointsPtr++;
            if (xmin > x) xmin = x;
            if (ymin > y) ymin = y;
            if (xmax < x) xmax = x;
            if (ymax < y) ymax = y;
        }
        if (++xmax < xmin) xmax--;
        if (++ymax < ymin) ymax--;
        if (bounds->x1 < xmin) bounds->x1 = xmin;
        if (bounds->y1 < ymin) bounds->y1 = ymin;
        if (bounds->x2 > xmax) bounds->x2 = xmax;
        if (bounds->y2 > ymax) bounds->y2 = ymax;
    } else {
        bounds->x2 = bounds->x1;
        bounds->y2 = bounds->y1;
    }
}

static void
ProcessPoly(SurfaceDataRasInfo *pRasInfo,
            DrawLineFunc *pLine,
            NativePrimitive *pPrim,
            CompositeInfo *pCompInfo,
            jint pixel, jint transX, jint transY,
            jint *xPointsPtr, jint *yPointsPtr,
            jint *nPointsPtr, jint numPolys,
            jboolean close)
{
    int i;
    for (i = 0; i < numPolys; i++) {
        jint numPts = nPointsPtr[i];
        if (numPts > 1) {
            jint x0, y0, x1, y1;
            jboolean empty = JNI_TRUE;
            x0 = x1 = transX + *xPointsPtr++;
            y0 = y1 = transY + *yPointsPtr++;
            while (--numPts > 0) {
                jint x2 = transX + *xPointsPtr++;
                jint y2 = transY + *yPointsPtr++;
                empty = (empty && x1 == x2 && y1 == y2);
                LineUtils_ProcessLine(pRasInfo, pixel, pLine,
                                      pPrim, pCompInfo,
                                      x1, y1, x2, y2,
                                      (numPts > 1 || close));
                x1 = x2;
                y1 = y2;
            }
            if (close && (empty || x1 != x0 || y1 != y0)) {
                LineUtils_ProcessLine(pRasInfo, pixel, pLine,
                                      pPrim, pCompInfo,
                                      x1, y1, x0, y0, !empty);
            }
        } else if (numPts == 1) {
            xPointsPtr++;
            yPointsPtr++;
        }
    }
}

/*
 * Class:     sun_java2d_loops_DrawPolygons
 * Method:    DrawPolygons
 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;[I[I[IIIIZ)V
 */
JNIEXPORT void JNICALL
Java_sun_java2d_loops_DrawPolygons_DrawPolygons
    (JNIEnv *env, jobject self,
     jobject sg2d, jobject sData,
     jintArray xPointsArray, jintArray yPointsArray,
     jintArray nPointsArray, jint numPolys,
     jint transX, jint transY, jboolean close)
{
    SurfaceDataOps *sdOps;
    SurfaceDataRasInfo rasInfo;
    NativePrimitive *pPrim;
    CompositeInfo compInfo;
    jsize nPointsLen, xPointsLen, yPointsLen;
    jint *nPointsPtr = NULL;
    jint *xPointsPtr = NULL;
    jint *yPointsPtr = NULL;
    jint pointsNeeded;
    jint i, ret;
    jboolean ok = JNI_TRUE;
    jint pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    if (JNU_IsNull(env, xPointsArray) || JNU_IsNull(env, yPointsArray)) {
        JNU_ThrowNullPointerException(env, "coordinate array");
        return;
    }
    if (JNU_IsNull(env, nPointsArray)) {
        JNU_ThrowNullPointerException(env, "polygon length array");
        return;
    }

    nPointsLen = (*env)->GetArrayLength(env, nPointsArray);
    xPointsLen = (*env)->GetArrayLength(env, xPointsArray);
    yPointsLen = (*env)->GetArrayLength(env, yPointsArray);
    if (nPointsLen < numPolys) {
        JNU_ThrowArrayIndexOutOfBoundsException(env,
                                                "polygon length array size");
        return;
    }

    pPrim = GetNativePrim(env, self);
    if (pPrim == NULL) {
        return;
    }
    if (pPrim->pCompType->getCompInfo != NULL) {
        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
    }

    sdOps = SurfaceData_GetOps(env, sData);
    if (sdOps == 0) {
        return;
    }

    GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);

    ret = sdOps->Lock(env, sdOps, &rasInfo, SD_LOCK_FASTEST | pPrim->dstflags);
    if (ret == SD_FAILURE) {
        return;
    }

    nPointsPtr = (*env)->GetPrimitiveArrayCritical(env, nPointsArray, NULL);
    if (!nPointsPtr) {
        ok = JNI_FALSE;
    }

    if (ok) {
        pointsNeeded = 0;
        for (i = 0; i < numPolys; i++) {
            if (nPointsPtr[i] > 0) {
                pointsNeeded += nPointsPtr[i];
            }
        }

        if (yPointsLen < pointsNeeded || xPointsLen < pointsNeeded) {
            (*env)->ReleasePrimitiveArrayCritical(env, nPointsArray,
                                                  nPointsPtr, JNI_ABORT);
            SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
            JNU_ThrowArrayIndexOutOfBoundsException(env,
                                                    "coordinate array length");
            return;
        }

        xPointsPtr = (*env)->GetPrimitiveArrayCritical(env, xPointsArray, NULL);
        if (!xPointsPtr) {
            ok = JNI_FALSE;
        }
        if (ok) {
            yPointsPtr = (*env)->GetPrimitiveArrayCritical(env, yPointsArray, NULL);
            if (!yPointsPtr) {
                ok = JNI_FALSE;
            }
        }
    }

    if (ok) {
        if (ret == SD_SLOWLOCK) {
            RefineBounds(&rasInfo.bounds, transX, transY,
                         xPointsPtr, yPointsPtr, pointsNeeded);
            ok = (rasInfo.bounds.x2 > rasInfo.bounds.x1 &&
                  rasInfo.bounds.y2 > rasInfo.bounds.y1);
        }
    }

    if (ok) {
        sdOps->GetRasInfo(env, sdOps, &rasInfo);
        if (rasInfo.rasBase &&
            rasInfo.bounds.x2 > rasInfo.bounds.x1 &&
            rasInfo.bounds.y2 > rasInfo.bounds.y1)
        {
            ProcessPoly(&rasInfo, pPrim->funcs.drawline, pPrim, &compInfo,
                        pixel, transX, transY,
                        xPointsPtr, yPointsPtr,
                        nPointsPtr, numPolys,
                        close);
        }
        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
    }

    if (nPointsPtr) {
        (*env)->ReleasePrimitiveArrayCritical(env, nPointsArray,
                                              nPointsPtr, JNI_ABORT);
    }
    if (xPointsPtr) {
        (*env)->ReleasePrimitiveArrayCritical(env, xPointsArray,
                                              xPointsPtr, JNI_ABORT);
    }
    if (yPointsPtr) {
        (*env)->ReleasePrimitiveArrayCritical(env, yPointsArray,
                                              yPointsPtr, JNI_ABORT);
    }
    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
}