/*

 * Copyright (c) 2003, 2010, 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.

 */

#ifndef HEADLESS

#include <math.h>

#include <jlong.h>

#include "sun_java2d_opengl_OGLTextRenderer.h"

#include "SurfaceData.h"

#include "OGLContext.h"

#include "OGLSurfaceData.h"

#include "OGLRenderQueue.h"

#include "OGLTextRenderer.h"

#include "OGLVertexCache.h"

#include "AccelGlyphCache.h"

#include "fontscalerdefs.h"

/**

 * The following constants define the inner and outer bounds of the

 * accelerated glyph cache.

 */

#define OGLTR_CACHE_WIDTH       512

#define OGLTR_CACHE_HEIGHT      512

#define OGLTR_CACHE_CELL_WIDTH  16

#define OGLTR_CACHE_CELL_HEIGHT 16

/**

 * The current "glyph mode" state.  This variable is used to track the

 * codepath used to render a particular glyph.  This variable is reset to

 * MODE_NOT_INITED at the beginning of every call to OGLTR_DrawGlyphList().

 * As each glyph is rendered, the glyphMode variable is updated to reflect

 * the current mode, so if the current mode is the same as the mode used

 * to render the previous glyph, we can avoid doing costly setup operations

 * each time.

 */

typedef enum {

    MODE_NOT_INITED,

    MODE_USE_CACHE_GRAY,

    MODE_USE_CACHE_LCD,

    MODE_NO_CACHE_GRAY,

    MODE_NO_CACHE_LCD

} GlyphMode;

static GlyphMode glyphMode = MODE_NOT_INITED;

/**

 * This enum indicates the current state of the hardware glyph cache.

 * Initially the CacheStatus is set to CACHE_NOT_INITED, and then it is

 * set to either GRAY or LCD when the glyph cache is initialized.

 */

typedef enum {

    CACHE_NOT_INITED,

    CACHE_GRAY,

    CACHE_LCD

} CacheStatus;

static CacheStatus cacheStatus = CACHE_NOT_INITED;

/**

 * This is the one glyph cache.  Once it is initialized as either GRAY or

 * LCD, it stays in that mode for the duration of the application.  It should

 * be safe to use this one glyph cache for all screens in a multimon

 * environment, since the glyph cache texture is shared between all contexts,

 * and (in theory) OpenGL drivers should be smart enough to manage that

 * texture across all screens.

 */

static GlyphCacheInfo *glyphCache = NULL;

/**

 * The handle to the LCD text fragment program object.

 */

static GLhandleARB lcdTextProgram = 0;

/**

 * The size of one of the gamma LUT textures in any one dimension along

 * the edge, in texels.

 */

#define LUT_EDGE 16

/**

 * These are the texture object handles for the gamma and inverse gamma

 * lookup tables.

 */

static GLuint gammaLutTextureID = 0;

static GLuint invGammaLutTextureID = 0;

/**

 * This value tracks the previous LCD contrast setting, so if the contrast

 * value hasn't changed since the last time the lookup tables were

 * generated (not very common), then we can skip updating the tables.

 */

static jint lastLCDContrast = -1;

/**

 * This value tracks the previous LCD rgbOrder setting, so if the rgbOrder

 * value has changed since the last time, it indicates that we need to

 * invalidate the cache, which may already store glyph images in the reverse

 * order.  Note that in most real world applications this value will not

 * change over the course of the application, but tests like Font2DTest

 * allow for changing the ordering at runtime, so we need to handle that case.

 */

static jboolean lastRGBOrder = JNI_TRUE;

/**

 * This constant defines the size of the tile to use in the

 * OGLTR_DrawLCDGlyphNoCache() method.  See below for more on why we

 * restrict this value to a particular size.

 */

#define OGLTR_NOCACHE_TILE_SIZE 32

