/*

 * Copyright (c) 2007, 2008, 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 <malloc.h>

#include <math.h>

#include <jlong.h>

#include "sun_java2d_d3d_D3DTextRenderer.h"

#include "sun_java2d_pipe_BufferedTextPipe.h"

#include "SurfaceData.h"

#include "D3DContext.h"

#include "D3DSurfaceData.h"

#include "D3DRenderQueue.h"

#include "D3DTextRenderer.h"

#include "D3DGlyphCache.h"

#include "AccelGlyphCache.h"

#include "fontscalerdefs.h"

/**

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

/**

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

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

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

/**

 * Updates the gamma and inverse gamma values for the LCD text shader.

 */

static HRESULT

D3DTR_UpdateLCDTextContrast(D3DContext *d3dc, jint contrast)

{

    HRESULT res;

    IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

    jfloat fcon = ((jfloat)contrast) / 100.0f;

    jfloat invgamma = fcon;

    jfloat gamma = 1.0f / invgamma;

    jfloat vals[4];

    // update the "invgamma" parameter of the shader program

    vals[0] = invgamma;

    vals[1] = invgamma;

    vals[2] = invgamma;

    vals[3] = 0.0f; // unused

    pd3dDevice->SetPixelShaderConstantF(1, vals, 1);

    // update the "gamma" parameter of the shader program

    vals[0] = gamma;

    vals[1] = gamma;

    vals[2] = gamma;

    vals[3] = 0.0f; // unused

    res = pd3dDevice->SetPixelShaderConstantF(2, vals, 1);

    return res;

}

/**

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

D3DTR_UpdateLCDTextColor(D3DContext *d3dc, jint contrast)

{

    IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

    jfloat gamma = ((jfloat)contrast) / 100.0f;

    jfloat clr[4];

    J2dTraceLn1(J2D_TRACE_INFO,

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

    /*

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

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

     * of querying the current D3D 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 D3D primary color state

    jint color = d3dc->pVCacher->GetColor();

    clr[0] = (jfloat)((color >> 16) & 0xff) / 255.0f;

    clr[1] = (jfloat)((color >>  8) & 0xff) / 255.0f;

    clr[2] = (jfloat)((color >>  0) & 0xff) / 255.0f;

    clr[3] = 0.0f; // unused

    // gamma adjust the primary color

    clr[0] = (jfloat)pow(clr[0], gamma);

    clr[1] = (jfloat)pow(clr[1], gamma);

    clr[2] = (jfloat)pow(clr[2], gamma);

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

    return pd3dDevice->SetPixelShaderConstantF(0, clr, 1);

}

/**

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

 * gamma values.

 */

static HRESULT

D3DTR_EnableLCDGlyphModeState(D3DContext *d3dc, D3DSDOps *dstOps,

                              jboolean useCache, jint contrast)

{

    D3DResource *pGlyphTexRes, *pCachedDestTexRes;

    IDirect3DTexture9 *pGlyphTex, *pCachedDestTex;

    RETURN_STATUS_IF_NULL(dstOps->pResource, E_FAIL);

    HRESULT res = S_OK;

    if (useCache) {

        // glyph cache had been already initialized

        pGlyphTexRes = d3dc->GetLCDGlyphCache()->GetGlyphCacheTexture();

    } else {

        res = d3dc->GetResourceManager()->GetBlitTexture(&pGlyphTexRes);

    }

    RETURN_STATUS_IF_FAILED(res);

    pGlyphTex = pGlyphTexRes->GetTexture();

    res = d3dc->GetResourceManager()->

        GetCachedDestTexture(dstOps->pResource->GetDesc()->Format,

                             &pCachedDestTexRes);

    RETURN_STATUS_IF_FAILED(res);

    pCachedDestTex = pCachedDestTexRes->GetTexture();

    IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

    D3DTEXTUREFILTERTYPE fhint =

        d3dc->IsTextureFilteringSupported(D3DTEXF_NONE) ?

        D3DTEXF_NONE : D3DTEXF_POINT;

    pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, fhint);

    pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, fhint);

    pd3dDevice->SetSamplerState(1, D3DSAMP_MAGFILTER, fhint);

    pd3dDevice->SetSamplerState(1, D3DSAMP_MINFILTER, fhint);

    d3dc->UpdateTextureColorState(D3DTA_TEXTURE, 1);

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

    d3dc->SetTexture(pGlyphTex, 0);

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

    d3dc->SetTexture(pCachedDestTex, 1);

    // create/enable the LCD text shader

    res = d3dc->EnableLCDTextProgram();

    RETURN_STATUS_IF_FAILED(res);

    // update the current contrast settings (note: these change very rarely,

    // but it seems that D3D pixel shader registers aren't maintained as

    // part of the pixel shader instance, so we need to update these

    // everytime around in case another shader blew away the contents

    // of those registers)

    D3DTR_UpdateLCDTextContrast(d3dc, contrast);

    // update the current color settings

    return D3DTR_UpdateLCDTextColor(d3dc, contrast);

}

