/*

 * 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 <jni.h>

#include <jlong.h>

#include "SurfaceData.h"

#include "OGLBlitLoops.h"

#include "OGLRenderQueue.h"

#include "OGLSurfaceData.h"

#include "GraphicsPrimitiveMgr.h"

#include <stdlib.h> // malloc

#include <string.h> // memcpy

#include "IntArgbPre.h"

extern OGLPixelFormat PixelFormats[];

/**

 * Inner loop used for copying a source OpenGL "Surface" (window, pbuffer,

 * etc.) to a destination OpenGL "Surface".  Note that the same surface can

 * be used as both the source and destination, as is the case in a copyArea()

 * operation.  This method is invoked from OGLBlitLoops_IsoBlit() as well as

 * OGLBlitLoops_CopyArea().

 *

 * The standard glCopyPixels() mechanism is used to copy the source region

 * into the destination region.  If the regions have different dimensions,

 * the source will be scaled into the destination as appropriate (only

 * nearest neighbor filtering will be applied for simple scale operations).

 */

static void

OGLBlitSurfaceToSurface(OGLContext *oglc, OGLSDOps *srcOps, OGLSDOps *dstOps,

                        jint sx1, jint sy1, jint sx2, jint sy2,

                        jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2)

{

    GLfloat scalex, scaley;

    jint srcw = sx2 - sx1;

    jint srch = sy2 - sy1;

    scalex = ((GLfloat)(dx2-dx1)) / srcw;

    scaley = ((GLfloat)(dy2-dy1)) / srch;

    // the following lines account for the fact that glCopyPixels() copies a

    // region whose lower-left corner is at (x,y), but the source parameters

    // (sx1,sy1) we are given here point to the upper-left corner of the

    // source region... so here we play with the sy1 and dy1 parameters so

    // that they point to the lower-left corners of the regions...

    sx1 = srcOps->xOffset + sx1;

    sy1 = srcOps->yOffset + srcOps->height - sy2;

    dy1 = dy2;

    if (oglc->extraAlpha != 1.0f) {

        OGLContext_SetExtraAlpha(oglc->extraAlpha);

    }

    // see OGLBlitSwToSurface() for more info on the following two lines

    j2d_glRasterPos2i(0, 0);

    j2d_glBitmap(0, 0, 0, 0, (GLfloat)dx1, (GLfloat)-dy1, NULL);

    if (scalex == 1.0f && scaley == 1.0f) {

        j2d_glCopyPixels(sx1, sy1, srcw, srch, GL_COLOR);

    } else {

        j2d_glPixelZoom(scalex, scaley);

        j2d_glCopyPixels(sx1, sy1, srcw, srch, GL_COLOR);

        j2d_glPixelZoom(1.0f, 1.0f);

    }

    if (oglc->extraAlpha != 1.0f) {

        OGLContext_SetExtraAlpha(1.0f);

    }

}

/**

 * Inner loop used for copying a source OpenGL "Texture" to a destination

 * OpenGL "Surface".  This method is invoked from OGLBlitLoops_IsoBlit().

 *

 * This method will copy, scale, or transform the source texture into the

 * destination depending on the transform state, as established in

 * and OGLContext_SetTransform().  If the source texture is

 * transformed in any way when rendered into the destination, the filtering

 * method applied is determined by the hint parameter (can be GL_NEAREST or

 * GL_LINEAR).

 */

static void

OGLBlitTextureToSurface(OGLContext *oglc,

                        OGLSDOps *srcOps, OGLSDOps *dstOps,

                        jboolean rtt, jint hint,

                        jint sx1, jint sy1, jint sx2, jint sy2,

                        jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2)

