1 /* 2 * Copyright (c) 2007, 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 <jlong.h> 29 30 #include "OGLBufImgOps.h" 31 #include "OGLContext.h" 32 #include "OGLRenderQueue.h" 33 #include "OGLSurfaceData.h" 34 #include "GraphicsPrimitiveMgr.h" 35 36 /** Evaluates to true if the given bit is set on the local flags variable. */ 37 #define IS_SET(flagbit) \ 38 (((flags) & (flagbit)) != 0) 39 40 /**************************** ConvolveOp support ****************************/ 41 42 /** 43 * The ConvolveOp shader is fairly straightforward. For each texel in 44 * the source texture, the shader samples the MxN texels in the surrounding 45 * area, multiplies each by its corresponding kernel value, and then sums 46 * them all together to produce a single color result. Finally, the 47 * resulting value is multiplied by the current OpenGL color, which contains 48 * the extra alpha value. 49 * 50 * Note that this shader source code includes some "holes" marked by "%s". 51 * This allows us to build different shader programs (e.g. one for 52 * 3x3, one for 5x5, and so on) simply by filling in these "holes" with 53 * a call to sprintf(). See the OGLBufImgOps_CreateConvolveProgram() method 54 * for more details. 55 * 56 * REMIND: Currently this shader (and the supporting code in the 57 * EnableConvolveOp() method) only supports 3x3 and 5x5 filters. 58 * Early shader-level hardware did not support non-constant sized 59 * arrays but modern hardware should support them (although I 60 * don't know of any simple way to find out, other than to compile 61 * the shader at runtime and see if the drivers complain). 62 */ 63 static const char *convolveShaderSource = 64 // maximum size supported by this shader 65 "const int MAX_KERNEL_SIZE = %s;" 66 // image to be convolved 67 "uniform sampler%s baseImage;" 68 // image edge limits: 69 // imgEdge.xy = imgMin.xy (anything < will be treated as edge case) 70 // imgEdge.zw = imgMax.xy (anything > will be treated as edge case) 71 "uniform vec4 imgEdge;" 72 // value for each location in the convolution kernel: 73 // kernelVals[i].x = offsetX[i] 74 // kernelVals[i].y = offsetY[i] 75 // kernelVals[i].z = kernel[i] 76 "uniform vec3 kernelVals[MAX_KERNEL_SIZE];" 77 "" 78 "void main(void)" 79 "{" 80 " int i;" 81 " vec4 sum;" 82 "" 83 " if (any(lessThan(gl_TexCoord[0].st, imgEdge.xy)) ||" 84 " any(greaterThan(gl_TexCoord[0].st, imgEdge.zw)))" 85 " {" 86 // (placeholder for edge condition code) 87 " %s" 88 " } else {" 89 " sum = vec4(0.0);" 90 " for (i = 0; i < MAX_KERNEL_SIZE; i++) {" 91 " sum +=" 92 " kernelVals[i].z *" 93 " texture%s(baseImage," 94 " gl_TexCoord[0].st + kernelVals[i].xy);" 95 " }" 96 " }" 97 "" 98 // modulate with gl_Color in order to apply extra alpha 99 " gl_FragColor = sum * gl_Color;" 100 "}"; 101 102 /** 103 * Flags that can be bitwise-or'ed together to control how the shader 104 * source code is generated. 105 */ 106 #define CONVOLVE_RECT (1 << 0) 107 #define CONVOLVE_EDGE_ZERO_FILL (1 << 1) 108 #define CONVOLVE_5X5 (1 << 2) 109 110 /** 111 * The handles to the ConvolveOp fragment program objects. The index to 112 * the array should be a bitwise-or'ing of the CONVOLVE_* flags defined 113 * above. Note that most applications will likely need to initialize one 114 * or two of these elements, so the array is usually sparsely populated. 115 */ 116 static GLhandleARB convolvePrograms[8]; 117 118 /** 119 * The maximum kernel size supported by the ConvolveOp shader. 120 */ 121 #define MAX_KERNEL_SIZE 25 122 123 /** 124 * Compiles and links the ConvolveOp shader program. If successful, this 125 * function returns a handle to the newly created shader program; otherwise 126 * returns 0. 127 */ 128 static GLhandleARB 129 OGLBufImgOps_CreateConvolveProgram(jint flags) 130 { 131 GLhandleARB convolveProgram; 132 GLint loc; 133 char *kernelMax = IS_SET(CONVOLVE_5X5) ? "25" : "9"; 134 char *target = IS_SET(CONVOLVE_RECT) ? "2DRect" : "2D"; 135 char edge[100]; 136 char finalSource[2000]; 137 138 J2dTraceLn1(J2D_TRACE_INFO, 139 "OGLBufImgOps_CreateConvolveProgram: flags=%d", 140 flags); 141 142 if (IS_SET(CONVOLVE_EDGE_ZERO_FILL)) { 143 // EDGE_ZERO_FILL: fill in zero at the edges 144 sprintf(edge, "sum = vec4(0.0);"); 145 } else { 146 // EDGE_NO_OP: use the source pixel color at the edges 147 sprintf(edge, 148 "sum = texture%s(baseImage, gl_TexCoord[0].st);", 149 target); 150 } 151 152 // compose the final source code string from the various pieces 153 sprintf(finalSource, convolveShaderSource, 154 kernelMax, target, edge, target); 155 156 convolveProgram = OGLContext_CreateFragmentProgram(finalSource); 157 if (convolveProgram == 0) { 158 J2dRlsTraceLn(J2D_TRACE_ERROR, 159 "OGLBufImgOps_CreateConvolveProgram: error creating program"); 160 return 0; 161 } 162 163 // "use" the program object temporarily so that we can set the uniforms 164 j2d_glUseProgramObjectARB(convolveProgram); 165 166 // set the "uniform" texture unit binding 167 loc = j2d_glGetUniformLocationARB(convolveProgram, "baseImage"); 168 j2d_glUniform1iARB(loc, 0); // texture unit 0 169 170 // "unuse" the program object; it will be re-bound later as needed 171 j2d_glUseProgramObjectARB(0); 172 173 return convolveProgram; 174 } 175 176 void 177 OGLBufImgOps_EnableConvolveOp(OGLContext *oglc, jlong pSrcOps, 178 jboolean edgeZeroFill, 179 jint kernelWidth, jint kernelHeight, 180 unsigned char *kernel) 181 { 182 OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); 183 jint kernelSize = kernelWidth * kernelHeight; 184 GLhandleARB convolveProgram; 185 GLfloat xoff, yoff; 186 GLfloat edgeX, edgeY, minX, minY, maxX, maxY; 187 GLfloat kernelVals[MAX_KERNEL_SIZE*3]; 188 jint i, j, kIndex; 189 GLint loc; 190 jint flags = 0; 191 192 J2dTraceLn2(J2D_TRACE_INFO, 193 "OGLBufImgOps_EnableConvolveOp: kernelW=%d kernelH=%d", 194 kernelWidth, kernelHeight); 195 196 RETURN_IF_NULL(oglc); 197 RETURN_IF_NULL(srcOps); 198 RESET_PREVIOUS_OP(); 199 200 if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) { 201 flags |= CONVOLVE_RECT; 202 203 // for GL_TEXTURE_RECTANGLE_ARB, texcoords are specified in the 204 // range [0,srcw] and [0,srch], so to achieve an x/y offset of 205 // exactly one pixel we simply use the value 1 here 206 xoff = 1.0f; 207 yoff = 1.0f; 208 } else { 209 // for GL_TEXTURE_2D, texcoords are specified in the range [0,1], 210 // so to achieve an x/y offset of approximately one pixel we have 211 // to normalize to that range here 212 xoff = 1.0f / srcOps->textureWidth; 213 yoff = 1.0f / srcOps->textureHeight; 214 } 215 if (edgeZeroFill) { 216 flags |= CONVOLVE_EDGE_ZERO_FILL; 217 } 218 if (kernelWidth == 5 && kernelHeight == 5) { 219 flags |= CONVOLVE_5X5; 220 } 221 222 // locate/initialize the shader program for the given flags 223 if (convolvePrograms[flags] == 0) { 224 convolvePrograms[flags] = OGLBufImgOps_CreateConvolveProgram(flags); 225 if (convolvePrograms[flags] == 0) { 226 // shouldn't happen, but just in case... 227 return; 228 } 229 } 230 convolveProgram = convolvePrograms[flags]; 231 232 // enable the convolve shader 233 j2d_glUseProgramObjectARB(convolveProgram); 234 235 // update the "uniform" image min/max values 236 edgeX = (kernelWidth/2) * xoff; 237 edgeY = (kernelHeight/2) * yoff; 238 minX = edgeX; 239 minY = edgeY; 240 if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) { 241 // texcoords are in the range [0,srcw] and [0,srch] 242 maxX = ((GLfloat)srcOps->width) - edgeX; 243 maxY = ((GLfloat)srcOps->height) - edgeY; 244 } else { 245 // texcoords are in the range [0,1] 246 maxX = (((GLfloat)srcOps->width) / srcOps->textureWidth) - edgeX; 247 maxY = (((GLfloat)srcOps->height) / srcOps->textureHeight) - edgeY; 248 } 249 loc = j2d_glGetUniformLocationARB(convolveProgram, "imgEdge"); 250 j2d_glUniform4fARB(loc, minX, minY, maxX, maxY); 251 252 // update the "uniform" kernel offsets and values 253 loc = j2d_glGetUniformLocationARB(convolveProgram, "kernelVals"); 254 kIndex = 0; 255 for (i = -kernelHeight/2; i < kernelHeight/2+1; i++) { 256 for (j = -kernelWidth/2; j < kernelWidth/2+1; j++) { 257 kernelVals[kIndex+0] = j*xoff; 258 kernelVals[kIndex+1] = i*yoff; 259 kernelVals[kIndex+2] = NEXT_FLOAT(kernel); 260 kIndex += 3; 261 } 262 } 263 j2d_glUniform3fvARB(loc, kernelSize, kernelVals); 264 } 265 266 void 267 OGLBufImgOps_DisableConvolveOp(OGLContext *oglc) 268 { 269 J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableConvolveOp"); 270 271 RETURN_IF_NULL(oglc); 272 273 // disable the ConvolveOp shader 274 j2d_glUseProgramObjectARB(0); 275 } 276 277 /**************************** RescaleOp support *****************************/ 278 279 /** 280 * The RescaleOp shader is one of the simplest possible. Each fragment 281 * from the source image is multiplied by the user's scale factor and added 282 * to the user's offset value (these are component-wise operations). 283 * Finally, the resulting value is multiplied by the current OpenGL color, 284 * which contains the extra alpha value. 285 * 286 * The RescaleOp spec says that the operation is performed regardless of 287 * whether the source data is premultiplied or non-premultiplied. This is 288 * a problem for the OpenGL pipeline in that a non-premultiplied 289 * BufferedImage will have already been converted into premultiplied 290 * when uploaded to an OpenGL texture. Therefore, we have a special mode 291 * called RESCALE_NON_PREMULT (used only for source images that were 292 * originally non-premultiplied) that un-premultiplies the source color 293 * prior to the rescale operation, then re-premultiplies the resulting 294 * color before returning from the fragment shader. 295 * 296 * Note that this shader source code includes some "holes" marked by "%s". 297 * This allows us to build different shader programs (e.g. one for 298 * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on) 299 * simply by filling in these "holes" with a call to sprintf(). See the 300 * OGLBufImgOps_CreateRescaleProgram() method for more details. 301 */ 302 static const char *rescaleShaderSource = 303 // image to be rescaled 304 "uniform sampler%s baseImage;" 305 // vector containing scale factors 306 "uniform vec4 scaleFactors;" 307 // vector containing offsets 308 "uniform vec4 offsets;" 309 "" 310 "void main(void)" 311 "{" 312 " vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);" 313 // (placeholder for un-premult code) 314 " %s" 315 // rescale source value 316 " vec4 result = (srcColor * scaleFactors) + offsets;" 317 // (placeholder for re-premult code) 318 " %s" 319 // modulate with gl_Color in order to apply extra alpha 320 " gl_FragColor = result * gl_Color;" 321 "}"; 322 323 /** 324 * Flags that can be bitwise-or'ed together to control how the shader 325 * source code is generated. 326 */ 327 #define RESCALE_RECT (1 << 0) 328 #define RESCALE_NON_PREMULT (1 << 1) 329 330 /** 331 * The handles to the RescaleOp fragment program objects. The index to 332 * the array should be a bitwise-or'ing of the RESCALE_* flags defined 333 * above. Note that most applications will likely need to initialize one 334 * or two of these elements, so the array is usually sparsely populated. 335 */ 336 static GLhandleARB rescalePrograms[4]; 337 338 /** 339 * Compiles and links the RescaleOp shader program. If successful, this 340 * function returns a handle to the newly created shader program; otherwise 341 * returns 0. 342 */ 343 static GLhandleARB 344 OGLBufImgOps_CreateRescaleProgram(jint flags) 345 { 346 GLhandleARB rescaleProgram; 347 GLint loc; 348 char *target = IS_SET(RESCALE_RECT) ? "2DRect" : "2D"; 349 char *preRescale = ""; 350 char *postRescale = ""; 351 char finalSource[2000]; 352 353 J2dTraceLn1(J2D_TRACE_INFO, 354 "OGLBufImgOps_CreateRescaleProgram: flags=%d", 355 flags); 356 357 if (IS_SET(RESCALE_NON_PREMULT)) { 358 preRescale = "srcColor.rgb /= srcColor.a;"; 359 postRescale = "result.rgb *= result.a;"; 360 } 361 362 // compose the final source code string from the various pieces 363 sprintf(finalSource, rescaleShaderSource, 364 target, target, preRescale, postRescale); 365 366 rescaleProgram = OGLContext_CreateFragmentProgram(finalSource); 367 if (rescaleProgram == 0) { 368 J2dRlsTraceLn(J2D_TRACE_ERROR, 369 "OGLBufImgOps_CreateRescaleProgram: error creating program"); 370 return 0; 371 } 372 373 // "use" the program object temporarily so that we can set the uniforms 374 j2d_glUseProgramObjectARB(rescaleProgram); 375 376 // set the "uniform" values 377 loc = j2d_glGetUniformLocationARB(rescaleProgram, "baseImage"); 378 j2d_glUniform1iARB(loc, 0); // texture unit 0 379 380 // "unuse" the program object; it will be re-bound later as needed 381 j2d_glUseProgramObjectARB(0); 382 383 return rescaleProgram; 384 } 385 386 void 387 OGLBufImgOps_EnableRescaleOp(OGLContext *oglc, jlong pSrcOps, 388 jboolean nonPremult, 389 unsigned char *scaleFactors, 390 unsigned char *offsets) 391 { 392 OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); 393 GLhandleARB rescaleProgram; 394 GLint loc; 395 jint flags = 0; 396 397 J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_EnableRescaleOp"); 398 399 RETURN_IF_NULL(oglc); 400 RETURN_IF_NULL(srcOps); 401 RESET_PREVIOUS_OP(); 402 403 // choose the appropriate shader, depending on the source texture target 404 if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) { 405 flags |= RESCALE_RECT; 406 } 407 if (nonPremult) { 408 flags |= RESCALE_NON_PREMULT; 409 } 410 411 // locate/initialize the shader program for the given flags 412 if (rescalePrograms[flags] == 0) { 413 rescalePrograms[flags] = OGLBufImgOps_CreateRescaleProgram(flags); 414 if (rescalePrograms[flags] == 0) { 415 // shouldn't happen, but just in case... 416 return; 417 } 418 } 419 rescaleProgram = rescalePrograms[flags]; 420 421 // enable the rescale shader 422 j2d_glUseProgramObjectARB(rescaleProgram); 423 424 // update the "uniform" scale factor values (note that the Java-level 425 // dispatching code always passes down 4 values here, regardless of 426 // the original source image type) 427 loc = j2d_glGetUniformLocationARB(rescaleProgram, "scaleFactors"); 428 { 429 GLfloat sf1 = NEXT_FLOAT(scaleFactors); 430 GLfloat sf2 = NEXT_FLOAT(scaleFactors); 431 GLfloat sf3 = NEXT_FLOAT(scaleFactors); 432 GLfloat sf4 = NEXT_FLOAT(scaleFactors); 433 j2d_glUniform4fARB(loc, sf1, sf2, sf3, sf4); 434 } 435 436 // update the "uniform" offset values (note that the Java-level 437 // dispatching code always passes down 4 values here, and that the 438 // offsets will have already been normalized to the range [0,1]) 439 loc = j2d_glGetUniformLocationARB(rescaleProgram, "offsets"); 440 { 441 GLfloat off1 = NEXT_FLOAT(offsets); 442 GLfloat off2 = NEXT_FLOAT(offsets); 443 GLfloat off3 = NEXT_FLOAT(offsets); 444 GLfloat off4 = NEXT_FLOAT(offsets); 445 j2d_glUniform4fARB(loc, off1, off2, off3, off4); 446 } 447 } 448 449 void 450 OGLBufImgOps_DisableRescaleOp(OGLContext *oglc) 451 { 452 J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableRescaleOp"); 453 454 RETURN_IF_NULL(oglc); 455 456 // disable the RescaleOp shader 457 j2d_glUseProgramObjectARB(0); 458 } 459 460 /**************************** LookupOp support ******************************/ 461 462 /** 463 * The LookupOp shader takes a fragment color (from the source texture) as 464 * input, subtracts the optional user offset value, and then uses the 465 * resulting value to index into the lookup table texture to provide 466 * a new color result. Finally, the resulting value is multiplied by 467 * the current OpenGL color, which contains the extra alpha value. 468 * 469 * The lookup step requires 3 texture accesses (or 4, when alpha is included), 470 * which is somewhat unfortunate because it's not ideal from a performance 471 * standpoint, but that sort of thing is getting faster with newer hardware. 472 * In the 3-band case, we could consider using a three-dimensional texture 473 * and performing the lookup with a single texture access step. We already 474 * use this approach in the LCD text shader, and it works well, but for the 475 * purposes of this LookupOp shader, it's probably overkill. Also, there's 476 * a difference in that the LCD text shader only needs to populate the 3D LUT 477 * once, but here we would need to populate it on every invocation, which 478 * would likely be a waste of VRAM and CPU/GPU cycles. 479 * 480 * The LUT texture is currently hardcoded as 4 rows/bands, each containing 481 * 256 elements. This means that we currently only support user-provided 482 * tables with no more than 256 elements in each band (this is checked at 483 * at the Java level). If the user provides a table with less than 256 484 * elements per band, our shader will still work fine, but if elements are 485 * accessed with an index >= the size of the LUT, then the shader will simply 486 * produce undefined values. Typically the user would provide an offset 487 * value that would prevent this from happening, but it's worth pointing out 488 * this fact because the software LookupOp implementation would usually 489 * throw an ArrayIndexOutOfBoundsException in this scenario (although it is 490 * not something demanded by the spec). 491 * 492 * The LookupOp spec says that the operation is performed regardless of 493 * whether the source data is premultiplied or non-premultiplied. This is 494 * a problem for the OpenGL pipeline in that a non-premultiplied 495 * BufferedImage will have already been converted into premultiplied 496 * when uploaded to an OpenGL texture. Therefore, we have a special mode 497 * called LOOKUP_NON_PREMULT (used only for source images that were 498 * originally non-premultiplied) that un-premultiplies the source color 499 * prior to the lookup operation, then re-premultiplies the resulting 500 * color before returning from the fragment shader. 501 * 502 * Note that this shader source code includes some "holes" marked by "%s". 503 * This allows us to build different shader programs (e.g. one for 504 * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on) 505 * simply by filling in these "holes" with a call to sprintf(). See the 506 * OGLBufImgOps_CreateLookupProgram() method for more details. 507 */ 508 static const char *lookupShaderSource = 509 // source image (bound to texture unit 0) 510 "uniform sampler%s baseImage;" 511 // lookup table (bound to texture unit 1) 512 "uniform sampler2D lookupTable;" 513 // offset subtracted from source index prior to lookup step 514 "uniform vec4 offset;" 515 "" 516 "void main(void)" 517 "{" 518 " vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);" 519 // (placeholder for un-premult code) 520 " %s" 521 // subtract offset from original index 522 " vec4 srcIndex = srcColor - offset;" 523 // use source value as input to lookup table (note that 524 // "v" texcoords are hardcoded to hit texel centers of 525 // each row/band in texture) 526 " vec4 result;" 527 " result.r = texture2D(lookupTable, vec2(srcIndex.r, 0.125)).r;" 528 " result.g = texture2D(lookupTable, vec2(srcIndex.g, 0.375)).r;" 529 " result.b = texture2D(lookupTable, vec2(srcIndex.b, 0.625)).r;" 530 // (placeholder for alpha store code) 531 " %s" 532 // (placeholder for re-premult code) 533 " %s" 534 // modulate with gl_Color in order to apply extra alpha 535 " gl_FragColor = result * gl_Color;" 536 "}"; 537 538 /** 539 * Flags that can be bitwise-or'ed together to control how the shader 540 * source code is generated. 541 */ 542 #define LOOKUP_RECT (1 << 0) 543 #define LOOKUP_USE_SRC_ALPHA (1 << 1) 544 #define LOOKUP_NON_PREMULT (1 << 2) 545 546 /** 547 * The handles to the LookupOp fragment program objects. The index to 548 * the array should be a bitwise-or'ing of the LOOKUP_* flags defined 549 * above. Note that most applications will likely need to initialize one 550 * or two of these elements, so the array is usually sparsely populated. 551 */ 552 static GLhandleARB lookupPrograms[8]; 553 554 /** 555 * The handle to the lookup table texture object used by the shader. 556 */ 557 static GLuint lutTextureID = 0; 558 559 /** 560 * Compiles and links the LookupOp shader program. If successful, this 561 * function returns a handle to the newly created shader program; otherwise 562 * returns 0. 563 */ 564 static GLhandleARB 565 OGLBufImgOps_CreateLookupProgram(jint flags) 566 { 567 GLhandleARB lookupProgram; 568 GLint loc; 569 char *target = IS_SET(LOOKUP_RECT) ? "2DRect" : "2D"; 570 char *alpha; 571 char *preLookup = ""; 572 char *postLookup = ""; 573 char finalSource[2000]; 574 575 J2dTraceLn1(J2D_TRACE_INFO, 576 "OGLBufImgOps_CreateLookupProgram: flags=%d", 577 flags); 578 579 if (IS_SET(LOOKUP_USE_SRC_ALPHA)) { 580 // when numComps is 1 or 3, the alpha is not looked up in the table; 581 // just keep the alpha from the source fragment 582 alpha = "result.a = srcColor.a;"; 583 } else { 584 // when numComps is 4, the alpha is looked up in the table, just 585 // like the other color components from the source fragment 586 alpha = 587 "result.a = texture2D(lookupTable, vec2(srcIndex.a, 0.875)).r;"; 588 } 589 if (IS_SET(LOOKUP_NON_PREMULT)) { 590 preLookup = "srcColor.rgb /= srcColor.a;"; 591 postLookup = "result.rgb *= result.a;"; 592 } 593 594 // compose the final source code string from the various pieces 595 sprintf(finalSource, lookupShaderSource, 596 target, target, preLookup, alpha, postLookup); 597 598 lookupProgram = OGLContext_CreateFragmentProgram(finalSource); 599 if (lookupProgram == 0) { 600 J2dRlsTraceLn(J2D_TRACE_ERROR, 601 "OGLBufImgOps_CreateLookupProgram: error creating program"); 602 return 0; 603 } 604 605 // "use" the program object temporarily so that we can set the uniforms 606 j2d_glUseProgramObjectARB(lookupProgram); 607 608 // set the "uniform" values 609 loc = j2d_glGetUniformLocationARB(lookupProgram, "baseImage"); 610 j2d_glUniform1iARB(loc, 0); // texture unit 0 611 loc = j2d_glGetUniformLocationARB(lookupProgram, "lookupTable"); 612 j2d_glUniform1iARB(loc, 1); // texture unit 1 613 614 // "unuse" the program object; it will be re-bound later as needed 615 j2d_glUseProgramObjectARB(0); 616 617 return lookupProgram; 618 } 619 620 void 621 OGLBufImgOps_EnableLookupOp(OGLContext *oglc, jlong pSrcOps, 622 jboolean nonPremult, jboolean shortData, 623 jint numBands, jint bandLength, jint offset, 624 void *tableValues) 625 { 626 OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps); 627 int bytesPerElem = (shortData ? 2 : 1); 628 GLhandleARB lookupProgram; 629 GLfloat foff; 630 GLint loc; 631 void *bands[4]; 632 int i; 633 jint flags = 0; 634 635 J2dTraceLn4(J2D_TRACE_INFO, 636 "OGLBufImgOps_EnableLookupOp: short=%d num=%d len=%d off=%d", 637 shortData, numBands, bandLength, offset); 638 639 for (i = 0; i < 4; i++) { 640 bands[i] = NULL; 641 } 642 RETURN_IF_NULL(oglc); 643 RETURN_IF_NULL(srcOps); 644 RESET_PREVIOUS_OP(); 645 646 // choose the appropriate shader, depending on the source texture target 647 // and the number of bands involved 648 if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) { 649 flags |= LOOKUP_RECT; 650 } 651 if (numBands != 4) { 652 flags |= LOOKUP_USE_SRC_ALPHA; 653 } 654 if (nonPremult) { 655 flags |= LOOKUP_NON_PREMULT; 656 } 657 658 // locate/initialize the shader program for the given flags 659 if (lookupPrograms[flags] == 0) { 660 lookupPrograms[flags] = OGLBufImgOps_CreateLookupProgram(flags); 661 if (lookupPrograms[flags] == 0) { 662 // shouldn't happen, but just in case... 663 return; 664 } 665 } 666 lookupProgram = lookupPrograms[flags]; 667 668 // enable the lookup shader 669 j2d_glUseProgramObjectARB(lookupProgram); 670 671 // update the "uniform" offset value 672 loc = j2d_glGetUniformLocationARB(lookupProgram, "offset"); 673 foff = offset / 255.0f; 674 j2d_glUniform4fARB(loc, foff, foff, foff, foff); 675 676 // bind the lookup table to texture unit 1 and enable texturing 677 j2d_glActiveTextureARB(GL_TEXTURE1_ARB); 678 if (lutTextureID == 0) { 679 /* 680 * Create the lookup table texture with 4 rows (one band per row) 681 * and 256 columns (one LUT band element per column) and with an 682 * internal format of 16-bit luminance values, which will be 683 * sufficient for either byte or short LUT data. Note that the 684 * texture wrap mode will be set to the default of GL_CLAMP_TO_EDGE, 685 * which means that out-of-range index value will be clamped 686 * appropriately. 687 */ 688 lutTextureID = 689 OGLContext_CreateBlitTexture(GL_LUMINANCE16, GL_LUMINANCE, 690 256, 4); 691 if (lutTextureID == 0) { 692 // should never happen, but just to be safe... 693 return; 694 } 695 } 696 j2d_glBindTexture(GL_TEXTURE_2D, lutTextureID); 697 j2d_glEnable(GL_TEXTURE_2D); 698 699 // update the lookup table with the user-provided values 700 if (numBands == 1) { 701 // replicate the single band for R/G/B; alpha band is unused 702 for (i = 0; i < 3; i++) { 703 bands[i] = tableValues; 704 } 705 bands[3] = NULL; 706 } else if (numBands == 3) { 707 // user supplied band for each of R/G/B; alpha band is unused 708 for (i = 0; i < 3; i++) { 709 bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem); 710 } 711 bands[3] = NULL; 712 } else if (numBands == 4) { 713 // user supplied band for each of R/G/B/A 714 for (i = 0; i < 4; i++) { 715 bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem); 716 } 717 } 718 719 // upload the bands one row at a time into our lookup table texture 720 for (i = 0; i < 4; i++) { 721 if (bands[i] == NULL) { 722 continue; 723 } 724 j2d_glTexSubImage2D(GL_TEXTURE_2D, 0, 725 0, i, bandLength, 1, 726 GL_LUMINANCE, 727 shortData ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE, 728 bands[i]); 729 } 730 731 // restore texture unit 0 (the default) as the active one since 732 // the OGLBlitTextureToSurface() method is responsible for binding the 733 // source image texture, which will happen later 734 j2d_glActiveTextureARB(GL_TEXTURE0_ARB); 735 } 736 737 void 738 OGLBufImgOps_DisableLookupOp(OGLContext *oglc) 739 { 740 J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableLookupOp"); 741 742 RETURN_IF_NULL(oglc); 743 744 // disable the LookupOp shader 745 j2d_glUseProgramObjectARB(0); 746 747 // disable the lookup table on texture unit 1 748 j2d_glActiveTextureARB(GL_TEXTURE1_ARB); 749 j2d_glDisable(GL_TEXTURE_2D); 750 j2d_glActiveTextureARB(GL_TEXTURE0_ARB); 751 } 752 753 #endif /* !HEADLESS */