/*

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

#include "math.h"

#include "string.h"

#include "stdlib.h"

#include "sunfontids.h"

#include "fontscalerdefs.h"

#include "glyphblitting.h"

#include "GraphicsPrimitiveMgr.h"

#include "sun_java2d_loops_DrawGlyphList.h"

#include "sun_java2d_loops_DrawGlyphListAA.h"

/*

 * Need to account for the rare case when (eg) repainting damaged

 * areas results in the drawing location being negative, in which

 * case (int) rounding always goes towards zero. We need to always

 * round down instead, so that we paint at the correct position.

 * We only call "floor" when value is < 0 (ie rarely).

 * Storing the result of (eg) (x+ginfo->topLeftX) benchmarks is more

 * expensive than repeating the calculation as we do here.

 * "floor" shows up as a significant cost in app-level microbenchmarks.

 * This macro avoids calling it on positive values, instead using an

 * (int) cast.

 */

#define FLOOR_ASSIGN(l, r)\

 if ((r)<0) (l) = ((int)floor(r)); else (l) = ((int)(r))

GlyphBlitVector* setupBlitVector(JNIEnv *env, jobject glyphlist) {

    int g;

    size_t bytesNeeded;

    jlong *imagePtrs;

    jfloat* positions = NULL;

    GlyphInfo *ginfo;

    GlyphBlitVector *gbv;

    jfloat x = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListX);

    jfloat y = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListY);

    jint len =  (*env)->GetIntField(env, glyphlist, sunFontIDs.glyphListLen);

    jlongArray glyphImages = (jlongArray)

        (*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphImages);

    jfloatArray glyphPositions =

      (*env)->GetBooleanField(env, glyphlist, sunFontIDs.glyphListUsePos)

        ? (jfloatArray)

      (*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphListPos)

        : NULL;

    bytesNeeded = sizeof(GlyphBlitVector)+sizeof(ImageRef)*len;

    gbv = (GlyphBlitVector*)malloc(bytesNeeded);

    if (gbv == NULL) {

        return NULL;

    }

    gbv->numGlyphs = len;

    gbv->glyphs = (ImageRef*)((unsigned char*)gbv+sizeof(GlyphBlitVector));

    imagePtrs = (*env)->GetPrimitiveArrayCritical(env, glyphImages, NULL);

    if (imagePtrs == NULL) {

        free(gbv);

        return (GlyphBlitVector*)NULL;

    }

    /* Add 0.5 to x and y and then use floor (or an equivalent operation)

     * to round down the glyph positions to integral pixel positions.

     */

    x += 0.5f;

    y += 0.5f;

    if (glyphPositions) {

        int n = -1;

        positions =

          (*env)->GetPrimitiveArrayCritical(env, glyphPositions, NULL);

        if (positions == NULL) {

            (*env)->ReleasePrimitiveArrayCritical(env, glyphImages,

                                                  imagePtrs, JNI_ABORT);

            free(gbv);

            return (GlyphBlitVector*)NULL;

        }

        for (g=0; g<len; g++) {

            jfloat px = x + positions[++n];

            jfloat py = y + positions[++n];

            ginfo = (GlyphInfo*)imagePtrs[g];

            gbv->glyphs[g].glyphInfo = ginfo;

            gbv->glyphs[g].pixels = ginfo->image;

            gbv->glyphs[g].width = ginfo->width;

            gbv->glyphs[g].rowBytes = ginfo->rowBytes;

            gbv->glyphs[g].height = ginfo->height;

            FLOOR_ASSIGN(gbv->glyphs[g].x, px + ginfo->topLeftX);

            FLOOR_ASSIGN(gbv->glyphs[g].y, py + ginfo->topLeftY);

        }

        (*env)->ReleasePrimitiveArrayCritical(env,glyphPositions,

                                              positions, JNI_ABORT);

    } else {

        for (g=0; g<len; g++) {

            ginfo = (GlyphInfo*)imagePtrs[g];

            gbv->glyphs[g].glyphInfo = ginfo;

            gbv->glyphs[g].pixels = ginfo->image;

            gbv->glyphs[g].width = ginfo->width;

            gbv->glyphs[g].rowBytes = ginfo->rowBytes;

            gbv->glyphs[g].height = ginfo->height;

            FLOOR_ASSIGN(gbv->glyphs[g].x, x + ginfo->topLeftX);

            FLOOR_ASSIGN(gbv->glyphs[g].y, y + ginfo->topLeftY);

            /* copy image data into this array at x/y locations */

            x += ginfo->advanceX;

            y += ginfo->advanceY;

        }

    }

    (*env)->ReleasePrimitiveArrayCritical(env, glyphImages, imagePtrs,

                                          JNI_ABORT);

    return gbv;

}