HRESULT

D3DTR_EnableGlyphVertexCache(D3DContext *d3dc)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DTR_EnableGlyphVertexCache");

    IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

    D3DTEXTUREFILTERTYPE fhint =

        d3dc->IsTextureFilteringSupported(D3DTEXF_NONE) ?

        D3DTEXF_NONE : D3DTEXF_POINT;

    pd3dDevice->SetSamplerState(0, D3DSAMP_MAGFILTER, fhint);

    pd3dDevice->SetSamplerState(0, D3DSAMP_MINFILTER, fhint);

    // glyph cache had been successfully initialized if we got here

    D3DResource *pGlyphCacheTexRes =

        d3dc->GetGrayscaleGlyphCache()->GetGlyphCacheTexture();

    return d3dc->SetTexture(pGlyphCacheTexRes->GetTexture(), 0);

}

HRESULT

D3DTR_DisableGlyphVertexCache(D3DContext *d3dc)

{

    J2dTraceLn(J2D_TRACE_INFO, "D3DTR_DisableGlyphVertexCache");

    return d3dc->SetTexture(NULL, 0);

}

/**

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

 */

static HRESULT

D3DTR_DisableGlyphModeState(D3DContext *d3dc)

{

    HRESULT res = S_OK;

    IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

    switch (glyphMode) {

    case MODE_NO_CACHE_LCD:

    case MODE_USE_CACHE_LCD:

        d3dc->FlushVertexQueue();

        pd3dDevice->SetPixelShader(NULL);

        res = d3dc->SetTexture(NULL, 1);

        break;

    case MODE_NO_CACHE_GRAY:

    case MODE_USE_CACHE_GRAY:

    case MODE_NOT_INITED:

    default:

        break;

    }

    return res;

}

static HRESULT

D3DTR_DrawGrayscaleGlyphViaCache(D3DContext *d3dc,

                                 GlyphInfo *ginfo, jint x, jint y)

{

    HRESULT res = S_OK;

    D3DGlyphCache *pGrayscaleGCache;

    CacheCellInfo *cell;

    GlyphCacheInfo *gcache;

    jfloat x1, y1, x2, y2;

    J2dTraceLn(J2D_TRACE_VERBOSE, "D3DTR_DrawGrayscaleGlyphViaCache");

    if (glyphMode != MODE_USE_CACHE_GRAY) {

        D3DTR_DisableGlyphModeState(d3dc);

        res = d3dc->BeginScene(STATE_GLYPHOP);

        RETURN_STATUS_IF_FAILED(res);

        glyphMode = MODE_USE_CACHE_GRAY;

    }

    pGrayscaleGCache = d3dc->GetGrayscaleGlyphCache();

    gcache = pGrayscaleGCache->GetGlyphCache();

    cell = AccelGlyphCache_GetCellInfoForCache(ginfo, gcache);

    if (cell == NULL) {

        // attempt to add glyph to accelerated glyph cache

        res = pGrayscaleGCache->AddGlyph(ginfo);

        RETURN_STATUS_IF_FAILED(res);

        cell = AccelGlyphCache_GetCellInfoForCache(ginfo, gcache);

        RETURN_STATUS_IF_NULL(cell, E_FAIL);

    }

    cell->timesRendered++;

    x1 = (jfloat)x;

    y1 = (jfloat)y;

    x2 = x1 + ginfo->width;

    y2 = y1 + ginfo->height;

    return d3dc->pVCacher->DrawTexture(x1, y1, x2, y2,

                                       cell->tx1, cell->ty1,

                                       cell->tx2, cell->ty2);

}