/**

 * These constants define the size of the "cached destination" texture.

 * This texture is only used when rendering LCD-optimized text, as that

 * codepath needs direct access to the destination.  There is no way to

 * access the framebuffer directly from an OpenGL shader, so we need to first

 * copy the destination region corresponding to a particular glyph into

 * this cached texture, and then that texture will be accessed inside the

 * shader.  Copying the destination into this cached texture can be a very

 * expensive operation (accounting for about half the rendering time for

 * LCD text), so to mitigate this cost we try to bulk read a horizontal

 * region of the destination at a time.  (These values are empirically

 * derived for the common case where text runs horizontally.)

 *

 * Note: It is assumed in various calculations below that:

 *     (OGLTR_CACHED_DEST_WIDTH  >= OGLTR_CACHE_CELL_WIDTH)  &&

 *     (OGLTR_CACHED_DEST_WIDTH  >= OGLTR_NOCACHE_TILE_SIZE) &&

 *     (OGLTR_CACHED_DEST_HEIGHT >= OGLTR_CACHE_CELL_HEIGHT) &&

 *     (OGLTR_CACHED_DEST_HEIGHT >= OGLTR_NOCACHE_TILE_SIZE)

 */

#define OGLTR_CACHED_DEST_WIDTH  512

#define OGLTR_CACHED_DEST_HEIGHT 32

/**

 * The handle to the "cached destination" texture object.

 */

static GLuint cachedDestTextureID = 0;

/**

 * The current bounds of the "cached destination" texture, in destination

 * coordinate space.  The width/height of these bounds will not exceed the

 * OGLTR_CACHED_DEST_WIDTH/HEIGHT values defined above.  These bounds are

 * only considered valid when the isCachedDestValid flag is JNI_TRUE.

 */

static SurfaceDataBounds cachedDestBounds;

/**

 * This flag indicates whether the "cached destination" texture contains

 * valid data.  This flag is reset to JNI_FALSE at the beginning of every

 * call to OGLTR_DrawGlyphList().  Once we copy valid destination data

 * into the cached texture, this flag is set to JNI_TRUE.  This way, we can

 * limit the number of times we need to copy destination data, which is a

 * very costly operation.

 */

static jboolean isCachedDestValid = JNI_FALSE;

/**

 * The bounds of the previously rendered LCD glyph, in destination

 * coordinate space.  We use these bounds to determine whether the glyph

 * currently being rendered overlaps the previously rendered glyph (i.e.

 * its bounding box intersects that of the previously rendered glyph).  If

 * so, we need to re-read the destination area associated with that previous

 * glyph so that we can correctly blend with the actual destination data.

 */

static SurfaceDataBounds previousGlyphBounds;

/**

 * Initializes the one glyph cache (texture and data structure).

 * If lcdCache is JNI_TRUE, the texture will contain RGB data,

 * otherwise we will simply store the grayscale/monochrome glyph images

 * as intensity values (which work well with the GL_MODULATE function).

 */

static jboolean

OGLTR_InitGlyphCache(jboolean lcdCache)

{

    GlyphCacheInfo *gcinfo;

    GLclampf priority = 1.0f;

    GLenum internalFormat = lcdCache ? GL_RGB8 : GL_INTENSITY8;

    GLenum pixelFormat = lcdCache ? GL_RGB : GL_LUMINANCE;

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_InitGlyphCache");

    // init vertex cache (if it hasn't been already)

    if (!OGLVertexCache_InitVertexCache()) {

        return JNI_FALSE;

    }

    // init glyph cache data structure

    gcinfo = AccelGlyphCache_Init(OGLTR_CACHE_WIDTH,

                                  OGLTR_CACHE_HEIGHT,

                                  OGLTR_CACHE_CELL_WIDTH,

                                  OGLTR_CACHE_CELL_HEIGHT,

                                  OGLVertexCache_FlushVertexCache);

    if (gcinfo == NULL) {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

                      "OGLTR_InitGlyphCache: could not init OGL glyph cache");

        return JNI_FALSE;

    }

    // init cache texture object

    j2d_glGenTextures(1, &gcinfo->cacheID);

    j2d_glBindTexture(GL_TEXTURE_2D, gcinfo->cacheID);

    j2d_glPrioritizeTextures(1, &gcinfo->cacheID, &priority);

    j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

    j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    j2d_glTexImage2D(GL_TEXTURE_2D, 0, internalFormat,

                     OGLTR_CACHE_WIDTH, OGLTR_CACHE_HEIGHT, 0,

                     pixelFormat, GL_UNSIGNED_BYTE, NULL);

    cacheStatus = (lcdCache ? CACHE_LCD : CACHE_GRAY);

    glyphCache = gcinfo;

    return JNI_TRUE;

}