jint RefineBounds(GlyphBlitVector *gbv, SurfaceDataBounds *bounds) {

    int index;

    jint dx1, dy1, dx2, dy2;

    ImageRef glyphImage;

    int num = gbv->numGlyphs;

    SurfaceDataBounds glyphs;

    glyphs.x1 = glyphs.y1 = 0x7fffffff;

    glyphs.x2 = glyphs.y2 = 0x80000000;

    for (index = 0; index < num; index++) {

        glyphImage = gbv->glyphs[index];

        dx1 = (jint) glyphImage.x;

        dy1 = (jint) glyphImage.y;

        dx2 = dx1 + glyphImage.width;

        dy2 = dy1 + glyphImage.height;

        if (glyphs.x1 > dx1) glyphs.x1 = dx1;

        if (glyphs.y1 > dy1) glyphs.y1 = dy1;

        if (glyphs.x2 < dx2) glyphs.x2 = dx2;

        if (glyphs.y2 < dy2) glyphs.y2 = dy2;

    }

    SurfaceData_IntersectBounds(bounds, &glyphs);

    return (bounds->x1 < bounds->x2 && bounds->y1 < bounds->y2);

}

/* since the AA and non-AA loop functions share a common method

 * signature, can call both through this common function since

 * there's no difference except for the inner loop.

 * This could be a macro but there's enough of those already.

 */

static void drawGlyphList(JNIEnv *env, jobject self,

                          jobject sg2d, jobject sData,

                          GlyphBlitVector *gbv, jint pixel, jint color,

                          NativePrimitive *pPrim, DrawGlyphListFunc *func) {

    SurfaceDataOps *sdOps;

    SurfaceDataRasInfo rasInfo;

    CompositeInfo compInfo;

    int clipLeft, clipRight, clipTop, clipBottom;

    int ret;

    sdOps = SurfaceData_GetOps(env, sData);

    if (sdOps == 0) {

        return;

    }

    if (pPrim->pCompType->getCompInfo != NULL) {

        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);

    }

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

    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||

        rasInfo.bounds.x2 <= rasInfo.bounds.x1)

    {

        return;

    }

    ret = sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags);

    if (ret != SD_SUCCESS) {

        if (ret == SD_SLOWLOCK) {

            if (!RefineBounds(gbv, &rasInfo.bounds)) {

                SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

                return;

            }

        } else {

            return;

        }

    }

    sdOps->GetRasInfo(env, sdOps, &rasInfo);

    if (!rasInfo.rasBase) {

        SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

        return;

    }

    clipLeft    = rasInfo.bounds.x1;

    clipRight   = rasInfo.bounds.x2;

    clipTop     = rasInfo.bounds.y1;

    clipBottom  = rasInfo.bounds.y2;

    if (clipRight > clipLeft && clipBottom > clipTop) {

        (*func)(&rasInfo,

                gbv->glyphs, gbv->numGlyphs,

                pixel, color,

                clipLeft, clipTop,

                clipRight, clipBottom,

                pPrim, &compInfo);

        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

    }

    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

}

static unsigned char* getLCDGammaLUT(int gamma);

static unsigned char* getInvLCDGammaLUT(int gamma);

static void drawGlyphListLCD(JNIEnv *env, jobject self,

                          jobject sg2d, jobject sData,

                          GlyphBlitVector *gbv, jint pixel, jint color,

                          jboolean rgbOrder, int contrast,

                          NativePrimitive *pPrim,

                          DrawGlyphListLCDFunc *func) {

    SurfaceDataOps *sdOps;

    SurfaceDataRasInfo rasInfo;

    CompositeInfo compInfo;

    int clipLeft, clipRight, clipTop, clipBottom;

    int ret;

    sdOps = SurfaceData_GetOps(env, sData);

    if (sdOps == 0) {

        return;

    }

    if (pPrim->pCompType->getCompInfo != NULL) {

        GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);

    }

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

    if (rasInfo.bounds.y2 <= rasInfo.bounds.y1 ||

        rasInfo.bounds.x2 <= rasInfo.bounds.x1)

    {

        return;

    }

    ret = sdOps->Lock(env, sdOps, &rasInfo, pPrim->dstflags);

    if (ret != SD_SUCCESS) {

        if (ret == SD_SLOWLOCK) {

            if (!RefineBounds(gbv, &rasInfo.bounds)) {

                SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

                return;

            }

        } else {

            return;

        }

    }

    sdOps->GetRasInfo(env, sdOps, &rasInfo);

    if (!rasInfo.rasBase) {

        SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

        return;

    }

    clipLeft    = rasInfo.bounds.x1;

    clipRight   = rasInfo.bounds.x2;

    clipTop     = rasInfo.bounds.y1;

    clipBottom  = rasInfo.bounds.y2;

    if (clipRight > clipLeft && clipBottom > clipTop) {

        (*func)(&rasInfo,

                gbv->glyphs, gbv->numGlyphs,

                pixel, color,

                clipLeft, clipTop,

                clipRight, clipBottom, (jint)rgbOrder,

                getLCDGammaLUT(contrast), getInvLCDGammaLUT(contrast),

                pPrim, &compInfo);

        SurfaceData_InvokeRelease(env, sdOps, &rasInfo);

    }

    SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);

}