/**

 * Evaluates to true if the rectangle defined by gx1/gy1/gx2/gy2 is

 * inside outerBounds.

 */

#define INSIDE(gx1, gy1, gx2, gy2, outerBounds) \

    (((gx1) >= outerBounds.x1) && ((gy1) >= outerBounds.y1) && \

     ((gx2) <= outerBounds.x2) && ((gy2) <= outerBounds.y2))

/**

 * Evaluates to true if the rectangle defined by gx1/gy1/gx2/gy2 intersects

 * the rectangle defined by bounds.

 */

#define INTERSECTS(gx1, gy1, gx2, gy2, bounds) \

    ((bounds.x2   > (gx1)) && (bounds.y2 > (gy1)) && \

     (bounds.x1   < (gx2)) && (bounds.y1 < (gy2)))

/**

 * This method checks to see if the given LCD glyph bounds fall within the

 * cached destination texture bounds.  If so, this method can return

 * immediately.  If not, this method will copy a chunk of framebuffer data

 * into the cached destination texture and then update the current cached

 * destination bounds before returning.

 *

 * The agx1, agx2 are "adjusted" glyph bounds, which are only used when checking

 * against the previous glyph bounds.

 */

static HRESULT

D3DTR_UpdateCachedDestination(D3DContext *d3dc, D3DSDOps *dstOps,

                              GlyphInfo *ginfo,

                              jint gx1, jint gy1, jint gx2, jint gy2,

                              jint agx1, jint agx2,

                              jint glyphIndex, jint totalGlyphs)