/**

 * Adds the given glyph to the glyph cache (texture and data structure)

 * associated with the given OGLContext.

 */

static void

OGLTR_AddToGlyphCache(GlyphInfo *glyph, jboolean rgbOrder)

{

    GLenum pixelFormat;

    CacheCellInfo *ccinfo;

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_AddToGlyphCache");

    if ((glyphCache == NULL) || (glyph->image == NULL)) {

        return;

    }

    if (cacheStatus == CACHE_LCD) {

        pixelFormat = rgbOrder ? GL_RGB : GL_BGR;

    } else {

        pixelFormat = GL_LUMINANCE;

    }

    AccelGlyphCache_AddGlyph(glyphCache, glyph);

    ccinfo = (CacheCellInfo *) glyph->cellInfo;

    if (ccinfo != NULL) {

        // store glyph image in texture cell

        j2d_glTexSubImage2D(GL_TEXTURE_2D, 0,

                            ccinfo->x, ccinfo->y,

                            glyph->width, glyph->height,

                            pixelFormat, GL_UNSIGNED_BYTE, glyph->image);

    }

}

/**

 * This is the GLSL fragment shader source code for rendering LCD-optimized

 * text.  Do not be frightened; it is much easier to understand than the

 * equivalent ASM-like fragment program!

 *

 * The "uniform" variables at the top are initialized once the program is

 * linked, and are updated at runtime as needed (e.g. when the source color

 * changes, we will modify the "src_adj" value in OGLTR_UpdateLCDTextColor()).

 *

 * The "main" function is executed for each "fragment" (or pixel) in the

 * glyph image.  We have determined that the pow() function can be quite

 * slow and it only operates on scalar values, not vectors as we require.

 * So instead we build two 3D textures containing gamma (and inverse gamma)

 * lookup tables that allow us to approximate a component-wise pow() function

 * with a single 3D texture lookup.  This approach is at least 2x faster

 * than the equivalent pow() calls.

 *

 * The variables involved in the equation can be expressed as follows:

 *

 *   Cs = Color component of the source (foreground color) [0.0, 1.0]

 *   Cd = Color component of the destination (background color) [0.0, 1.0]

 *   Cr = Color component to be written to the destination [0.0, 1.0]

 *   Ag = Glyph alpha (aka intensity or coverage) [0.0, 1.0]

 *   Ga = Gamma adjustment in the range [1.0, 2.5]

 *   (^ means raised to the power)

 *

 * And here is the theoretical equation approximated by this shader:

 *

 *            Cr = (Ag*(Cs^Ga) + (1-Ag)*(Cd^Ga)) ^ (1/Ga)

 */

static const char *lcdTextShaderSource =

    "uniform vec3 src_adj;"

    "uniform sampler2D glyph_tex;"

    "uniform sampler2D dst_tex;"

    "uniform sampler3D invgamma_tex;"

    "uniform sampler3D gamma_tex;"

    ""

    "void main(void)"

    "{"

         // load the RGB value from the glyph image at the current texcoord

    "    vec3 glyph_clr = vec3(texture2D(glyph_tex, gl_TexCoord[0].st));"

    "    if (glyph_clr == vec3(0.0)) {"

             // zero coverage, so skip this fragment

    "        discard;"

    "    }"

         // load the RGB value from the corresponding destination pixel

    "    vec3 dst_clr = vec3(texture2D(dst_tex, gl_TexCoord[1].st));"

         // gamma adjust the dest color using the invgamma LUT

    "    vec3 dst_adj = vec3(texture3D(invgamma_tex, dst_clr.stp));"

         // linearly interpolate the three color values

    "    vec3 result = mix(dst_adj, src_adj, glyph_clr);"

         // gamma re-adjust the resulting color (alpha is always set to 1.0)

    "    gl_FragColor = vec4(vec3(texture3D(gamma_tex, result.stp)), 1.0);"

    "}";