/*

 * Class:     sun_java2d_loops_DrawGlyphList

 * Method:    DrawGlyphList

 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_DrawGlyphList_DrawGlyphList

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData, jobject glyphlist) {

    jint pixel, color;

    GlyphBlitVector* gbv;

    NativePrimitive *pPrim;

    if ((pPrim = GetNativePrim(env, self)) == NULL) {

        return;

    }

    if ((gbv = setupBlitVector(env, glyphlist)) == NULL) {

        return;

    }

    pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    color = GrPrim_Sg2dGetEaRGB(env, sg2d);

    drawGlyphList(env, self, sg2d, sData, gbv, pixel, color,

                  pPrim, pPrim->funcs.drawglyphlist);

    free(gbv);

}

/*

 * Class:     sun_java2d_loops_DrawGlyphListAA

 * Method:    DrawGlyphListAA

 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_DrawGlyphListAA_DrawGlyphListAA

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData, jobject glyphlist) {

    jint pixel, color;

    GlyphBlitVector* gbv;

    NativePrimitive *pPrim;

    if ((pPrim = GetNativePrim(env, self)) == NULL) {

        return;

    }

    if ((gbv = setupBlitVector(env, glyphlist)) == NULL) {

        return;

    }

    pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    color = GrPrim_Sg2dGetEaRGB(env, sg2d);

    drawGlyphList(env, self, sg2d, sData, gbv, pixel, color,

                  pPrim, pPrim->funcs.drawglyphlistaa);

    free(gbv);

}

/*

 * Class:     sun_java2d_loops_DrawGlyphListLCD

 * Method:    DrawGlyphListLCD

 * Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;Lsun/java2d/font/GlyphList;J)V

 */

JNIEXPORT void JNICALL

Java_sun_java2d_loops_DrawGlyphListLCD_DrawGlyphListLCD

    (JNIEnv *env, jobject self,

     jobject sg2d, jobject sData, jobject glyphlist) {

    jint pixel, color, contrast;

    jboolean rgbOrder;

    GlyphBlitVector* gbv;

    NativePrimitive *pPrim;

    if ((pPrim = GetNativePrim(env, self)) == NULL) {

        return;

    }

    if ((gbv = setupLCDBlitVector(env, glyphlist)) == NULL) {

        return;

    }

    pixel = GrPrim_Sg2dGetPixel(env, sg2d);

    color = GrPrim_Sg2dGetEaRGB(env, sg2d);

    contrast = GrPrim_Sg2dGetLCDTextContrast(env, sg2d);

    rgbOrder = (*env)->GetBooleanField(env,glyphlist, sunFontIDs.lcdRGBOrder);

    drawGlyphListLCD(env, self, sg2d, sData, gbv, pixel, color,

                     rgbOrder, contrast,

                     pPrim, pPrim->funcs.drawglyphlistlcd);

    free(gbv);

}