{

    jint dx1, dy1, dx2, dy2;

    D3DResource *pCachedDestTexRes;

    IDirect3DSurface9 *pCachedDestSurface, *pDst;

    HRESULT res;

    if (isCachedDestValid && INSIDE(gx1, gy1, gx2, gy2, cachedDestBounds)) {

        // glyph is already within the cached destination bounds; no need

        // to read back the entire destination region again, but we do

        // need to see if the current glyph overlaps the previous glyph...

        // only use the "adjusted" glyph bounds when checking against

        // previous glyph's bounds

        gx1 = agx1;

        gx2 = agx2;

        if (INTERSECTS(gx1, gy1, gx2, gy2, previousGlyphBounds)) {

            // the current glyph overlaps the destination region touched

            // by the previous glyph, so now we need to read back the part

            // of the destination corresponding to the previous glyph

            dx1 = previousGlyphBounds.x1;

            dy1 = previousGlyphBounds.y1;

            dx2 = previousGlyphBounds.x2;

            dy2 = previousGlyphBounds.y2;

            // REMIND: make sure we flush any pending primitives that are

            // dependent on the current contents of the cached dest

            d3dc->FlushVertexQueue();

            RETURN_STATUS_IF_NULL(dstOps->pResource, E_FAIL);

            RETURN_STATUS_IF_NULL(pDst = dstOps->pResource->GetSurface(),

                                  E_FAIL);

            res = d3dc->GetResourceManager()->

                GetCachedDestTexture(dstOps->pResource->GetDesc()->Format,

                                     &pCachedDestTexRes);

            RETURN_STATUS_IF_FAILED(res);

            pCachedDestSurface = pCachedDestTexRes->GetSurface();

            // now dxy12 represent the "desired" destination bounds, but the

            // StretchRect() call may fail if these fall outside the actual

            // surface bounds; therefore, we use cxy12 to represent the

            // clamped bounds, and dxy12 are saved for later

            jint cx1 = (dx1 < 0) ? 0 : dx1;

            jint cy1 = (dy1 < 0) ? 0 : dy1;

            jint cx2 = (dx2 > dstOps->width)  ? dstOps->width  : dx2;

            jint cy2 = (dy2 > dstOps->height) ? dstOps->height : dy2;

            if (cx2 > cx1 && cy2 > cy1) {

                // copy destination into subregion of cached texture tile

                //   cx1-cachedDestBounds.x1 == +xoffset from left of texture

                //   cy1-cachedDestBounds.y1 == +yoffset from top of texture

                //   cx2-cachedDestBounds.x1 == +xoffset from left of texture

                //   cy2-cachedDestBounds.y1 == +yoffset from top of texture

                jint cdx1 = cx1-cachedDestBounds.x1;

                jint cdy1 = cy1-cachedDestBounds.y1;

                jint cdx2 = cx2-cachedDestBounds.x1;

                jint cdy2 = cy2-cachedDestBounds.y1;

                RECT srcRect = {  cx1,  cy1,  cx2,  cy2 };

                RECT dstRect = { cdx1, cdy1, cdx2, cdy2 };

                IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

                res = pd3dDevice->StretchRect(pDst, &srcRect,

                                              pCachedDestSurface, &dstRect,

                                              D3DTEXF_NONE);

            }

        }

    } else {

        // destination region is not valid, so we need to read back a

        // chunk of the destination into our cached texture

        // position the upper-left corner of the destination region on the

        // "top" line of glyph list

        // REMIND: this isn't ideal; it would be better if we had some idea

        //         of the bounding box of the whole glyph list (this is

        //         do-able, but would require iterating through the whole

        //         list up front, which may present its own problems)

        dx1 = gx1;

        dy1 = gy1;

        jint remainingWidth;

        if (ginfo->advanceX > 0) {

            // estimate the width based on our current position in the glyph

            // list and using the x advance of the current glyph (this is just

            // a quick and dirty heuristic; if this is a "thin" glyph image,

            // then we're likely to underestimate, and if it's "thick" then we

            // may end up reading back more than we need to)

            remainingWidth =

                (jint)(ginfo->advanceX * (totalGlyphs - glyphIndex));

            if (remainingWidth > D3DTR_CACHED_DEST_WIDTH) {

                remainingWidth = D3DTR_CACHED_DEST_WIDTH;

            } else if (remainingWidth < ginfo->width) {

                // in some cases, the x-advance may be slightly smaller

                // than the actual width of the glyph; if so, adjust our

                remainingWidth = ginfo->width;

            }

        } else {

            // a negative advance is possible when rendering rotated text,

            // in which case it is difficult to estimate an appropriate

            // region for readback, so we will pick a region that

            // encompasses just the current glyph

            remainingWidth = ginfo->width;

        }

        dx2 = dx1 + remainingWidth;

        // estimate the height (this is another sloppy heuristic; we'll

        // make the cached destination region tall enough to encompass most

        // glyphs that are small enough to fit in the glyph cache, and then

        // we add a little something extra to account for descenders

        dy2 = dy1 + D3DTR_CACHE_CELL_HEIGHT + 2;

        // REMIND: make sure we flush any pending primitives that are

        // dependent on the current contents of the cached dest

        d3dc->FlushVertexQueue();

        RETURN_STATUS_IF_NULL(dstOps->pResource, E_FAIL);

        RETURN_STATUS_IF_NULL(pDst = dstOps->pResource->GetSurface(), E_FAIL);

        res = d3dc->GetResourceManager()->

            GetCachedDestTexture(dstOps->pResource->GetDesc()->Format,

                                 &pCachedDestTexRes);

        RETURN_STATUS_IF_FAILED(res);

        pCachedDestSurface = pCachedDestTexRes->GetSurface();

        // now dxy12 represent the "desired" destination bounds, but the

        // StretchRect() call may fail if these fall outside the actual

        // surface bounds; therefore, we use cxy12 to represent the

        // clamped bounds, and dxy12 are saved for later

        jint cx1 = (dx1 < 0) ? 0 : dx1;

        jint cy1 = (dy1 < 0) ? 0 : dy1;

        jint cx2 = (dx2 > dstOps->width)  ? dstOps->width  : dx2;

        jint cy2 = (dy2 > dstOps->height) ? dstOps->height : dy2;

        if (cx2 > cx1 && cy2 > cy1) {

            // copy destination into cached texture tile (the upper-left

            // corner of the destination region will be positioned at the

            // upper-left corner (0,0) of the texture)

            RECT srcRect = { cx1, cy1, cx2, cy2 };

            RECT dstRect = { cx1-dx1, cy1-dy1, cx2-dx1, cy2-dy1 };

            IDirect3DDevice9 *pd3dDevice = d3dc->Get3DDevice();

            res = pd3dDevice->StretchRect(pDst, &srcRect,

                                          pCachedDestSurface, &dstRect,

                                          D3DTEXF_NONE);