/**

 * Compiles and links the LCD text shader program.  If successful, this

 * function returns a handle to the newly created shader program; otherwise

 * returns 0.

 */

static GLhandleARB

OGLTR_CreateLCDTextProgram()

{

    GLhandleARB lcdTextProgram;

    GLint loc;

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_CreateLCDTextProgram");

    lcdTextProgram = OGLContext_CreateFragmentProgram(lcdTextShaderSource);

    if (lcdTextProgram == 0) {

        J2dRlsTraceLn(J2D_TRACE_ERROR,

                      "OGLTR_CreateLCDTextProgram: error creating program");

        return 0;

    }

    // "use" the program object temporarily so that we can set the uniforms

    j2d_glUseProgramObjectARB(lcdTextProgram);

    // set the "uniform" values

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "glyph_tex");

    j2d_glUniform1iARB(loc, 0); // texture unit 0

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "dst_tex");

    j2d_glUniform1iARB(loc, 1); // texture unit 1

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "invgamma_tex");

    j2d_glUniform1iARB(loc, 2); // texture unit 2

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "gamma_tex");

    j2d_glUniform1iARB(loc, 3); // texture unit 3

    // "unuse" the program object; it will be re-bound later as needed

    j2d_glUseProgramObjectARB(0);

    return lcdTextProgram;

}

/**

 * Initializes a 3D texture object for use as a three-dimensional gamma

 * lookup table.  Note that the wrap mode is initialized to GL_LINEAR so

 * that the table will interpolate adjacent values when the index falls

 * somewhere in between.

 */

static GLuint

OGLTR_InitGammaLutTexture()

{

    GLuint lutTextureID;

    j2d_glGenTextures(1, &lutTextureID);

    j2d_glBindTexture(GL_TEXTURE_3D, lutTextureID);

    j2d_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    j2d_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

    j2d_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);

    j2d_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

    j2d_glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);

    return lutTextureID;

}

/**

 * Updates the lookup table in the given texture object with the float

 * values in the given system memory buffer.  Note that we could use

 * glTexSubImage3D() when updating the texture after its first

 * initialization, but since we're updating the entire table (with

 * power-of-two dimensions) and this is a relatively rare event, we'll

 * just stick with glTexImage3D().

 */

static void

OGLTR_UpdateGammaLutTexture(GLuint texID, GLfloat *lut, jint size)

{

    j2d_glBindTexture(GL_TEXTURE_3D, texID);

    j2d_glTexImage3D(GL_TEXTURE_3D, 0, GL_RGB8,

                     size, size, size, 0, GL_RGB, GL_FLOAT, lut);

}

/**

 * (Re)Initializes the gamma lookup table textures.

 *

 * The given contrast value is an int in the range [100, 250] which we will

 * then scale to fit in the range [1.0, 2.5].  We create two LUTs, one

 * that essentially calculates pow(x, gamma) and the other calculates

 * pow(x, 1/gamma).  These values are replicated in all three dimensions, so

 * given a single 3D texture coordinate (typically this will be a triplet

 * in the form (r,g,b)), the 3D texture lookup will return an RGB triplet:

 *

 *     (pow(r,g), pow(y,g), pow(z,g)

 *

 * where g is either gamma or 1/gamma, depending on the table.

 */

static jboolean

OGLTR_UpdateLCDTextContrast(jint contrast)