{

    GLdouble tx1, ty1, tx2, ty2;

    if (rtt) {

        /*

         * The source is a render-to-texture surface.  These surfaces differ

         * from regular texture objects in that the bottom scanline (of

         * the actual image content) coincides with the top edge of the

         * texture object.  Therefore, we need to adjust the sy1/sy2

         * coordinates relative to the top scanline of the image content.

         *

         * In texture coordinates, the top-left corner of the image content

         * would be at:

         *     (0.0, (imgHeight/texHeight))

         * while the bottom-right corner corresponds to:

         *     ((imgWidth/texWidth), 0.0)

         */

        sy1 = srcOps->height - sy1;

        sy2 = srcOps->height - sy2;

    }

    if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) {

        // The GL_ARB_texture_rectangle extension requires that we specify

        // texture coordinates in the range [0,srcw] and [0,srch] instead of

        // [0,1] as we would normally do in the case of GL_TEXTURE_2D

        tx1 = (GLdouble)sx1;

        ty1 = (GLdouble)sy1;

        tx2 = (GLdouble)sx2;

        ty2 = (GLdouble)sy2;

    } else {

        // Otherwise we need to convert the source bounds into the range [0,1]

        tx1 = ((GLdouble)sx1) / srcOps->textureWidth;

        ty1 = ((GLdouble)sy1) / srcOps->textureHeight;

        tx2 = ((GLdouble)sx2) / srcOps->textureWidth;

        ty2 = ((GLdouble)sy2) / srcOps->textureHeight;

    }

    // Note that we call CHECK_PREVIOUS_OP(texTarget) in IsoBlit(), which

    // will call glEnable(texTarget) as necessary.

    j2d_glBindTexture(srcOps->textureTarget, srcOps->textureID);

    OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE);

    OGLSD_UPDATE_TEXTURE_FILTER(srcOps, hint);

    j2d_glBegin(GL_QUADS);

    j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx1, dy1);

    j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx2, dy1);

    j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx2, dy2);

    j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx1, dy2);

    j2d_glEnd();

}

/**

 * Inner loop used for copying a source system memory ("Sw") surface to a

 * destination OpenGL "Surface".  This method is invoked from

 * OGLBlitLoops_Blit().

 *

 * The standard glDrawPixels() mechanism is used to copy the source region

 * into the destination region.  If the regions have different

 * dimensions, the source will be scaled into the destination

 * as appropriate (only nearest neighbor filtering will be applied for simple

 * scale operations).

 */

static void

OGLBlitSwToSurface(OGLContext *oglc, SurfaceDataRasInfo *srcInfo,

                   OGLPixelFormat *pf,

                   jint sx1, jint sy1, jint sx2, jint sy2,

                   jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2)

{

    GLfloat scalex, scaley;

    scalex = ((GLfloat)(dx2-dx1)) / (sx2-sx1);

    scaley = ((GLfloat)(dy2-dy1)) / (sy2-sy1);

    if (oglc->extraAlpha != 1.0f) {

        OGLContext_SetExtraAlpha(oglc->extraAlpha);

    }

    if (!pf->hasAlpha) {

        // if the source surface does not have an alpha channel,

        // we need to ensure that the alpha values are forced to

        // the current extra alpha value (see OGLContext_SetExtraAlpha()

        // for more information)

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, oglc->extraAlpha);

    }

    // This is a rather intriguing (yet totally valid) hack... If we were to

    // specify a raster position that is outside the surface bounds, the raster

    // position would be invalid and nothing would be rendered.  However, we

    // can use a widely known trick to move the raster position outside the

    // surface bounds while maintaining its status as valid.  The following

    // call to glBitmap() renders a no-op bitmap, but offsets the current

    // raster position from (0,0) to the desired location of (dx1,-dy1)...

    j2d_glRasterPos2i(0, 0);

    j2d_glBitmap(0, 0, 0, 0, (GLfloat)dx1, (GLfloat)-dy1, NULL);

    j2d_glPixelZoom(scalex, -scaley);

    // in case pixel stride is not a multiple of scanline stride the copy

    // has to be done line by line (see 6207877)

    if (srcInfo->scanStride % srcInfo->pixelStride != 0) {

        jint width = sx2-sx1;

        jint height = sy2-sy1;

        while (height > 0) {

            j2d_glDrawPixels(width, 1, pf->format, pf->type, pSrc);

            pSrc = PtrAddBytes(pSrc, srcInfo->scanStride);

            height--;

        }

    } else {

    }

    j2d_glPixelZoom(1.0, 1.0);

    if (oglc->extraAlpha != 1.0f) {

        OGLContext_SetExtraAlpha(1.0f);

    }

    if (!pf->hasAlpha) {

        // restore scale/bias to their original values

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f);

    }

}

