| /* | |
| * Copyright (c) 2003, 2019, 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 <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); | |
| GLvoid *pSrc = PtrCoord(srcInfo->rasBase, sx1, srcInfo->pixelStride, | |
| sy1, srcInfo->scanStride); | |
| // 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); | |
| j2d_glBitmap(0, 0, 0, 0, (GLfloat)0, (GLfloat)-scaley, NULL); | |
| pSrc = PtrAddBytes(pSrc, srcInfo->scanStride); | |
| height--; | |
| } | |
| } else { | |
| j2d_glDrawPixels(sx2-sx1, sy2-sy1, pf->format, pf->type, pSrc); | |
| } | |
| 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) { | |
| GLvoid *pSrc = PtrCoord(srcInfo->rasBase, | |
| sx, srcInfo->pixelStride, | |
| sy, srcInfo->scanStride); | |
| 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, | |
| pSrc); | |
| } | |
| // 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)) { | |
| case OGLC_VENDOR_NVIDIA: | |
| // the via-texture codepath tends to be faster when | |
| // there is either a simple scale OR an extra alpha | |
| viaTexture = | |
| (sx2-sx1) != (jint)(dx2-dx1) || | |
| (sy2-sy1) != (jint)(dy2-dy1) || | |
| oglc->extraAlpha != 1.0f; | |
| break; | |
| case OGLC_VENDOR_ATI: | |
| // the via-texture codepath tends to be faster only when | |
| // there is an extra alpha involved (scaling or not) | |
| viaTexture = (oglc->extraAlpha != 1.0f); | |
| break; | |
| default: | |
| // just use the glCopyPixels() codepath | |
| viaTexture = JNI_FALSE; | |
| break; | |
| } | |
| } | |
| RESET_PREVIOUS_OP(); | |
| if (viaTexture) { | |
| OGLBlitToSurfaceViaTexture(oglc, &srcInfo, NULL, srcOps, | |
| JNI_FALSE, hint, | |
| sx1, sy1, sx2, sy2, | |
| dx1, dy1, dx2, dy2); | |
| } else { | |
| OGLBlitSurfaceToSurface(oglc, srcOps, dstOps, | |
| sx1, sy1, sx2, sy2, | |
| dx1, dy1, dx2, dy2); | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * General blit method for copying a system memory ("Sw") surface to a native | |
| * OpenGL surface (of type "Surface" or "Texture"). If texture is JNI_TRUE, | |
| * this method will invoke the Sw->Texture inner loop; otherwise, one of the | |
| * Sw->Surface inner loops will be invoked, depending on the transform state. | |
| */ | |
| void | |
| OGLBlitLoops_Blit(JNIEnv *env, | |
| OGLContext *oglc, jlong pSrcOps, jlong pDstOps, | |
| jboolean xform, jint hint, | |
| jint srctype, jboolean texture, | |
| jint sx1, jint sy1, jint sx2, jint sy2, | |
| jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) | |
| { | |
| SurfaceDataOps *srcOps = (SurfaceDataOps *)jlong_to_ptr(pSrcOps); | |
| OGLSDOps *dstOps = (OGLSDOps *)jlong_to_ptr(pDstOps); | |
| SurfaceDataRasInfo srcInfo; | |
| OGLPixelFormat pf = PixelFormats[srctype]; | |
| jint sw = sx2 - sx1; | |
| jint sh = sy2 - sy1; | |
| jdouble dw = dx2 - dx1; | |
| jdouble dh = dy2 - dy1; | |
| J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_Blit"); | |
| if (sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0 || srctype < 0) { | |
| J2dTraceLn(J2D_TRACE_WARNING, | |
| "OGLBlitLoops_Blit: invalid dimensions or srctype"); | |
| return; | |
| } | |
| RETURN_IF_NULL(srcOps); | |
| RETURN_IF_NULL(dstOps); | |
| RETURN_IF_NULL(oglc); | |
| RESET_PREVIOUS_OP(); | |
| srcInfo.bounds.x1 = sx1; | |
| srcInfo.bounds.y1 = sy1; | |
| srcInfo.bounds.x2 = sx2; | |
| srcInfo.bounds.y2 = sy2; | |
| if (srcOps->Lock(env, srcOps, &srcInfo, SD_LOCK_READ) != SD_SUCCESS) { | |
| J2dTraceLn(J2D_TRACE_WARNING, | |
| "OGLBlitLoops_Blit: could not acquire lock"); | |
| return; | |
| } | |
| if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && | |
| srcInfo.bounds.y2 > srcInfo.bounds.y1) | |
| { | |
| srcOps->GetRasInfo(env, srcOps, &srcInfo); | |
| if (srcInfo.rasBase) { | |
| 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; | |
| } | |
| J2dTraceLn3(J2D_TRACE_VERBOSE, " texture=%d srctype=%d hint=%d", | |
| texture, srctype, 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); | |
| // Note: we will calculate x/y positions in the raster manually | |
| j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); | |
| j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); | |
| j2d_glPixelStorei(GL_UNPACK_ROW_LENGTH, | |
| srcInfo.scanStride / srcInfo.pixelStride); | |
| j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, pf.alignment); | |
| if (texture) { | |
| // These coordinates will always be integers since we | |
| // only ever do a straight copy from sw to texture. | |
| // Thus these casts are "safe" - no loss of precision. | |
| OGLBlitSwToTexture(&srcInfo, &pf, dstOps, | |
| (jint)dx1, (jint)dy1, (jint)dx2, (jint)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)) { | |
| case OGLC_VENDOR_NVIDIA: | |
| // the via-texture codepath tends to be faster when | |
| // there is either a simple scale OR an extra alpha | |
| viaTexture = | |
| (sx2-sx1) != (jint)(dx2-dx1) || | |
| (sy2-sy1) != (jint)(dy2-dy1) || | |
| oglc->extraAlpha != 1.0f; | |
| break; | |
| #ifdef MACOSX | |
| case OGLC_VENDOR_ATI: | |
| // see 8024461 | |
| viaTexture = JNI_TRUE; | |
| break; | |
| #endif | |
| case OGLC_VENDOR_INTEL: | |
| viaTexture = JNI_TRUE; | |
| break; | |
| default: | |
| // just use the glDrawPixels() codepath | |
| viaTexture = JNI_FALSE; | |
| break; | |
| } | |
| } | |
| if (viaTexture) { | |
| OGLBlitToSurfaceViaTexture(oglc, &srcInfo, &pf, NULL, | |
| JNI_TRUE, hint, | |
| sx1, sy1, sx2, sy2, | |
| dx1, dy1, dx2, dy2); | |
| } else { | |
| OGLBlitSwToSurface(oglc, &srcInfo, &pf, | |
| sx1, sy1, sx2, sy2, | |
| dx1, dy1, dx2, dy2); | |
| } | |
| } | |
| j2d_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); | |
| j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, 4); | |
| } | |
| SurfaceData_InvokeRelease(env, srcOps, &srcInfo); | |
| } | |
| SurfaceData_InvokeUnlock(env, srcOps, &srcInfo); | |
| } | |
| /** | |
| * This method makes vertical flip of the provided area of Surface and convert | |
| * pixel's data from argbPre to argb format if requested. | |
| */ | |
| void flip(void *pDst, juint w, juint h, jint scanStride, jboolean convert) { | |
| const size_t clippedStride = 4 * w; | |
| void *tempRow = (h > 1 && !convert) ? malloc(clippedStride) : NULL; | |
| juint i = 0; | |
| juint step = 0; | |
| // vertical flip and convert argbpre to argb if necessary | |
| for (; i < h / 2; ++i) { | |
| juint *r1 = PtrPixelsRow(pDst, i, scanStride); | |
| juint *r2 = PtrPixelsRow(pDst, h - i - 1, scanStride); | |
| if (tempRow) { | |
| // fast path | |
| memcpy(tempRow, r1, clippedStride); | |
| memcpy(r1, r2, clippedStride); | |
| memcpy(r2, tempRow, clippedStride); | |
| } else { | |
| // slow path | |
| for (step = 0; step < w; ++step) { | |
| juint tmp = r1[step]; | |
| if (convert) { | |
| LoadIntArgbPreTo1IntArgb(r2, 0, step, r1[step]); | |
| LoadIntArgbPreTo1IntArgb(&tmp, 0, 0, r2[step]); | |
| } else { | |
| r1[step] = r2[step]; | |
| r2[step] = tmp; | |
| } | |
| } | |
| } | |
| } | |
| // convert the middle line if necessary | |
| if (convert && h % 2) { | |
| juint *r1 = PtrPixelsRow(pDst, i, scanStride); | |
| for (step = 0; step < w; ++step) { | |
| LoadIntArgbPreTo1IntArgb(r1, 0, step, r1[step]); | |
| } | |
| } | |
| if (tempRow) { | |
| free(tempRow); | |
| } | |
| } | |
| /** | |
| * Specialized blit method for copying a native OpenGL "Surface" (pbuffer, | |
| * window, etc.) to a system memory ("Sw") surface. | |
| */ | |
| void | |
| OGLBlitLoops_SurfaceToSwBlit(JNIEnv *env, OGLContext *oglc, | |
| jlong pSrcOps, jlong pDstOps, jint dsttype, | |
| jint srcx, jint srcy, jint dstx, jint dsty, | |
| jint width, jint height) | |
| { | |
| OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); | |
| SurfaceDataOps *dstOps = (SurfaceDataOps *)jlong_to_ptr(pDstOps); | |
| SurfaceDataRasInfo srcInfo, dstInfo; | |
| OGLPixelFormat pf = PixelFormats[dsttype]; | |
| J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_SurfaceToSwBlit"); | |
| if (width <= 0 || height <= 0) { | |
| J2dTraceLn(J2D_TRACE_WARNING, | |
| "OGLBlitLoops_SurfaceToSwBlit: dimensions are non-positive"); | |
| return; | |
| } | |
| RETURN_IF_NULL(srcOps); | |
| RETURN_IF_NULL(dstOps); | |
| RETURN_IF_NULL(oglc); | |
| RESET_PREVIOUS_OP(); | |
| srcInfo.bounds.x1 = srcx; | |
| srcInfo.bounds.y1 = srcy; | |
| srcInfo.bounds.x2 = srcx + width; | |
| srcInfo.bounds.y2 = srcy + height; | |
| dstInfo.bounds.x1 = dstx; | |
| dstInfo.bounds.y1 = dsty; | |
| dstInfo.bounds.x2 = dstx + width; | |
| dstInfo.bounds.y2 = dsty + height; | |
| if (dstOps->Lock(env, dstOps, &dstInfo, SD_LOCK_WRITE) != SD_SUCCESS) { | |
| J2dTraceLn(J2D_TRACE_WARNING, | |
| "OGLBlitLoops_SurfaceToSwBlit: could not acquire dst lock"); | |
| return; | |
| } | |
| SurfaceData_IntersectBoundsXYXY(&srcInfo.bounds, | |
| 0, 0, srcOps->width, srcOps->height); | |
| SurfaceData_IntersectBlitBounds(&dstInfo.bounds, &srcInfo.bounds, | |
| srcx - dstx, srcy - dsty); | |
| if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && | |
| srcInfo.bounds.y2 > srcInfo.bounds.y1) | |
| { | |
| dstOps->GetRasInfo(env, dstOps, &dstInfo); | |
| if (dstInfo.rasBase) { | |
| void *pDst = dstInfo.rasBase; | |
| srcx = srcInfo.bounds.x1; | |
| srcy = srcInfo.bounds.y1; | |
| dstx = dstInfo.bounds.x1; | |
| dsty = dstInfo.bounds.y1; | |
| width = srcInfo.bounds.x2 - srcInfo.bounds.x1; | |
| height = srcInfo.bounds.y2 - srcInfo.bounds.y1; | |
| pDst = PtrAddBytes(pDst, dstx * dstInfo.pixelStride); | |
| pDst = PtrPixelsRow(pDst, dsty, dstInfo.scanStride); | |
| j2d_glPixelStorei(GL_PACK_ROW_LENGTH, | |
| dstInfo.scanStride / dstInfo.pixelStride); | |
| j2d_glPixelStorei(GL_PACK_ALIGNMENT, pf.alignment); | |
| #ifdef MACOSX | |
| if (srcOps->isOpaque) { | |
| // For some reason Apple's OpenGL implementation will | |
| // read back zero values from the alpha channel of an | |
| // opaque surface when using glReadPixels(), so here we | |
| // force the resulting pixels to be fully opaque. | |
| j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0); | |
| } | |
| #endif | |
| J2dTraceLn4(J2D_TRACE_VERBOSE, " sx=%d sy=%d w=%d h=%d", | |
| srcx, srcy, width, height); | |
| J2dTraceLn2(J2D_TRACE_VERBOSE, " dx=%d dy=%d", | |
| dstx, dsty); | |
| // this accounts for lower-left origin of the source region | |
| srcx = srcOps->xOffset + srcx; | |
| srcy = srcOps->yOffset + srcOps->height - srcy - height; | |
| // Note that glReadPixels() is extremely slow! | |
| // So we call it only once and flip the image using memcpy. | |
| j2d_glReadPixels(srcx, srcy, width, height, | |
| pf.format, pf.type, pDst); | |
| // It was checked above that width and height are positive. | |
| flip(pDst, (juint) width, (juint) height, dstInfo.scanStride, | |
| !pf.isPremult && !srcOps->isOpaque); | |
| #ifdef MACOSX | |
| if (srcOps->isOpaque) { | |
| j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0); | |
| } | |
| #endif | |
| j2d_glPixelStorei(GL_PACK_ROW_LENGTH, 0); | |
| j2d_glPixelStorei(GL_PACK_ALIGNMENT, 4); | |
| } | |
| SurfaceData_InvokeRelease(env, dstOps, &dstInfo); | |
| } | |
| SurfaceData_InvokeUnlock(env, dstOps, &dstInfo); | |
| } | |
| void | |
| OGLBlitLoops_CopyArea(JNIEnv *env, | |
| OGLContext *oglc, OGLSDOps *dstOps, | |
| jint x, jint y, jint width, jint height, | |
| jint dx, jint dy) | |
| { | |
| SurfaceDataBounds srcBounds, dstBounds; | |
| J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_CopyArea"); | |
| RETURN_IF_NULL(oglc); | |
| RETURN_IF_NULL(dstOps); | |
| RESET_PREVIOUS_OP(); | |
| J2dTraceLn4(J2D_TRACE_VERBOSE, " x=%d y=%d w=%d h=%d", | |
| x, y, width, height); | |
| J2dTraceLn2(J2D_TRACE_VERBOSE, " dx=%d dy=%d", | |
| dx, dy); | |
| srcBounds.x1 = x; | |
| srcBounds.y1 = y; | |
| srcBounds.x2 = srcBounds.x1 + width; | |
| srcBounds.y2 = srcBounds.y1 + height; | |
| dstBounds.x1 = x + dx; | |
| dstBounds.y1 = y + dy; | |
| dstBounds.x2 = dstBounds.x1 + width; | |
| dstBounds.y2 = dstBounds.y1 + height; | |
| // 6430601: manually clip src/dst parameters to work around | |
| // some bugs in Sun's and Apple's OpenGL implementations | |
| // (it's a good idea to restrict the source parameters anyway, since | |
| // passing out of range parameters to glCopyPixels() will result in | |
| // an OpenGL error) | |
| SurfaceData_IntersectBoundsXYXY(&srcBounds, | |
| 0, 0, dstOps->width, dstOps->height); | |
| SurfaceData_IntersectBoundsXYXY(&dstBounds, | |
| 0, 0, dstOps->width, dstOps->height); | |
| SurfaceData_IntersectBlitBounds(&dstBounds, &srcBounds, -dx, -dy); | |
| if (dstBounds.x1 < dstBounds.x2 && dstBounds.y1 < dstBounds.y2) { | |
| #ifdef MACOSX | |
| if (dstOps->isOpaque) { | |
| // For some reason Apple's OpenGL implementation will fail | |
| // to render glCopyPixels() when the src/dst rectangles are | |
| // overlapping and glColorMask() has disabled writes to the | |
| // alpha channel. The workaround is to temporarily re-enable | |
| // the alpha channel during the glCopyPixels() operation. | |
| j2d_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); | |
| } | |
| #endif | |
| OGLBlitSurfaceToSurface(oglc, dstOps, dstOps, | |
| srcBounds.x1, srcBounds.y1, | |
| srcBounds.x2, srcBounds.y2, | |
| dstBounds.x1, dstBounds.y1, | |
| dstBounds.x2, dstBounds.y2); | |
| #ifdef MACOSX | |
| if (dstOps->isOpaque) { | |
| j2d_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); | |
| } | |
| #endif | |
| } | |
| } | |
| #endif /* !HEADLESS */ |