{

    double gamma = ((double)contrast) / 100.0;

    double ig = gamma;

    double g = 1.0 / ig;

    GLfloat lut[LUT_EDGE][LUT_EDGE][LUT_EDGE][3];

    GLfloat invlut[LUT_EDGE][LUT_EDGE][LUT_EDGE][3];

    int min = 0;

    int max = LUT_EDGE - 1;

    int x, y, z;

    J2dTraceLn1(J2D_TRACE_INFO,

                "OGLTR_UpdateLCDTextContrast: contrast=%d", contrast);

    for (z = min; z <= max; z++) {

        double zval = ((double)z) / max;

        GLfloat gz = (GLfloat)pow(zval, g);

        GLfloat igz = (GLfloat)pow(zval, ig);

        for (y = min; y <= max; y++) {

            double yval = ((double)y) / max;

            GLfloat gy = (GLfloat)pow(yval, g);

            GLfloat igy = (GLfloat)pow(yval, ig);

            for (x = min; x <= max; x++) {

                double xval = ((double)x) / max;

                GLfloat gx = (GLfloat)pow(xval, g);

                GLfloat igx = (GLfloat)pow(xval, ig);

                lut[z][y][x][0] = gx;

                lut[z][y][x][1] = gy;

                lut[z][y][x][2] = gz;

                invlut[z][y][x][0] = igx;

                invlut[z][y][x][1] = igy;

                invlut[z][y][x][2] = igz;

            }

        }

    }

    if (gammaLutTextureID == 0) {

        gammaLutTextureID = OGLTR_InitGammaLutTexture();

    }

    OGLTR_UpdateGammaLutTexture(gammaLutTextureID, (GLfloat *)lut, LUT_EDGE);

    if (invGammaLutTextureID == 0) {

        invGammaLutTextureID = OGLTR_InitGammaLutTexture();

    }

    OGLTR_UpdateGammaLutTexture(invGammaLutTextureID,

                                (GLfloat *)invlut, LUT_EDGE);

    return JNI_TRUE;

}

/**

 * Updates the current gamma-adjusted source color ("src_adj") of the LCD

 * text shader program.  Note that we could calculate this value in the

 * shader (e.g. just as we do for "dst_adj"), but would be unnecessary work

 * (and a measurable performance hit, maybe around 5%) since this value is

 * constant over the entire glyph list.  So instead we just calculate the

 * gamma-adjusted value once and update the uniform parameter of the LCD

 * shader as needed.

 */

static jboolean

OGLTR_UpdateLCDTextColor(jint contrast)

{

    double gamma = ((double)contrast) / 100.0;

    GLfloat radj, gadj, badj;

    GLfloat clr[4];

    GLint loc;

    J2dTraceLn1(J2D_TRACE_INFO,

                "OGLTR_UpdateLCDTextColor: contrast=%d", contrast);

    /*

     * Note: Ideally we would update the "src_adj" uniform parameter only

     * when there is a change in the source color.  Fortunately, the cost

     * of querying the current OpenGL color state and updating the uniform

     * value is quite small, and in the common case we only need to do this

     * once per GlyphList, so we gain little from trying to optimize too

     * eagerly here.

     */

    // get the current OpenGL primary color state

    j2d_glGetFloatv(GL_CURRENT_COLOR, clr);

    // gamma adjust the primary color

    radj = (GLfloat)pow(clr[0], gamma);

    gadj = (GLfloat)pow(clr[1], gamma);

    badj = (GLfloat)pow(clr[2], gamma);

    // update the "src_adj" parameter of the shader program with this value

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "src_adj");

    j2d_glUniform3fARB(loc, radj, gadj, badj);

    return JNI_TRUE;

}

/**

 * Enables the LCD text shader and updates any related state, such as the

 * gamma lookup table textures.

 */

static jboolean

OGLTR_EnableLCDGlyphModeState(GLuint glyphTextureID, jint contrast)

{

    // bind the texture containing glyph data to texture unit 0

    j2d_glActiveTextureARB(GL_TEXTURE0_ARB);

    j2d_glBindTexture(GL_TEXTURE_2D, glyphTextureID);