/**

 * Inner loop used for copying a source system memory ("Sw") surface or

 * OpenGL "Surface" to a destination OpenGL "Surface", using an OpenGL texture

 * tile as an intermediate surface.  This method is invoked from

 * OGLBlitLoops_Blit() for "Sw" surfaces and OGLBlitLoops_IsoBlit() for

 * "Surface" surfaces.

 *

 * This method is used to transform the source surface into the destination.

 * Pixel rectangles cannot be arbitrarily transformed (without the

 * GL_EXT_pixel_transform extension, which is not supported on most modern

 * hardware).  However, texture mapped quads do respect the GL_MODELVIEW

 * transform matrix, so we use textures here to perform the transform

 * operation.  This method uses a tile-based approach in which a small

 * subregion of the source surface is copied into a cached texture tile.  The

 * texture tile is then mapped into the appropriate location in the

 * destination surface.

 *

 * REMIND: this only works well using GL_NEAREST for the filtering mode

 *         (GL_LINEAR causes visible stitching problems between tiles,

 *         but this can be fixed by making use of texture borders)

 */

static void

OGLBlitToSurfaceViaTexture(OGLContext *oglc, SurfaceDataRasInfo *srcInfo,

                           OGLPixelFormat *pf, OGLSDOps *srcOps,

                           jboolean swsurface, jint hint,

                           jint sx1, jint sy1, jint sx2, jint sy2,

                           jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2)

{

    GLdouble tx1, ty1, tx2, ty2;

    GLdouble dx, dy, dw, dh, cdw, cdh;

    jint tw, th;

    jint sx, sy, sw, sh;

    GLint glhint = (hint == OGLSD_XFORM_BILINEAR) ? GL_LINEAR : GL_NEAREST;

    jboolean adjustAlpha = (pf != NULL && !pf->hasAlpha);

    jboolean slowPath;

    if (oglc->blitTextureID == 0) {

        if (!OGLContext_InitBlitTileTexture(oglc)) {

            J2dRlsTraceLn(J2D_TRACE_ERROR,

                "OGLBlitToSurfaceViaTexture: could not init blit tile");

            return;

        }

    }

    tx1 = 0.0f;

    ty1 = 0.0f;

    tw = OGLC_BLIT_TILE_SIZE;

    th = OGLC_BLIT_TILE_SIZE;

    cdw = (dx2-dx1) / (((GLdouble)(sx2-sx1)) / OGLC_BLIT_TILE_SIZE);

    cdh = (dy2-dy1) / (((GLdouble)(sy2-sy1)) / OGLC_BLIT_TILE_SIZE);

    j2d_glEnable(GL_TEXTURE_2D);

    j2d_glBindTexture(GL_TEXTURE_2D, oglc->blitTextureID);

    OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE);

    j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glhint);

    j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glhint);

    if (adjustAlpha) {

        // if the source surface does not have an alpha channel,

        // we need to ensure that the alpha values are forced to 1.0f

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0f);

    }

    // in case pixel stride is not a multiple of scanline stride the copy

    // has to be done line by line (see 6207877)

    slowPath = srcInfo->scanStride % srcInfo->pixelStride != 0;

    for (sy = sy1, dy = dy1; sy < sy2; sy += th, dy += cdh) {

        sh = ((sy + th) > sy2) ? (sy2 - sy) : th;

        dh = ((dy + cdh) > dy2) ? (dy2 - dy) : cdh;

        for (sx = sx1, dx = dx1; sx < sx2; sx += tw, dx += cdw) {

            sw = ((sx + tw) > sx2) ? (sx2 - sx) : tw;

            dw = ((dx + cdw) > dx2) ? (dx2 - dx) : cdw;

            tx2 = ((GLdouble)sw) / tw;

            ty2 = ((GLdouble)sh) / th;

            if (swsurface) {

                if (slowPath) {

                    jint tmph = sh;

                    while (tmph > 0) {

                        j2d_glTexSubImage2D(GL_TEXTURE_2D, 0,

                                            0, sh - tmph, sw, 1,

                                            pf->format, pf->type,

                                            pSrc);

                        pSrc = PtrAddBytes(pSrc, srcInfo->scanStride);

                        tmph--;

                    }

                } else {

                    j2d_glTexSubImage2D(GL_TEXTURE_2D, 0,

                                        0, 0, sw, sh,

                                        pf->format, pf->type,

                }

                // the texture image is "right side up", so we align the

                // upper-left texture corner with the upper-left quad corner

                j2d_glBegin(GL_QUADS);

                j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx, dy);

                j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx + dw, dy);

                j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx + dw, dy + dh);

                j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx, dy + dh);

                j2d_glEnd();

            } else {

                // this accounts for lower-left origin of the source region

                jint newsx = srcOps->xOffset + sx;

                jint newsy = srcOps->yOffset + srcOps->height - (sy + sh);

                j2d_glCopyTexSubImage2D(GL_TEXTURE_2D, 0,

                                        0, 0, newsx, newsy, sw, sh);

                // the texture image is "upside down" after the last step, so

                // we align the bottom-left texture corner with the upper-left

                // quad corner (and vice versa) to effectively flip the

                // texture image

                j2d_glBegin(GL_QUADS);

                j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx, dy);

                j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx + dw, dy);

                j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx + dw, dy + dh);

                j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx, dy + dh);

                j2d_glEnd();

            }

        }

    }

    if (adjustAlpha) {

        // restore scale/bias to their original values

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f);

    }

    j2d_glDisable(GL_TEXTURE_2D);

}

