/*

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

 */

#ifndef HEADLESS

#include <stdlib.h>

#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  32

#define OGLTR_CACHE_CELL_HEIGHT 32

/**

 * 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;

/**

 * There are two separate glyph caches: for AA and for LCD.

 * Once one of them 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 *glyphCacheLCD = NULL;

static GlyphCacheInfo *glyphCacheAA = NULL;

/**

 * The handle to the LCD text fragment program object.

 */

static GLhandleARB lcdTextProgram = 0;

/**

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

 * value hasn't changed since the last time the gamma uniforms were

 * updated (not very common), then we can skip updating the unforms.

 */

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 (OGLTR_CACHE_CELL_HEIGHT * 2)

/**

 * 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 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);

    if (lcdCache) {

        glyphCacheLCD = gcinfo;

    } else {

        glyphCacheAA = 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, GLenum pixelFormat)

{

    CacheCellInfo *ccinfo;

    GlyphCacheInfo *gcinfo;

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_AddToGlyphCache");

    if (pixelFormat == GL_LUMINANCE) {

        gcinfo = glyphCacheAA;

    } else {

        gcinfo = glyphCacheLCD;

    }

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

        return;

    }

    AccelGlyphCache_AddGlyph(gcinfo, 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. The pow() routine operates on vectors, gives precise results,

 * and provides acceptable level of performance, so we use it to perform

 * the gamma adjustment.

 *

 * 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 vec3 gamma;"

    "uniform vec3 invgamma;"

    ""

    "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

    "    vec3 dst_adj = pow(dst_clr.rgb, gamma);"

         // 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(pow(result.rgb, invgamma), 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

{

    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

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

    j2d_glUseProgramObjectARB(0);

    return lcdTextProgram;

}

/**

 * (Re)Initializes the gamma related uniforms.

 *

 * 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].

 */

static jboolean

OGLTR_UpdateLCDTextContrast(jint contrast)

{

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

    double ig = 1.0 / g;

    GLint loc;

    J2dTraceLn1(J2D_TRACE_INFO,

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

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "gamma");

    j2d_glUniform3fARB(loc, g, g, g);

    loc = j2d_glGetUniformLocationARB(lcdTextProgram, "invgamma");

    j2d_glUniform3fARB(loc, ig, ig, ig);

    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,

                              GLuint dstTextureID,

                              jint contrast)

{

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

    j2d_glActiveTextureARB(GL_TEXTURE0_ARB);

    j2d_glBindTexture(GL_TEXTURE_2D, glyphTextureID);

    j2d_glEnable(GL_TEXTURE_2D);

    // bind the texture tile containing destination data to texture unit 1

    j2d_glActiveTextureARB(GL_TEXTURE1_ARB);

    if (dstTextureID != 0) {

        j2d_glBindTexture(GL_TEXTURE_2D, dstTextureID);

    } else {

        if (cachedDestTextureID == 0) {

            cachedDestTextureID =

                OGLContext_CreateBlitTexture(GL_RGB8, GL_RGB,

                                             OGLTR_CACHED_DEST_WIDTH,

                                             OGLTR_CACHED_DEST_HEIGHT);

            if (cachedDestTextureID == 0) {

                return JNI_FALSE;

            }

        }

        j2d_glBindTexture(GL_TEXTURE_2D, cachedDestTextureID);

    }

    // note that GL_TEXTURE_2D was already enabled for texture unit 0,

    // but we need to explicitly enable it for texture unit 1

    j2d_glEnable(GL_TEXTURE_2D);

    // create the LCD text shader, if necessary

    if (lcdTextProgram == 0) {

        lcdTextProgram = OGLTR_CreateLCDTextProgram();

        if (lcdTextProgram == 0) {

            return JNI_FALSE;

        }

    }

    // enable the LCD text shader

    j2d_glUseProgramObjectARB(lcdTextProgram);

    // update the current contrast settings, if necessary

    if (lastLCDContrast != contrast) {

        if (!OGLTR_UpdateLCDTextContrast(contrast)) {

            return JNI_FALSE;

        }

        lastLCDContrast = contrast;

    }

    // update the current color settings

    if (!OGLTR_UpdateLCDTextColor(contrast)) {

        return JNI_FALSE;

    }

    return JNI_TRUE;

}

void

OGLTR_EnableGlyphVertexCache(OGLContext *oglc)

{

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_EnableGlyphVertexCache");

    if (!OGLVertexCache_InitVertexCache(oglc)) {

        return;

    }

    if (glyphCacheAA == NULL) {

        if (!OGLTR_InitGlyphCache(JNI_FALSE)) {

            return;

        }

    }

    j2d_glEnable(GL_TEXTURE_2D);

    j2d_glBindTexture(GL_TEXTURE_2D, glyphCacheAA->cacheID);

    j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    // for grayscale/monochrome text, the current OpenGL source color

    // is modulated with the glyph image as part of the texture

    // application stage, so we use GL_MODULATE here

    OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE);

}

void

OGLTR_DisableGlyphVertexCache(OGLContext *oglc)

{

    J2dTraceLn(J2D_TRACE_INFO, "OGLTR_DisableGlyphVertexCache");

    OGLVertexCache_FlushVertexCache();

    OGLVertexCache_RestoreColorState(oglc);

    j2d_glDisable(GL_TEXTURE_2D);

    j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

    j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

    j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

    j2d_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);

}

/**

 * Disables any pending state associated with the current "glyph mode".

 */

static void

{

    switch (glyphMode) {

    case MODE_NO_CACHE_LCD:

        j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);

        j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);

        /* FALLTHROUGH */

    case MODE_USE_CACHE_LCD: