1 /* 2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 #ifndef HEADLESS 27 28 #include <jni.h> 29 #include <jlong.h> 30 31 #include "SurfaceData.h" 32 #include "OGLBlitLoops.h" 33 #include "OGLRenderQueue.h" 34 #include "OGLSurfaceData.h" 35 #include "GraphicsPrimitiveMgr.h" 36 37 extern OGLPixelFormat PixelFormats[]; 38 39 /** 40 * Inner loop used for copying a source OpenGL "Surface" (window, pbuffer, 41 * etc.) to a destination OpenGL "Surface". Note that the same surface can 42 * be used as both the source and destination, as is the case in a copyArea() 43 * operation. This method is invoked from OGLBlitLoops_IsoBlit() as well as 44 * OGLBlitLoops_CopyArea(). 45 * 46 * The standard glCopyPixels() mechanism is used to copy the source region 47 * into the destination region. If the regions have different dimensions, 48 * the source will be scaled into the destination as appropriate (only 49 * nearest neighbor filtering will be applied for simple scale operations). 50 */ 51 static void 52 OGLBlitSurfaceToSurface(OGLContext *oglc, OGLSDOps *srcOps, OGLSDOps *dstOps, 53 jint sx1, jint sy1, jint sx2, jint sy2, 54 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 55 { 56 GLfloat scalex, scaley; 57 jint srcw = sx2 - sx1; 58 jint srch = sy2 - sy1; 59 60 scalex = ((GLfloat)(dx2-dx1)) / srcw; 61 scaley = ((GLfloat)(dy2-dy1)) / srch; 62 63 // the following lines account for the fact that glCopyPixels() copies a 64 // region whose lower-left corner is at (x,y), but the source parameters 65 // (sx1,sy1) we are given here point to the upper-left corner of the 66 // source region... so here we play with the sy1 and dy1 parameters so 67 // that they point to the lower-left corners of the regions... 68 sx1 = srcOps->xOffset + sx1; 69 sy1 = srcOps->yOffset + srcOps->height - sy2; 70 dy1 = dy2; 71 72 if (oglc->extraAlpha != 1.0f) { 73 OGLContext_SetExtraAlpha(oglc->extraAlpha); 74 } 75 76 // see OGLBlitSwToSurface() for more info on the following two lines 77 j2d_glRasterPos2i(0, 0); 78 j2d_glBitmap(0, 0, 0, 0, (GLfloat)dx1, (GLfloat)-dy1, NULL); 79 80 if (scalex == 1.0f && scaley == 1.0f) { 81 j2d_glCopyPixels(sx1, sy1, srcw, srch, GL_COLOR); 82 } else { 83 j2d_glPixelZoom(scalex, scaley); 84 j2d_glCopyPixels(sx1, sy1, srcw, srch, GL_COLOR); 85 j2d_glPixelZoom(1.0f, 1.0f); 86 } 87 88 if (oglc->extraAlpha != 1.0f) { 89 OGLContext_SetExtraAlpha(1.0f); 90 } 91 } 92 93 /** 94 * Inner loop used for copying a source OpenGL "Texture" to a destination 95 * OpenGL "Surface". This method is invoked from OGLBlitLoops_IsoBlit(). 96 * 97 * This method will copy, scale, or transform the source texture into the 98 * destination depending on the transform state, as established in 99 * and OGLContext_SetTransform(). If the source texture is 100 * transformed in any way when rendered into the destination, the filtering 101 * method applied is determined by the hint parameter (can be GL_NEAREST or 102 * GL_LINEAR). 103 */ 104 static void 105 OGLBlitTextureToSurface(OGLContext *oglc, 106 OGLSDOps *srcOps, OGLSDOps *dstOps, 107 jboolean rtt, jint hint, 108 jint sx1, jint sy1, jint sx2, jint sy2, 109 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 110 { 111 GLdouble tx1, ty1, tx2, ty2; 112 113 if (rtt) { 114 /* 115 * The source is a render-to-texture surface. These surfaces differ 116 * from regular texture objects in that the bottom scanline (of 117 * the actual image content) coincides with the top edge of the 118 * texture object. Therefore, we need to adjust the sy1/sy2 119 * coordinates relative to the top scanline of the image content. 120 * 121 * In texture coordinates, the top-left corner of the image content 122 * would be at: 123 * (0.0, (imgHeight/texHeight)) 124 * while the bottom-right corner corresponds to: 125 * ((imgWidth/texWidth), 0.0) 126 */ 127 sy1 = srcOps->height - sy1; 128 sy2 = srcOps->height - sy2; 129 } 130 131 if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) { 132 // The GL_ARB_texture_rectangle extension requires that we specify 133 // texture coordinates in the range [0,srcw] and [0,srch] instead of 134 // [0,1] as we would normally do in the case of GL_TEXTURE_2D 135 tx1 = (GLdouble)sx1; 136 ty1 = (GLdouble)sy1; 137 tx2 = (GLdouble)sx2; 138 ty2 = (GLdouble)sy2; 139 } else { 140 // Otherwise we need to convert the source bounds into the range [0,1] 141 tx1 = ((GLdouble)sx1) / srcOps->textureWidth; 142 ty1 = ((GLdouble)sy1) / srcOps->textureHeight; 143 tx2 = ((GLdouble)sx2) / srcOps->textureWidth; 144 ty2 = ((GLdouble)sy2) / srcOps->textureHeight; 145 } 146 147 // Note that we call CHECK_PREVIOUS_OP(texTarget) in IsoBlit(), which 148 // will call glEnable(texTarget) as necessary. 149 j2d_glBindTexture(srcOps->textureTarget, srcOps->textureID); 150 OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE); 151 OGLSD_UPDATE_TEXTURE_FILTER(srcOps, hint); 152 153 j2d_glBegin(GL_QUADS); 154 j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx1, dy1); 155 j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx2, dy1); 156 j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx2, dy2); 157 j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx1, dy2); 158 j2d_glEnd(); 159 } 160 161 /** 162 * Inner loop used for copying a source system memory ("Sw") surface to a 163 * destination OpenGL "Surface". This method is invoked from 164 * OGLBlitLoops_Blit(). 165 * 166 * The standard glDrawPixels() mechanism is used to copy the source region 167 * into the destination region. If the regions have different 168 * dimensions, the source will be scaled into the destination 169 * as appropriate (only nearest neighbor filtering will be applied for simple 170 * scale operations). 171 */ 172 static void 173 OGLBlitSwToSurface(OGLContext *oglc, SurfaceDataRasInfo *srcInfo, 174 OGLPixelFormat *pf, 175 jint sx1, jint sy1, jint sx2, jint sy2, 176 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 177 { 178 GLfloat scalex, scaley; 179 180 scalex = ((GLfloat)(dx2-dx1)) / (sx2-sx1); 181 scaley = ((GLfloat)(dy2-dy1)) / (sy2-sy1); 182 183 if (oglc->extraAlpha != 1.0f) { 184 OGLContext_SetExtraAlpha(oglc->extraAlpha); 185 } 186 if (!pf->hasAlpha) { 187 // if the source surface does not have an alpha channel, 188 // we need to ensure that the alpha values are forced to 189 // the current extra alpha value (see OGLContext_SetExtraAlpha() 190 // for more information) 191 j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f); 192 j2d_glPixelTransferf(GL_ALPHA_BIAS, oglc->extraAlpha); 193 } 194 195 // This is a rather intriguing (yet totally valid) hack... If we were to 196 // specify a raster position that is outside the surface bounds, the raster 197 // position would be invalid and nothing would be rendered. However, we 198 // can use a widely known trick to move the raster position outside the 199 // surface bounds while maintaining its status as valid. The following 200 // call to glBitmap() renders a no-op bitmap, but offsets the current 201 // raster position from (0,0) to the desired location of (dx1,-dy1)... 202 j2d_glRasterPos2i(0, 0); 203 j2d_glBitmap(0, 0, 0, 0, (GLfloat)dx1, (GLfloat)-dy1, NULL); 204 205 j2d_glPixelZoom(scalex, -scaley); 206 207 // in case pixel stride is not a multiple of scanline stride the copy 208 // has to be done line by line (see 6207877) 209 if (srcInfo->scanStride % srcInfo->pixelStride != 0) { 210 jint width = sx2-sx1; 211 jint height = sy2-sy1; 212 GLvoid *pSrc = srcInfo->rasBase; 213 214 while (height > 0) { 215 j2d_glDrawPixels(width, 1, pf->format, pf->type, pSrc); 216 j2d_glBitmap(0, 0, 0, 0, (GLfloat)0, (GLfloat)-1, NULL); 217 pSrc = PtrAddBytes(pSrc, srcInfo->scanStride); 218 height--; 219 } 220 } else { 221 j2d_glDrawPixels(sx2-sx1, sy2-sy1, pf->format, pf->type, srcInfo->rasBase); 222 } 223 224 j2d_glPixelZoom(1.0, 1.0); 225 226 if (oglc->extraAlpha != 1.0f) { 227 OGLContext_SetExtraAlpha(1.0f); 228 } 229 if (!pf->hasAlpha) { 230 // restore scale/bias to their original values 231 j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f); 232 j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f); 233 } 234 } 235 236 /** 237 * Inner loop used for copying a source system memory ("Sw") surface or 238 * OpenGL "Surface" to a destination OpenGL "Surface", using an OpenGL texture 239 * tile as an intermediate surface. This method is invoked from 240 * OGLBlitLoops_Blit() for "Sw" surfaces and OGLBlitLoops_IsoBlit() for 241 * "Surface" surfaces. 242 * 243 * This method is used to transform the source surface into the destination. 244 * Pixel rectangles cannot be arbitrarily transformed (without the 245 * GL_EXT_pixel_transform extension, which is not supported on most modern 246 * hardware). However, texture mapped quads do respect the GL_MODELVIEW 247 * transform matrix, so we use textures here to perform the transform 248 * operation. This method uses a tile-based approach in which a small 249 * subregion of the source surface is copied into a cached texture tile. The 250 * texture tile is then mapped into the appropriate location in the 251 * destination surface. 252 * 253 * REMIND: this only works well using GL_NEAREST for the filtering mode 254 * (GL_LINEAR causes visible stitching problems between tiles, 255 * but this can be fixed by making use of texture borders) 256 */ 257 static void 258 OGLBlitToSurfaceViaTexture(OGLContext *oglc, SurfaceDataRasInfo *srcInfo, 259 OGLPixelFormat *pf, OGLSDOps *srcOps, 260 jboolean swsurface, jint hint, 261 jint sx1, jint sy1, jint sx2, jint sy2, 262 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 263 { 264 GLdouble tx1, ty1, tx2, ty2; 265 GLdouble dx, dy, dw, dh, cdw, cdh; 266 jint tw, th; 267 jint sx, sy, sw, sh; 268 GLint glhint = (hint == OGLSD_XFORM_BILINEAR) ? GL_LINEAR : GL_NEAREST; 269 jboolean adjustAlpha = (pf != NULL && !pf->hasAlpha); 270 jboolean slowPath; 271 272 if (oglc->blitTextureID == 0) { 273 if (!OGLContext_InitBlitTileTexture(oglc)) { 274 J2dRlsTraceLn(J2D_TRACE_ERROR, 275 "OGLBlitToSurfaceViaTexture: could not init blit tile"); 276 return; 277 } 278 } 279 280 tx1 = 0.0f; 281 ty1 = 0.0f; 282 tw = OGLC_BLIT_TILE_SIZE; 283 th = OGLC_BLIT_TILE_SIZE; 284 cdw = (dx2-dx1) / (((GLdouble)(sx2-sx1)) / OGLC_BLIT_TILE_SIZE); 285 cdh = (dy2-dy1) / (((GLdouble)(sy2-sy1)) / OGLC_BLIT_TILE_SIZE); 286 287 j2d_glEnable(GL_TEXTURE_2D); 288 j2d_glBindTexture(GL_TEXTURE_2D, oglc->blitTextureID); 289 OGLC_UPDATE_TEXTURE_FUNCTION(oglc, GL_MODULATE); 290 j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, glhint); 291 j2d_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, glhint); 292 293 if (adjustAlpha) { 294 // if the source surface does not have an alpha channel, 295 // we need to ensure that the alpha values are forced to 1.0f 296 j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f); 297 j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0f); 298 } 299 300 // in case pixel stride is not a multiple of scanline stride the copy 301 // has to be done line by line (see 6207877) 302 slowPath = srcInfo->scanStride % srcInfo->pixelStride != 0; 303 304 for (sy = sy1, dy = dy1; sy < sy2; sy += th, dy += cdh) { 305 sh = ((sy + th) > sy2) ? (sy2 - sy) : th; 306 dh = ((dy + cdh) > dy2) ? (dy2 - dy) : cdh; 307 308 for (sx = sx1, dx = dx1; sx < sx2; sx += tw, dx += cdw) { 309 sw = ((sx + tw) > sx2) ? (sx2 - sx) : tw; 310 dw = ((dx + cdw) > dx2) ? (dx2 - dx) : cdw; 311 312 tx2 = ((GLdouble)sw) / tw; 313 ty2 = ((GLdouble)sh) / th; 314 315 if (swsurface) { 316 if (slowPath) { 317 jint tmph = sh; 318 GLvoid *pSrc = PtrCoord(srcInfo->rasBase, 319 sx, srcInfo->pixelStride, 320 sy, srcInfo->scanStride); 321 322 while (tmph > 0) { 323 j2d_glTexSubImage2D(GL_TEXTURE_2D, 0, 324 0, sh - tmph, sw, 1, 325 pf->format, pf->type, 326 pSrc); 327 pSrc = PtrAddBytes(pSrc, srcInfo->scanStride); 328 tmph--; 329 } 330 } else { 331 j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx); 332 j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, sy); 333 334 j2d_glTexSubImage2D(GL_TEXTURE_2D, 0, 335 0, 0, sw, sh, 336 pf->format, pf->type, 337 srcInfo->rasBase); 338 } 339 340 // the texture image is "right side up", so we align the 341 // upper-left texture corner with the upper-left quad corner 342 j2d_glBegin(GL_QUADS); 343 j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx, dy); 344 j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx + dw, dy); 345 j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx + dw, dy + dh); 346 j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx, dy + dh); 347 j2d_glEnd(); 348 } else { 349 // this accounts for lower-left origin of the source region 350 jint newsx = srcOps->xOffset + sx; 351 jint newsy = srcOps->yOffset + srcOps->height - (sy + sh); 352 j2d_glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 353 0, 0, newsx, newsy, sw, sh); 354 355 // the texture image is "upside down" after the last step, so 356 // we align the bottom-left texture corner with the upper-left 357 // quad corner (and vice versa) to effectively flip the 358 // texture image 359 j2d_glBegin(GL_QUADS); 360 j2d_glTexCoord2d(tx1, ty2); j2d_glVertex2d(dx, dy); 361 j2d_glTexCoord2d(tx2, ty2); j2d_glVertex2d(dx + dw, dy); 362 j2d_glTexCoord2d(tx2, ty1); j2d_glVertex2d(dx + dw, dy + dh); 363 j2d_glTexCoord2d(tx1, ty1); j2d_glVertex2d(dx, dy + dh); 364 j2d_glEnd(); 365 } 366 } 367 } 368 369 if (adjustAlpha) { 370 // restore scale/bias to their original values 371 j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f); 372 j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f); 373 } 374 375 j2d_glDisable(GL_TEXTURE_2D); 376 } 377 378 /** 379 * Inner loop used for copying a source system memory ("Sw") surface to a 380 * destination OpenGL "Texture". This method is invoked from 381 * OGLBlitLoops_Blit(). 382 * 383 * The source surface is effectively loaded into the OpenGL texture object, 384 * which must have already been initialized by OGLSD_initTexture(). Note 385 * that this method is only capable of copying the source surface into the 386 * destination surface (i.e. no scaling or general transform is allowed). 387 * This restriction should not be an issue as this method is only used 388 * currently to cache a static system memory image into an OpenGL texture in 389 * a hidden-acceleration situation. 390 */ 391 static void 392 OGLBlitSwToTexture(SurfaceDataRasInfo *srcInfo, OGLPixelFormat *pf, 393 OGLSDOps *dstOps, 394 jint dx1, jint dy1, jint dx2, jint dy2) 395 { 396 jboolean adjustAlpha = (pf != NULL && !pf->hasAlpha); 397 j2d_glBindTexture(dstOps->textureTarget, dstOps->textureID); 398 399 if (adjustAlpha) { 400 // if the source surface does not have an alpha channel, 401 // we need to ensure that the alpha values are forced to 1.0f 402 j2d_glPixelTransferf(GL_ALPHA_SCALE, 0.0f); 403 j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0f); 404 } 405 406 // in case pixel stride is not a multiple of scanline stride the copy 407 // has to be done line by line (see 6207877) 408 if (srcInfo->scanStride % srcInfo->pixelStride != 0) { 409 jint width = dx2 - dx1; 410 jint height = dy2 - dy1; 411 GLvoid *pSrc = srcInfo->rasBase; 412 413 while (height > 0) { 414 j2d_glTexSubImage2D(dstOps->textureTarget, 0, 415 dx1, dy2 - height, width, 1, 416 pf->format, pf->type, pSrc); 417 pSrc = PtrAddBytes(pSrc, srcInfo->scanStride); 418 height--; 419 } 420 } else { 421 j2d_glTexSubImage2D(dstOps->textureTarget, 0, 422 dx1, dy1, dx2-dx1, dy2-dy1, 423 pf->format, pf->type, srcInfo->rasBase); 424 } 425 if (adjustAlpha) { 426 // restore scale/bias to their original values 427 j2d_glPixelTransferf(GL_ALPHA_SCALE, 1.0f); 428 j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0f); 429 } 430 } 431 432 /** 433 * General blit method for copying a native OpenGL surface (of type "Surface" 434 * or "Texture") to another OpenGL "Surface". If texture is JNI_TRUE, this 435 * method will invoke the Texture->Surface inner loop; otherwise, one of the 436 * Surface->Surface inner loops will be invoked, depending on the transform 437 * state. 438 * 439 * REMIND: we can trick these blit methods into doing XOR simply by passing 440 * in the (pixel ^ xorpixel) as the pixel value and preceding the 441 * blit with a fillrect... 442 */ 443 void 444 OGLBlitLoops_IsoBlit(JNIEnv *env, 445 OGLContext *oglc, jlong pSrcOps, jlong pDstOps, 446 jboolean xform, jint hint, 447 jboolean texture, jboolean rtt, 448 jint sx1, jint sy1, jint sx2, jint sy2, 449 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 450 { 451 OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); 452 OGLSDOps *dstOps = (OGLSDOps *)jlong_to_ptr(pDstOps); 453 SurfaceDataRasInfo srcInfo; 454 jint sw = sx2 - sx1; 455 jint sh = sy2 - sy1; 456 jdouble dw = dx2 - dx1; 457 jdouble dh = dy2 - dy1; 458 459 J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_IsoBlit"); 460 461 if (sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0) { 462 J2dTraceLn(J2D_TRACE_WARNING, 463 "OGLBlitLoops_IsoBlit: invalid dimensions"); 464 return; 465 } 466 467 RETURN_IF_NULL(srcOps); 468 RETURN_IF_NULL(dstOps); 469 RETURN_IF_NULL(oglc); 470 471 srcInfo.bounds.x1 = sx1; 472 srcInfo.bounds.y1 = sy1; 473 srcInfo.bounds.x2 = sx2; 474 srcInfo.bounds.y2 = sy2; 475 476 SurfaceData_IntersectBoundsXYXY(&srcInfo.bounds, 477 0, 0, srcOps->width, srcOps->height); 478 479 if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && 480 srcInfo.bounds.y2 > srcInfo.bounds.y1) 481 { 482 if (srcInfo.bounds.x1 != sx1) { 483 dx1 += (srcInfo.bounds.x1 - sx1) * (dw / sw); 484 sx1 = srcInfo.bounds.x1; 485 } 486 if (srcInfo.bounds.y1 != sy1) { 487 dy1 += (srcInfo.bounds.y1 - sy1) * (dh / sh); 488 sy1 = srcInfo.bounds.y1; 489 } 490 if (srcInfo.bounds.x2 != sx2) { 491 dx2 += (srcInfo.bounds.x2 - sx2) * (dw / sw); 492 sx2 = srcInfo.bounds.x2; 493 } 494 if (srcInfo.bounds.y2 != sy2) { 495 dy2 += (srcInfo.bounds.y2 - sy2) * (dh / sh); 496 sy2 = srcInfo.bounds.y2; 497 } 498 499 J2dTraceLn2(J2D_TRACE_VERBOSE, " texture=%d hint=%d", texture, hint); 500 J2dTraceLn4(J2D_TRACE_VERBOSE, " sx1=%d sy1=%d sx2=%d sy2=%d", 501 sx1, sy1, sx2, sy2); 502 J2dTraceLn4(J2D_TRACE_VERBOSE, " dx1=%f dy1=%f dx2=%f dy2=%f", 503 dx1, dy1, dx2, dy2); 504 505 if (texture) { 506 GLint glhint = (hint == OGLSD_XFORM_BILINEAR) ? GL_LINEAR : 507 GL_NEAREST; 508 CHECK_PREVIOUS_OP(srcOps->textureTarget); 509 OGLBlitTextureToSurface(oglc, srcOps, dstOps, rtt, glhint, 510 sx1, sy1, sx2, sy2, 511 dx1, dy1, dx2, dy2); 512 } else { 513 jboolean viaTexture; 514 if (xform) { 515 // we must use the via-texture codepath when there is a xform 516 viaTexture = JNI_TRUE; 517 } else { 518 // look at the vendor to see which codepath is faster 519 // (this has been empirically determined; see 5020009) 520 switch (OGLC_GET_VENDOR(oglc)) { 521 case OGLC_VENDOR_NVIDIA: 522 // the via-texture codepath tends to be faster when 523 // there is either a simple scale OR an extra alpha 524 viaTexture = 525 (sx2-sx1) != (jint)(dx2-dx1) || 526 (sy2-sy1) != (jint)(dy2-dy1) || 527 oglc->extraAlpha != 1.0f; 528 break; 529 530 case OGLC_VENDOR_ATI: 531 // the via-texture codepath tends to be faster only when 532 // there is an extra alpha involved (scaling or not) 533 viaTexture = (oglc->extraAlpha != 1.0f); 534 break; 535 536 default: 537 // just use the glCopyPixels() codepath 538 viaTexture = JNI_FALSE; 539 break; 540 } 541 } 542 543 RESET_PREVIOUS_OP(); 544 if (viaTexture) { 545 OGLBlitToSurfaceViaTexture(oglc, &srcInfo, NULL, srcOps, 546 JNI_FALSE, hint, 547 sx1, sy1, sx2, sy2, 548 dx1, dy1, dx2, dy2); 549 } else { 550 OGLBlitSurfaceToSurface(oglc, srcOps, dstOps, 551 sx1, sy1, sx2, sy2, 552 dx1, dy1, dx2, dy2); 553 } 554 } 555 } 556 } 557 558 /** 559 * General blit method for copying a system memory ("Sw") surface to a native 560 * OpenGL surface (of type "Surface" or "Texture"). If texture is JNI_TRUE, 561 * this method will invoke the Sw->Texture inner loop; otherwise, one of the 562 * Sw->Surface inner loops will be invoked, depending on the transform state. 563 */ 564 void 565 OGLBlitLoops_Blit(JNIEnv *env, 566 OGLContext *oglc, jlong pSrcOps, jlong pDstOps, 567 jboolean xform, jint hint, 568 jint srctype, jboolean texture, 569 jint sx1, jint sy1, jint sx2, jint sy2, 570 jdouble dx1, jdouble dy1, jdouble dx2, jdouble dy2) 571 { 572 SurfaceDataOps *srcOps = (SurfaceDataOps *)jlong_to_ptr(pSrcOps); 573 OGLSDOps *dstOps = (OGLSDOps *)jlong_to_ptr(pDstOps); 574 SurfaceDataRasInfo srcInfo; 575 OGLPixelFormat pf = PixelFormats[srctype]; 576 jint sw = sx2 - sx1; 577 jint sh = sy2 - sy1; 578 jdouble dw = dx2 - dx1; 579 jdouble dh = dy2 - dy1; 580 581 J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_Blit"); 582 583 if (sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0 || srctype < 0) { 584 J2dTraceLn(J2D_TRACE_WARNING, 585 "OGLBlitLoops_Blit: invalid dimensions or srctype"); 586 return; 587 } 588 589 RETURN_IF_NULL(srcOps); 590 RETURN_IF_NULL(dstOps); 591 RETURN_IF_NULL(oglc); 592 RESET_PREVIOUS_OP(); 593 594 srcInfo.bounds.x1 = sx1; 595 srcInfo.bounds.y1 = sy1; 596 srcInfo.bounds.x2 = sx2; 597 srcInfo.bounds.y2 = sy2; 598 599 if (srcOps->Lock(env, srcOps, &srcInfo, SD_LOCK_READ) != SD_SUCCESS) { 600 J2dTraceLn(J2D_TRACE_WARNING, 601 "OGLBlitLoops_Blit: could not acquire lock"); 602 return; 603 } 604 605 if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && 606 srcInfo.bounds.y2 > srcInfo.bounds.y1) 607 { 608 srcOps->GetRasInfo(env, srcOps, &srcInfo); 609 if (srcInfo.rasBase) { 610 if (srcInfo.bounds.x1 != sx1) { 611 dx1 += (srcInfo.bounds.x1 - sx1) * (dw / sw); 612 sx1 = srcInfo.bounds.x1; 613 } 614 if (srcInfo.bounds.y1 != sy1) { 615 dy1 += (srcInfo.bounds.y1 - sy1) * (dh / sh); 616 sy1 = srcInfo.bounds.y1; 617 } 618 if (srcInfo.bounds.x2 != sx2) { 619 dx2 += (srcInfo.bounds.x2 - sx2) * (dw / sw); 620 sx2 = srcInfo.bounds.x2; 621 } 622 if (srcInfo.bounds.y2 != sy2) { 623 dy2 += (srcInfo.bounds.y2 - sy2) * (dh / sh); 624 sy2 = srcInfo.bounds.y2; 625 } 626 627 J2dTraceLn3(J2D_TRACE_VERBOSE, " texture=%d srctype=%d hint=%d", 628 texture, srctype, hint); 629 J2dTraceLn4(J2D_TRACE_VERBOSE, " sx1=%d sy1=%d sx2=%d sy2=%d", 630 sx1, sy1, sx2, sy2); 631 J2dTraceLn4(J2D_TRACE_VERBOSE, " dx1=%f dy1=%f dx2=%f dy2=%f", 632 dx1, dy1, dx2, dy2); 633 634 j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, sx1); 635 j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, sy1); 636 j2d_glPixelStorei(GL_UNPACK_ROW_LENGTH, 637 srcInfo.scanStride / srcInfo.pixelStride); 638 j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, pf.alignment); 639 640 if (texture) { 641 // These coordinates will always be integers since we 642 // only ever do a straight copy from sw to texture. 643 // Thus these casts are "safe" - no loss of precision. 644 OGLBlitSwToTexture(&srcInfo, &pf, dstOps, 645 (jint)dx1, (jint)dy1, (jint)dx2, (jint)dy2); 646 } else { 647 jboolean viaTexture; 648 if (xform) { 649 // we must use the via-texture codepath when there 650 // is a xform 651 viaTexture = JNI_TRUE; 652 } else { 653 // look at the vendor to see which codepath is faster 654 // (this has been empirically determined; see 5020009) 655 switch (OGLC_GET_VENDOR(oglc)) { 656 case OGLC_VENDOR_NVIDIA: 657 // the via-texture codepath tends to be faster when 658 // there is either a simple scale OR an extra alpha 659 viaTexture = 660 (sx2-sx1) != (jint)(dx2-dx1) || 661 (sy2-sy1) != (jint)(dy2-dy1) || 662 oglc->extraAlpha != 1.0f; 663 break; 664 #ifdef MACOSX 665 case OGLC_VENDOR_ATI: 666 // see 8024461 667 viaTexture = JNI_TRUE; 668 break; 669 #endif 670 default: 671 // just use the glDrawPixels() codepath 672 viaTexture = JNI_FALSE; 673 break; 674 } 675 } 676 677 if (viaTexture) { 678 OGLBlitToSurfaceViaTexture(oglc, &srcInfo, &pf, NULL, 679 JNI_TRUE, hint, 680 sx1, sy1, sx2, sy2, 681 dx1, dy1, dx2, dy2); 682 } else { 683 OGLBlitSwToSurface(oglc, &srcInfo, &pf, 684 sx1, sy1, sx2, sy2, 685 dx1, dy1, dx2, dy2); 686 } 687 } 688 689 j2d_glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); 690 j2d_glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); 691 j2d_glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); 692 j2d_glPixelStorei(GL_UNPACK_ALIGNMENT, 4); 693 } 694 SurfaceData_InvokeRelease(env, srcOps, &srcInfo); 695 } 696 SurfaceData_InvokeUnlock(env, srcOps, &srcInfo); 697 } 698 699 /** 700 * Specialized blit method for copying a native OpenGL "Surface" (pbuffer, 701 * window, etc.) to a system memory ("Sw") surface. 702 */ 703 void 704 OGLBlitLoops_SurfaceToSwBlit(JNIEnv *env, OGLContext *oglc, 705 jlong pSrcOps, jlong pDstOps, jint dsttype, 706 jint srcx, jint srcy, jint dstx, jint dsty, 707 jint width, jint height) 708 { 709 OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); 710 SurfaceDataOps *dstOps = (SurfaceDataOps *)jlong_to_ptr(pDstOps); 711 SurfaceDataRasInfo srcInfo, dstInfo; 712 OGLPixelFormat pf = PixelFormats[dsttype]; 713 714 J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_SurfaceToSwBlit"); 715 716 if (width <= 0 || height <= 0) { 717 J2dTraceLn(J2D_TRACE_WARNING, 718 "OGLBlitLoops_SurfaceToSwBlit: dimensions are non-positive"); 719 return; 720 } 721 722 RETURN_IF_NULL(srcOps); 723 RETURN_IF_NULL(dstOps); 724 RETURN_IF_NULL(oglc); 725 RESET_PREVIOUS_OP(); 726 727 srcInfo.bounds.x1 = srcx; 728 srcInfo.bounds.y1 = srcy; 729 srcInfo.bounds.x2 = srcx + width; 730 srcInfo.bounds.y2 = srcy + height; 731 dstInfo.bounds.x1 = dstx; 732 dstInfo.bounds.y1 = dsty; 733 dstInfo.bounds.x2 = dstx + width; 734 dstInfo.bounds.y2 = dsty + height; 735 736 if (dstOps->Lock(env, dstOps, &dstInfo, SD_LOCK_WRITE) != SD_SUCCESS) { 737 J2dTraceLn(J2D_TRACE_WARNING, 738 "OGLBlitLoops_SurfaceToSwBlit: could not acquire dst lock"); 739 return; 740 } 741 742 SurfaceData_IntersectBoundsXYXY(&srcInfo.bounds, 743 0, 0, srcOps->width, srcOps->height); 744 SurfaceData_IntersectBlitBounds(&dstInfo.bounds, &srcInfo.bounds, 745 srcx - dstx, srcy - dsty); 746 747 if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && 748 srcInfo.bounds.y2 > srcInfo.bounds.y1) 749 { 750 dstOps->GetRasInfo(env, dstOps, &dstInfo); 751 if (dstInfo.rasBase) { 752 void *pDst = dstInfo.rasBase; 753 754 srcx = srcInfo.bounds.x1; 755 srcy = srcInfo.bounds.y1; 756 dstx = dstInfo.bounds.x1; 757 dsty = dstInfo.bounds.y1; 758 width = srcInfo.bounds.x2 - srcInfo.bounds.x1; 759 height = srcInfo.bounds.y2 - srcInfo.bounds.y1; 760 761 j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, dstx); 762 j2d_glPixelStorei(GL_PACK_ROW_LENGTH, 763 dstInfo.scanStride / dstInfo.pixelStride); 764 j2d_glPixelStorei(GL_PACK_ALIGNMENT, pf.alignment); 765 #ifdef MACOSX 766 if (srcOps->isOpaque) { 767 // For some reason Apple's OpenGL implementation will 768 // read back zero values from the alpha channel of an 769 // opaque surface when using glReadPixels(), so here we 770 // force the resulting pixels to be fully opaque. 771 j2d_glPixelTransferf(GL_ALPHA_BIAS, 1.0); 772 } 773 #endif 774 775 J2dTraceLn4(J2D_TRACE_VERBOSE, " sx=%d sy=%d w=%d h=%d", 776 srcx, srcy, width, height); 777 J2dTraceLn2(J2D_TRACE_VERBOSE, " dx=%d dy=%d", 778 dstx, dsty); 779 780 // this accounts for lower-left origin of the source region 781 srcx = srcOps->xOffset + srcx; 782 srcy = srcOps->yOffset + srcOps->height - (srcy + 1); 783 784 // we must read one scanline at a time because there is no way 785 // to read starting at the top-left corner of the source region 786 while (height > 0) { 787 j2d_glPixelStorei(GL_PACK_SKIP_ROWS, dsty); 788 j2d_glReadPixels(srcx, srcy, width, 1, 789 pf.format, pf.type, pDst); 790 srcy--; 791 dsty++; 792 height--; 793 } 794 795 #ifdef MACOSX 796 if (srcOps->isOpaque) { 797 j2d_glPixelTransferf(GL_ALPHA_BIAS, 0.0); 798 } 799 #endif 800 801 j2d_glPixelStorei(GL_PACK_SKIP_PIXELS, 0); 802 j2d_glPixelStorei(GL_PACK_SKIP_ROWS, 0); 803 j2d_glPixelStorei(GL_PACK_ROW_LENGTH, 0); 804 j2d_glPixelStorei(GL_PACK_ALIGNMENT, 4); 805 } 806 SurfaceData_InvokeRelease(env, dstOps, &dstInfo); 807 } 808 SurfaceData_InvokeUnlock(env, dstOps, &dstInfo); 809 } 810 811 void 812 OGLBlitLoops_CopyArea(JNIEnv *env, 813 OGLContext *oglc, OGLSDOps *dstOps, 814 jint x, jint y, jint width, jint height, 815 jint dx, jint dy) 816 { 817 SurfaceDataBounds srcBounds, dstBounds; 818 819 J2dTraceLn(J2D_TRACE_INFO, "OGLBlitLoops_CopyArea"); 820 821 RETURN_IF_NULL(oglc); 822 RETURN_IF_NULL(dstOps); 823 RESET_PREVIOUS_OP(); 824 825 J2dTraceLn4(J2D_TRACE_VERBOSE, " x=%d y=%d w=%d h=%d", 826 x, y, width, height); 827 J2dTraceLn2(J2D_TRACE_VERBOSE, " dx=%d dy=%d", 828 dx, dy); 829 830 srcBounds.x1 = x; 831 srcBounds.y1 = y; 832 srcBounds.x2 = srcBounds.x1 + width; 833 srcBounds.y2 = srcBounds.y1 + height; 834 dstBounds.x1 = x + dx; 835 dstBounds.y1 = y + dy; 836 dstBounds.x2 = dstBounds.x1 + width; 837 dstBounds.y2 = dstBounds.y1 + height; 838 839 // 6430601: manually clip src/dst parameters to work around 840 // some bugs in Sun's and Apple's OpenGL implementations 841 // (it's a good idea to restrict the source parameters anyway, since 842 // passing out of range parameters to glCopyPixels() will result in 843 // an OpenGL error) 844 SurfaceData_IntersectBoundsXYXY(&srcBounds, 845 0, 0, dstOps->width, dstOps->height); 846 SurfaceData_IntersectBoundsXYXY(&dstBounds, 847 0, 0, dstOps->width, dstOps->height); 848 SurfaceData_IntersectBlitBounds(&dstBounds, &srcBounds, -dx, -dy); 849 850 if (dstBounds.x1 < dstBounds.x2 && dstBounds.y1 < dstBounds.y2) { 851 #ifdef MACOSX 852 if (dstOps->isOpaque) { 853 // For some reason Apple's OpenGL implementation will fail 854 // to render glCopyPixels() when the src/dst rectangles are 855 // overlapping and glColorMask() has disabled writes to the 856 // alpha channel. The workaround is to temporarily re-enable 857 // the alpha channel during the glCopyPixels() operation. 858 j2d_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE); 859 } 860 #endif 861 862 OGLBlitSurfaceToSurface(oglc, dstOps, dstOps, 863 srcBounds.x1, srcBounds.y1, 864 srcBounds.x2, srcBounds.y2, 865 dstBounds.x1, dstBounds.y1, 866 dstBounds.x2, dstBounds.y2); 867 #ifdef MACOSX 868 if (dstOps->isOpaque) { 869 j2d_glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); 870 } 871 #endif 872 } 873 } 874 875 #endif /* !HEADLESS */