/**

 * Inner loop used for copying a source system memory ("Sw") surface to a

 * destination OpenGL "Texture".  This method is invoked from

 * OGLBlitLoops_Blit().

 *

 * The source surface is effectively loaded into the OpenGL texture object,

 * which must have already been initialized by OGLSD_initTexture().  Note

 * that this method is only capable of copying the source surface into the

 * destination surface (i.e. no scaling or general transform is allowed).

 * This restriction should not be an issue as this method is only used

 * currently to cache a static system memory image into an OpenGL texture in

 * a hidden-acceleration situation.

 */

static void

OGLBlitSwToTexture(SurfaceDataRasInfo *srcInfo, OGLPixelFormat *pf,

                   OGLSDOps *dstOps,

                   jint dx1, jint dy1, jint dx2, jint dy2)

{

    jboolean adjustAlpha = (pf != NULL && !pf->hasAlpha);

    j2d_glBindTexture(dstOps->textureTarget, dstOps->textureID);

    if (adjustAlpha) {

        // if the source surface does not have an alpha channel,

        // we need to ensure that the alpha values are forced to 1.0f

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0f);

    }

    // in case pixel stride is not a multiple of scanline stride the copy

    // has to be done line by line (see 6207877)

    if (srcInfo->scanStride % srcInfo->pixelStride != 0) {

        jint width = dx2 - dx1;

        jint height = dy2 - dy1;

        GLvoid *pSrc = srcInfo->rasBase;

        while (height > 0) {

            j2d_glTexSubImage2D(dstOps->textureTarget, 0,

                                dx1, dy2 - height, width, 1,

                                pf->format, pf->type, pSrc);

            pSrc = PtrAddBytes(pSrc, srcInfo->scanStride);

            height--;

        }

    } else {

        j2d_glTexSubImage2D(dstOps->textureTarget, 0,

                            dx1, dy1, dx2-dx1, dy2-dy1,

                            pf->format, pf->type, srcInfo->rasBase);

    }

    if (adjustAlpha) {

        // restore scale/bias to their original values

        j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f);

        j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f);

    }

}