/*

 *  LCD text utilises a filter which spreads energy to adjacent subpixels.

 *  So we add 3 bytes (one whole pixel) of padding at the start of every row

 *  to hold energy from the very leftmost sub-pixel.

 *  This is to the left of the intended glyph image position so LCD text also

 *  adjusts the top-left X position of the padded image one pixel to the left

 *  so a glyph image is drawn in the same place it would be if the padding

 *  were not present.

 *

 *  So in the glyph cache for LCD text the first two bytes of every row are

 *  zero.

 *  We make use of this to be able to adjust the rendering position of the

 *  text when the client specifies a fractional metrics sub-pixel positioning

 *  rendering hint.

 *

 *  So the first 6 bytes in a cache row looks like :

 *  00 00 Ex G0 G1 G2

 *

 *  where

 *  00 are the always zero bytes

 *  Ex is extra energy spread from the glyph into the left padding pixel.

 *  Gn are the RGB component bytes of the first pixel of the glyph image

 *  For an RGB display G0 is the red component, etc.

 *

 *  If a glyph is drawn at X=12 then the G0 G1 G2 pixel is placed at that

 *  position : ie G0 is drawn in the first sub-pixel at X=12

 *

 *  Draw at X=12,0

 *  PIXEL POS 11 11 11 12 12 12 13 13 13

 *  SUBPX POS  0  1  2  0  1  2  0  1  2

 *            00 00 Ex G0 G1 G2

 *

 *  If a sub-pixel rounded glyph position is calculated as being X=12.33 -

 *  ie 12 and one-third pixels, we want the result to look like this :

 *  Draw at X=12,1

 *  PIXEL POS 11 11 11 12 12 12 13 13 13

 *  SUBPX POS  0  1  2  0  1  2  0  1  2

 *               00 00 Ex G0 G1 G2

 *

 *  ie the G0 byte is moved one sub-pixel to the right.

 *  To do this we need to make two adjustments :

 *  - set X=X+1

 *  - set start of scan row to start+2, ie index past the two zero bytes

 *  ie we don't need the 00 00 bytes at all any more. Rendering start X

 *  can skip over those.

 *

 *  Lets look at the final case :

 *  If a sub-pixel rounded glyph position is calculated as being X=12.67 -

 *  ie 12 and two-third pixels, we want the result to look like this :

 *  Draw at X=12,2

 *  PIXEL POS 11 11 11 12 12 12 13 13 13

 *  SUBPX POS  0  1  2  0  1  2  0  1  2

 *                  00 00 Ex G0 G1 G2

 *

 *  ie the G0 byte is moved two sub-pixels to the right, so that the image

 *  starts at 12.67

 *  To do this we need to make these two adjustments :

 *  - set X=X+1

 *  - set start of scan row to start+1, ie index past the first zero byte

 *  In this case the second of the 00 bytes is used as a no-op on the first

 *   red sub-pixel position.

 *

 *  The final adjustment needed to make all this work is note that if

 *  we moved the start of row one or two bytes in we will go one or two bytes

 *  past the end of the row. So the glyph cache needs to have 2 bytes of

 *  zero padding at the end of each row. This is the extra memory cost to

 *  accommodate this algorithm.

 *

 *  The resulting text is perhaps fractionally better in overall perception

 *  than rounding to the whole pixel grid, as a few issues arise.

 *

 *  * the improvement in inter-glyph spacing as well as being limited

 *  to 1/3 pixel resolution, is also limited because the glyphs were hinted

 *  so they fit to the whole pixel grid. It may be worthwhile to pursue

 *  disabling x-axis gridfitting.

 *

 *  * an LCD display may have gaps between the pixels that are greater

 *  than the subpixels. Thus for thin stemmed fonts, if the shift causes

 *  the "heart" of a stem to span whole pixels it may appear more diffuse -

 *  less sharp. Eliminating hinting would probably not make this worse - in

 *  effect we have already doing that here. But it would improve the spacing.

 *

 *  * perhaps contradicting the above point in some ways, more diffuse glyphs

 *  are better at reducing colour fringing, but what appears to be more

 *  colour fringing in this FM case is more likely attributable to a greater

 *  likelihood for glyphs to abutt. In integer metrics or even whole pixel

 *  rendered fractional metrics, there's typically more space between the

 *  glyphs. Perhaps disabling X-axis grid-fitting will help with that.

 */

GlyphBlitVector* setupLCDBlitVector(JNIEnv *env, jobject glyphlist) {

    int g;

    size_t bytesNeeded;

    jlong *imagePtrs;

    jfloat* positions = NULL;

    GlyphInfo *ginfo;

    GlyphBlitVector *gbv;

    jfloat x = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListX);

    jfloat y = (*env)->GetFloatField(env, glyphlist, sunFontIDs.glyphListY);

    jint len =  (*env)->GetIntField(env, glyphlist, sunFontIDs.glyphListLen);

    jlongArray glyphImages = (jlongArray)

        (*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphImages);

    jfloatArray glyphPositions =

      (*env)->GetBooleanField(env, glyphlist, sunFontIDs.glyphListUsePos)

        ? (jfloatArray)

      (*env)->GetObjectField(env, glyphlist, sunFontIDs.glyphListPos)

        : NULL;

    jboolean subPixPos =

      (*env)->GetBooleanField(env,glyphlist, sunFontIDs.lcdSubPixPos);

    bytesNeeded = sizeof(GlyphBlitVector)+sizeof(ImageRef)*len;

    gbv = (GlyphBlitVector*)malloc(bytesNeeded);

    if (gbv == NULL) {

        return NULL;

    }

    gbv->numGlyphs = len;

    gbv->glyphs = (ImageRef*)((unsigned char*)gbv+sizeof(GlyphBlitVector));

    imagePtrs = (*env)->GetPrimitiveArrayCritical(env, glyphImages, NULL);

    if (imagePtrs == NULL) {

        free(gbv);

        return (GlyphBlitVector*)NULL;

    }

    /* The position of the start of the text is adjusted up so

     * that we can round it to an integral pixel position for a

     * bitmap glyph or non-subpixel positioning, and round it to an

     * integral subpixel position for that case, hence 0.5/3 = 0.166667

     * Presently subPixPos means FM, and FM disables embedded bitmaps

     * Therefore if subPixPos is true we should never get embedded bitmaps

     * and the glyphlist will be homogenous. This test and the position