/**

 * General blit method for copying a native OpenGL surface (of type "Surface"

 * or "Texture") to another OpenGL "Surface".  If texture is JNI_TRUE, this

 * method will invoke the Texture->Surface inner loop; otherwise, one of the

 * Surface->Surface inner loops will be invoked, depending on the transform

 * state.

 *

 * REMIND: we can trick these blit methods into doing XOR simply by passing

 *         in the (pixel ^ xorpixel) as the pixel value and preceding the

 *         blit with a fillrect...

 */

void

OGLBlitLoops_IsoBlit(JNIEnv *env,

                     OGLContext *oglc, jlong pSrcOps, jlong pDstOps,

                     jboolean xform, jint hint,

                     jboolean texture, jboolean rtt,

                     jint sx1, jint sy1, jint sx2, jint sy2,

                     jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2)

{

    OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps);

    OGLSDOps *dstOps = (OGLSDOps *)jlong_to_ptr(pDstOps);

    SurfaceDataRasInfo srcInfo;

    jint sw    = sx2 - sx1;

    jint sh    = sy2 - sy1;

    jdouble dw = dx2 - dx1;

    jdouble dh = dy2 - dy1;

    J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_IsoBlit");

    if (sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0) {

        J2dTraceLn(J2D_TRACE_WARNING,

                   "OGLBlitLoops_IsoBlit: invalid dimensions");

        return;

    }

    RETURN_IF_NULL(srcOps);

    RETURN_IF_NULL(dstOps);

    RETURN_IF_NULL(oglc);

    srcInfo.bounds.x1 = sx1;

    srcInfo.bounds.y1 = sy1;

    srcInfo.bounds.x2 = sx2;

    srcInfo.bounds.y2 = sy2;

    SurfaceData_IntersectBoundsXYXY(&srcInfo.bounds,

                                    0, 0, srcOps->width, srcOps->height);

    if (srcInfo.bounds.x2 > srcInfo.bounds.x1 &&

        srcInfo.bounds.y2 > srcInfo.bounds.y1)

    {

        if (srcInfo.bounds.x1 != sx1) {

            dx1 += (srcInfo.bounds.x1 - sx1) * (dw / sw);

            sx1 = srcInfo.bounds.x1;

        }

        if (srcInfo.bounds.y1 != sy1) {

            dy1 += (srcInfo.bounds.y1 - sy1) * (dh / sh);

            sy1 = srcInfo.bounds.y1;

        }

        if (srcInfo.bounds.x2 != sx2) {

            dx2 += (srcInfo.bounds.x2 - sx2) * (dw / sw);

            sx2 = srcInfo.bounds.x2;

        }

        if (srcInfo.bounds.y2 != sy2) {

            dy2 += (srcInfo.bounds.y2 - sy2) * (dh / sh);

            sy2 = srcInfo.bounds.y2;

        }

        J2dTraceLn2(J2D_TRACE_VERBOSE, "  texture=%d hint=%d", texture, hint);

        J2dTraceLn4(J2D_TRACE_VERBOSE, "  sx1=%d sy1=%d sx2=%d sy2=%d",

                    sx1, sy1, sx2, sy2);

        J2dTraceLn4(J2D_TRACE_VERBOSE, "  dx1=%f dy1=%f dx2=%f dy2=%f",

                    dx1, dy1, dx2, dy2);

        if (texture) {

            GLint glhint = (hint == OGLSD_XFORM_BILINEAR) ? GL_LINEAR :

                                                            GL_NEAREST;

            CHECK_PREVIOUS_OP(srcOps->textureTarget);

            OGLBlitTextureToSurface(oglc, srcOps, dstOps, rtt, glhint,

                                    sx1, sy1, sx2, sy2,

                                    dx1, dy1, dx2, dy2);

        } else {

            jboolean viaTexture;

            if (xform) {

                // we must use the via-texture codepath when there is a xform

                viaTexture = JNI_TRUE;

            } else {

                // look at the vendor to see which codepath is faster

                // (this has been empirically determined; see 5020009)

                switch (OGLC_GET_VENDOR(oglc)) {