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 
  64 /**
  65  * Flags that can be bitwise-or'ed together to control how the shader
  66  * source code is generated.
  67  */
  68 #define CONVOLVE_RECT            (1 << 0)
  69 #define CONVOLVE_EDGE_ZERO_FILL  (1 << 1)
  70 #define CONVOLVE_5X5             (1 << 2)
  71 
  72 /**
  73  * The handles to the ConvolveOp fragment program objects.  The index to
  74  * the array should be a bitwise-or'ing of the CONVOLVE_* flags defined
  75  * above.  Note that most applications will likely need to initialize one
  76  * or two of these elements, so the array is usually sparsely populated.
  77  */
  78 static GLhandleARB convolvePrograms[8];
  79 
  80 /**
  81  * The maximum kernel size supported by the ConvolveOp shader.
  82  */
  83 #define MAX_KERNEL_SIZE 25
  84 
  85 /**
  86  * Compiles and links the ConvolveOp shader program.  If successful, this
  87  * function returns a handle to the newly created shader program; otherwise
  88  * returns 0.
  89  */
  90 static GLhandleARB
  91 OGLBufImgOps_CreateConvolveProgram(jint flags)
  92 {
  93     GLhandleARB convolveProgram;
  94     GLint loc;
  95     char *kernelMax = IS_SET(CONVOLVE_5X5) ? "25" : "9";
  96     char *target = IS_SET(CONVOLVE_RECT) ? "2DRect" : "2D";
  97     char edge[100];
  98     char finalSource[2000];
  99 
 100     J2dTraceLn1(J2D_TRACE_INFO,
 101                 "OGLBufImgOps_CreateConvolveProgram: flags=%d",
 102                 flags);
 103 
 104     if (IS_SET(CONVOLVE_EDGE_ZERO_FILL)) {
 105         // EDGE_ZERO_FILL: fill in zero at the edges
 106         sprintf(edge, "sum = vec4(0.0);");
 107     } else {
 108         // EDGE_NO_OP: use the source pixel color at the edges
 109         sprintf(edge,
 110                 "sum = texture%s(baseImage, gl_TexCoord[0].st);",
 111                 target);
 112     }
 113 
 114     // compose the final source code string from the various pieces
 115     sprintf(finalSource,
 116         // maximum size supported by this shader
 117         "const int MAX_KERNEL_SIZE = %s;"
 118         // image to be convolved
 119         "uniform sampler%s baseImage;"
 120         // image edge limits:
 121         //   imgEdge.xy = imgMin.xy (anything < will be treated as edge case)
 122         //   imgEdge.zw = imgMax.xy (anything > will be treated as edge case)
 123         "uniform vec4 imgEdge;"
 124         // value for each location in the convolution kernel:
 125         //   kernelVals[i].x = offsetX[i]
 126         //   kernelVals[i].y = offsetY[i]
 127         //   kernelVals[i].z = kernel[i]
 128         "uniform vec3 kernelVals[MAX_KERNEL_SIZE];"
 129         ""
 130         "void main(void)"
 131         "{"
 132         "    int i;"
 133         "    vec4 sum;"
 134         ""
 135         "    if (any(lessThan(gl_TexCoord[0].st, imgEdge.xy)) ||"
 136         "        any(greaterThan(gl_TexCoord[0].st, imgEdge.zw)))"
 137         "    {"
 138                  // (placeholder for edge condition code)
 139         "        %s"
 140         "    } else {"
 141         "        sum = vec4(0.0);"
 142         "        for (i = 0; i < MAX_KERNEL_SIZE; i++) {"
 143         "            sum +="
 144         "                kernelVals[i].z *"
 145         "                texture%s(baseImage,"
 146         "                          gl_TexCoord[0].st + kernelVals[i].xy);"
 147         "        }"
 148         "    }"
 149         ""
 150              // modulate with gl_Color in order to apply extra alpha
 151         "    gl_FragColor = sum * gl_Color;"
 152         "}", kernelMax, target, edge, target);
 153 
 154     convolveProgram = OGLContext_CreateFragmentProgram(finalSource);
 155     if (convolveProgram == 0) {
 156         J2dRlsTraceLn(J2D_TRACE_ERROR,
 157             "OGLBufImgOps_CreateConvolveProgram: error creating program");
 158         return 0;
 159     }
 160 
 161     // "use" the program object temporarily so that we can set the uniforms
 162     j2d_glUseProgramObjectARB(convolveProgram);
 163 
 164     // set the "uniform" texture unit binding
 165     loc = j2d_glGetUniformLocationARB(convolveProgram, "baseImage");
 166     j2d_glUniform1iARB(loc, 0); // texture unit 0
 167 
 168     // "unuse" the program object; it will be re-bound later as needed
 169     j2d_glUseProgramObjectARB(0);
 170 
 171     return convolveProgram;
 172 }
 173 
 174 void
 175 OGLBufImgOps_EnableConvolveOp(OGLContext *oglc, jlong pSrcOps,
 176                               jboolean edgeZeroFill,
 177                               jint kernelWidth, jint kernelHeight,
 178                               unsigned char *kernel)
 179 {
 180     OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps);
 181     jint kernelSize = kernelWidth * kernelHeight;
 182     GLhandleARB convolveProgram;
 183     GLfloat xoff, yoff;
 184     GLfloat edgeX, edgeY, minX, minY, maxX, maxY;
 185     GLfloat kernelVals[MAX_KERNEL_SIZE*3];
 186     jint i, j, kIndex;
 187     GLint loc;
 188     jint flags = 0;
 189 
 190     J2dTraceLn2(J2D_TRACE_INFO,
 191                 "OGLBufImgOps_EnableConvolveOp: kernelW=%d kernelH=%d",
 192                 kernelWidth, kernelHeight);
 193 
 194     RETURN_IF_NULL(oglc);
 195     RETURN_IF_NULL(srcOps);
 196     RESET_PREVIOUS_OP();
 197 
 198     if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) {
 199         flags |= CONVOLVE_RECT;
 200 
 201         // for GL_TEXTURE_RECTANGLE_ARB, texcoords are specified in the
 202         // range [0,srcw] and [0,srch], so to achieve an x/y offset of
 203         // exactly one pixel we simply use the value 1 here
 204         xoff = 1.0f;
 205         yoff = 1.0f;
 206     } else {
 207         // for GL_TEXTURE_2D, texcoords are specified in the range [0,1],
 208         // so to achieve an x/y offset of approximately one pixel we have
 209         // to normalize to that range here
 210         xoff = 1.0f / srcOps->textureWidth;
 211         yoff = 1.0f / srcOps->textureHeight;
 212     }
 213     if (edgeZeroFill) {
 214         flags |= CONVOLVE_EDGE_ZERO_FILL;
 215     }
 216     if (kernelWidth == 5 && kernelHeight == 5) {
 217         flags |= CONVOLVE_5X5;
 218     }
 219 
 220     // locate/initialize the shader program for the given flags
 221     if (convolvePrograms[flags] == 0) {
 222         convolvePrograms[flags] = OGLBufImgOps_CreateConvolveProgram(flags);
 223         if (convolvePrograms[flags] == 0) {
 224             // shouldn't happen, but just in case...
 225             return;
 226         }
 227     }
 228     convolveProgram = convolvePrograms[flags];
 229 
 230     // enable the convolve shader
 231     j2d_glUseProgramObjectARB(convolveProgram);
 232 
 233     // update the "uniform" image min/max values
 234     edgeX = (kernelWidth/2) * xoff;
 235     edgeY = (kernelHeight/2) * yoff;
 236     minX = edgeX;
 237     minY = edgeY;
 238     if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) {
 239         // texcoords are in the range [0,srcw] and [0,srch]
 240         maxX = ((GLfloat)srcOps->width)  - edgeX;
 241         maxY = ((GLfloat)srcOps->height) - edgeY;
 242     } else {
 243         // texcoords are in the range [0,1]
 244         maxX = (((GLfloat)srcOps->width) / srcOps->textureWidth) - edgeX;
 245         maxY = (((GLfloat)srcOps->height) / srcOps->textureHeight) - edgeY;
 246     }
 247     loc = j2d_glGetUniformLocationARB(convolveProgram, "imgEdge");
 248     j2d_glUniform4fARB(loc, minX, minY, maxX, maxY);
 249 
 250     // update the "uniform" kernel offsets and values
 251     loc = j2d_glGetUniformLocationARB(convolveProgram, "kernelVals");
 252     kIndex = 0;
 253     for (i = -kernelHeight/2; i < kernelHeight/2+1; i++) {
 254         for (j = -kernelWidth/2; j < kernelWidth/2+1; j++) {
 255             kernelVals[kIndex+0] = j*xoff;
 256             kernelVals[kIndex+1] = i*yoff;
 257             kernelVals[kIndex+2] = NEXT_FLOAT(kernel);
 258             kIndex += 3;
 259         }
 260     }
 261     j2d_glUniform3fvARB(loc, kernelSize, kernelVals);
 262 }
 263 
 264 void
 265 OGLBufImgOps_DisableConvolveOp(OGLContext *oglc)
 266 {
 267     J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableConvolveOp");
 268 
 269     RETURN_IF_NULL(oglc);
 270 
 271     // disable the ConvolveOp shader
 272     j2d_glUseProgramObjectARB(0);
 273 }
 274 
 275 /**************************** RescaleOp support *****************************/
 276 
 277 /**
 278  * The RescaleOp shader is one of the simplest possible.  Each fragment
 279  * from the source image is multiplied by the user's scale factor and added
 280  * to the user's offset value (these are component-wise operations).
 281  * Finally, the resulting value is multiplied by the current OpenGL color,
 282  * which contains the extra alpha value.
 283  *
 284  * The RescaleOp spec says that the operation is performed regardless of
 285  * whether the source data is premultiplied or non-premultiplied.  This is
 286  * a problem for the OpenGL pipeline in that a non-premultiplied
 287  * BufferedImage will have already been converted into premultiplied
 288  * when uploaded to an OpenGL texture.  Therefore, we have a special mode
 289  * called RESCALE_NON_PREMULT (used only for source images that were
 290  * originally non-premultiplied) that un-premultiplies the source color
 291  * prior to the rescale operation, then re-premultiplies the resulting
 292  * color before returning from the fragment shader.
 293  *
 294  * Note that this shader source code includes some "holes" marked by "%s".
 295  * This allows us to build different shader programs (e.g. one for
 296  * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on)
 297  * simply by filling in these "holes" with a call to sprintf().  See the
 298  * OGLBufImgOps_CreateRescaleProgram() method for more details.
 299  */




















 300 
 301 /**
 302  * Flags that can be bitwise-or'ed together to control how the shader
 303  * source code is generated.
 304  */
 305 #define RESCALE_RECT        (1 << 0)
 306 #define RESCALE_NON_PREMULT (1 << 1)
 307 
 308 /**
 309  * The handles to the RescaleOp fragment program objects.  The index to
 310  * the array should be a bitwise-or'ing of the RESCALE_* flags defined
 311  * above.  Note that most applications will likely need to initialize one
 312  * or two of these elements, so the array is usually sparsely populated.
 313  */
 314 static GLhandleARB rescalePrograms[4];
 315 
 316 /**
 317  * Compiles and links the RescaleOp shader program.  If successful, this
 318  * function returns a handle to the newly created shader program; otherwise
 319  * returns 0.
 320  */
 321 static GLhandleARB
 322 OGLBufImgOps_CreateRescaleProgram(jint flags)
 323 {
 324     GLhandleARB rescaleProgram;
 325     GLint loc;
 326     char *target = IS_SET(RESCALE_RECT) ? "2DRect" : "2D";
 327     char *preRescale = "";
 328     char *postRescale = "";
 329     char finalSource[2000];
 330 
 331     J2dTraceLn1(J2D_TRACE_INFO,
 332                 "OGLBufImgOps_CreateRescaleProgram: flags=%d",
 333                 flags);
 334 
 335     if (IS_SET(RESCALE_NON_PREMULT)) {
 336         preRescale  = "srcColor.rgb /= srcColor.a;";
 337         postRescale = "result.rgb *= result.a;";
 338     }
 339 
 340     // compose the final source code string from the various pieces
 341     sprintf(finalSource,
 342         // image to be rescaled
 343         "uniform sampler%s baseImage;"
 344         // vector containing scale factors
 345         "uniform vec4 scaleFactors;"
 346         // vector containing offsets
 347         "uniform vec4 offsets;"
 348         ""
 349         "void main(void)"
 350         "{"
 351         "    vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);"
 352              // (placeholder for un-premult code)
 353         "    %s"
 354              // rescale source value
 355         "    vec4 result = (srcColor * scaleFactors) + offsets;"
 356              // (placeholder for re-premult code)
 357         "    %s"
 358              // modulate with gl_Color in order to apply extra alpha
 359         "    gl_FragColor = result * gl_Color;"
 360         "}", target, target, preRescale, postRescale);
 361 
 362     rescaleProgram = OGLContext_CreateFragmentProgram(finalSource);
 363     if (rescaleProgram == 0) {
 364         J2dRlsTraceLn(J2D_TRACE_ERROR,
 365             "OGLBufImgOps_CreateRescaleProgram: error creating program");
 366         return 0;
 367     }
 368 
 369     // "use" the program object temporarily so that we can set the uniforms
 370     j2d_glUseProgramObjectARB(rescaleProgram);
 371 
 372     // set the "uniform" values
 373     loc = j2d_glGetUniformLocationARB(rescaleProgram, "baseImage");
 374     j2d_glUniform1iARB(loc, 0); // texture unit 0
 375 
 376     // "unuse" the program object; it will be re-bound later as needed
 377     j2d_glUseProgramObjectARB(0);
 378 
 379     return rescaleProgram;
 380 }
 381 
 382 void
 383 OGLBufImgOps_EnableRescaleOp(OGLContext *oglc, jlong pSrcOps,
 384                              jboolean nonPremult,
 385                              unsigned char *scaleFactors,
 386                              unsigned char *offsets)
 387 {
 388     OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps);
 389     GLhandleARB rescaleProgram;
 390     GLint loc;
 391     jint flags = 0;
 392 
 393     J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_EnableRescaleOp");
 394 
 395     RETURN_IF_NULL(oglc);
 396     RETURN_IF_NULL(srcOps);
 397     RESET_PREVIOUS_OP();
 398 
 399     // choose the appropriate shader, depending on the source texture target
 400     if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) {
 401         flags |= RESCALE_RECT;
 402     }
 403     if (nonPremult) {
 404         flags |= RESCALE_NON_PREMULT;
 405     }
 406 
 407     // locate/initialize the shader program for the given flags
 408     if (rescalePrograms[flags] == 0) {
 409         rescalePrograms[flags] = OGLBufImgOps_CreateRescaleProgram(flags);
 410         if (rescalePrograms[flags] == 0) {
 411             // shouldn't happen, but just in case...
 412             return;
 413         }
 414     }
 415     rescaleProgram = rescalePrograms[flags];
 416 
 417     // enable the rescale shader
 418     j2d_glUseProgramObjectARB(rescaleProgram);
 419 
 420     // update the "uniform" scale factor values (note that the Java-level
 421     // dispatching code always passes down 4 values here, regardless of
 422     // the original source image type)
 423     loc = j2d_glGetUniformLocationARB(rescaleProgram, "scaleFactors");
 424     {
 425         GLfloat sf1 = NEXT_FLOAT(scaleFactors);
 426         GLfloat sf2 = NEXT_FLOAT(scaleFactors);
 427         GLfloat sf3 = NEXT_FLOAT(scaleFactors);
 428         GLfloat sf4 = NEXT_FLOAT(scaleFactors);
 429         j2d_glUniform4fARB(loc, sf1, sf2, sf3, sf4);
 430     }
 431 
 432     // update the "uniform" offset values (note that the Java-level
 433     // dispatching code always passes down 4 values here, and that the
 434     // offsets will have already been normalized to the range [0,1])
 435     loc = j2d_glGetUniformLocationARB(rescaleProgram, "offsets");
 436     {
 437         GLfloat off1 = NEXT_FLOAT(offsets);
 438         GLfloat off2 = NEXT_FLOAT(offsets);
 439         GLfloat off3 = NEXT_FLOAT(offsets);
 440         GLfloat off4 = NEXT_FLOAT(offsets);
 441         j2d_glUniform4fARB(loc, off1, off2, off3, off4);
 442     }
 443 }
 444 
 445 void
 446 OGLBufImgOps_DisableRescaleOp(OGLContext *oglc)
 447 {
 448     J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableRescaleOp");
 449 
 450     RETURN_IF_NULL(oglc);
 451 
 452     // disable the RescaleOp shader
 453     j2d_glUseProgramObjectARB(0);
 454 }
 455 
 456 /**************************** LookupOp support ******************************/
 457 
 458 /**
 459  * The LookupOp shader takes a fragment color (from the source texture) as
 460  * input, subtracts the optional user offset value, and then uses the
 461  * resulting value to index into the lookup table texture to provide
 462  * a new color result.  Finally, the resulting value is multiplied by
 463  * the current OpenGL color, which contains the extra alpha value.
 464  *
 465  * The lookup step requires 3 texture accesses (or 4, when alpha is included),
 466  * which is somewhat unfortunate because it's not ideal from a performance
 467  * standpoint, but that sort of thing is getting faster with newer hardware.
 468  * In the 3-band case, we could consider using a three-dimensional texture
 469  * and performing the lookup with a single texture access step.  We already
 470  * use this approach in the LCD text shader, and it works well, but for the
 471  * purposes of this LookupOp shader, it's probably overkill.  Also, there's
 472  * a difference in that the LCD text shader only needs to populate the 3D LUT
 473  * once, but here we would need to populate it on every invocation, which
 474  * would likely be a waste of VRAM and CPU/GPU cycles.
 475  *
 476  * The LUT texture is currently hardcoded as 4 rows/bands, each containing
 477  * 256 elements.  This means that we currently only support user-provided
 478  * tables with no more than 256 elements in each band (this is checked at
 479  * at the Java level).  If the user provides a table with less than 256
 480  * elements per band, our shader will still work fine, but if elements are
 481  * accessed with an index >= the size of the LUT, then the shader will simply
 482  * produce undefined values.  Typically the user would provide an offset
 483  * value that would prevent this from happening, but it's worth pointing out
 484  * this fact because the software LookupOp implementation would usually
 485  * throw an ArrayIndexOutOfBoundsException in this scenario (although it is
 486  * not something demanded by the spec).
 487  *
 488  * The LookupOp spec says that the operation is performed regardless of
 489  * whether the source data is premultiplied or non-premultiplied.  This is
 490  * a problem for the OpenGL pipeline in that a non-premultiplied
 491  * BufferedImage will have already been converted into premultiplied
 492  * when uploaded to an OpenGL texture.  Therefore, we have a special mode
 493  * called LOOKUP_NON_PREMULT (used only for source images that were
 494  * originally non-premultiplied) that un-premultiplies the source color
 495  * prior to the lookup operation, then re-premultiplies the resulting
 496  * color before returning from the fragment shader.
 497  *
 498  * Note that this shader source code includes some "holes" marked by "%s".
 499  * This allows us to build different shader programs (e.g. one for
 500  * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on)
 501  * simply by filling in these "holes" with a call to sprintf().  See the
 502  * OGLBufImgOps_CreateLookupProgram() method for more details.
 503  */





























 504 
 505 /**
 506  * Flags that can be bitwise-or'ed together to control how the shader
 507  * source code is generated.
 508  */
 509 #define LOOKUP_RECT          (1 << 0)
 510 #define LOOKUP_USE_SRC_ALPHA (1 << 1)
 511 #define LOOKUP_NON_PREMULT   (1 << 2)
 512 
 513 /**
 514  * The handles to the LookupOp fragment program objects.  The index to
 515  * the array should be a bitwise-or'ing of the LOOKUP_* flags defined
 516  * above.  Note that most applications will likely need to initialize one
 517  * or two of these elements, so the array is usually sparsely populated.
 518  */
 519 static GLhandleARB lookupPrograms[8];
 520 
 521 /**
 522  * The handle to the lookup table texture object used by the shader.
 523  */
 524 static GLuint lutTextureID = 0;
 525 
 526 /**
 527  * Compiles and links the LookupOp shader program.  If successful, this
 528  * function returns a handle to the newly created shader program; otherwise
 529  * returns 0.
 530  */
 531 static GLhandleARB
 532 OGLBufImgOps_CreateLookupProgram(jint flags)
 533 {
 534     GLhandleARB lookupProgram;
 535     GLint loc;
 536     char *target = IS_SET(LOOKUP_RECT) ? "2DRect" : "2D";
 537     char *alpha;
 538     char *preLookup = "";
 539     char *postLookup = "";
 540     char finalSource[2000];
 541 
 542     J2dTraceLn1(J2D_TRACE_INFO,
 543                 "OGLBufImgOps_CreateLookupProgram: flags=%d",
 544                 flags);
 545 
 546     if (IS_SET(LOOKUP_USE_SRC_ALPHA)) {
 547         // when numComps is 1 or 3, the alpha is not looked up in the table;
 548         // just keep the alpha from the source fragment
 549         alpha = "result.a = srcColor.a;";
 550     } else {
 551         // when numComps is 4, the alpha is looked up in the table, just
 552         // like the other color components from the source fragment
 553         alpha =
 554             "result.a = texture2D(lookupTable, vec2(srcIndex.a, 0.875)).r;";
 555     }
 556     if (IS_SET(LOOKUP_NON_PREMULT)) {
 557         preLookup  = "srcColor.rgb /= srcColor.a;";
 558         postLookup = "result.rgb *= result.a;";
 559     }
 560 
 561     // compose the final source code string from the various pieces
 562     sprintf(finalSource,
 563     // source image (bound to texture unit 0)
 564         "uniform sampler%s baseImage;"
 565         // lookup table (bound to texture unit 1)
 566         "uniform sampler2D lookupTable;"
 567         // offset subtracted from source index prior to lookup step
 568         "uniform vec4 offset;"
 569         ""
 570         "void main(void)"
 571         "{"
 572         "    vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);"
 573              // (placeholder for un-premult code)
 574         "    %s"
 575              // subtract offset from original index
 576         "    vec4 srcIndex = srcColor - offset;"
 577              // use source value as input to lookup table (note that
 578              // "v" texcoords are hardcoded to hit texel centers of
 579              // each row/band in texture)
 580         "    vec4 result;"
 581         "    result.r = texture2D(lookupTable, vec2(srcIndex.r, 0.125)).r;"
 582         "    result.g = texture2D(lookupTable, vec2(srcIndex.g, 0.375)).r;"
 583         "    result.b = texture2D(lookupTable, vec2(srcIndex.b, 0.625)).r;"
 584              // (placeholder for alpha store code)
 585         "    %s"
 586              // (placeholder for re-premult code)
 587         "    %s"
 588              // modulate with gl_Color in order to apply extra alpha
 589         "    gl_FragColor = result * gl_Color;"
 590         "}", target, target, preLookup, alpha, postLookup);
 591 
 592     lookupProgram = OGLContext_CreateFragmentProgram(finalSource);
 593     if (lookupProgram == 0) {
 594         J2dRlsTraceLn(J2D_TRACE_ERROR,
 595             "OGLBufImgOps_CreateLookupProgram: error creating program");
 596         return 0;
 597     }
 598 
 599     // "use" the program object temporarily so that we can set the uniforms
 600     j2d_glUseProgramObjectARB(lookupProgram);
 601 
 602     // set the "uniform" values
 603     loc = j2d_glGetUniformLocationARB(lookupProgram, "baseImage");
 604     j2d_glUniform1iARB(loc, 0); // texture unit 0
 605     loc = j2d_glGetUniformLocationARB(lookupProgram, "lookupTable");
 606     j2d_glUniform1iARB(loc, 1); // texture unit 1
 607 
 608     // "unuse" the program object; it will be re-bound later as needed
 609     j2d_glUseProgramObjectARB(0);
 610 
 611     return lookupProgram;
 612 }
 613 
 614 void
 615 OGLBufImgOps_EnableLookupOp(OGLContext *oglc, jlong pSrcOps,
 616                             jboolean nonPremult, jboolean shortData,
 617                             jint numBands, jint bandLength, jint offset,
 618                             void *tableValues)
 619 {
 620     OGLSDOps *srcOps = (OGLSDOps *)jlong_to_ptr(pSrcOps);
 621     int bytesPerElem = (shortData ? 2 : 1);
 622     GLhandleARB lookupProgram;
 623     GLfloat foff;
 624     GLint loc;
 625     void *bands[4];
 626     int i;
 627     jint flags = 0;
 628 
 629     J2dTraceLn4(J2D_TRACE_INFO,
 630                 "OGLBufImgOps_EnableLookupOp: short=%d num=%d len=%d off=%d",
 631                 shortData, numBands, bandLength, offset);
 632 
 633     for (i = 0; i < 4; i++) {
 634         bands[i] = NULL;
 635     }
 636     RETURN_IF_NULL(oglc);
 637     RETURN_IF_NULL(srcOps);
 638     RESET_PREVIOUS_OP();
 639 
 640     // choose the appropriate shader, depending on the source texture target
 641     // and the number of bands involved
 642     if (srcOps->textureTarget == GL_TEXTURE_RECTANGLE_ARB) {
 643         flags |= LOOKUP_RECT;
 644     }
 645     if (numBands != 4) {
 646         flags |= LOOKUP_USE_SRC_ALPHA;
 647     }
 648     if (nonPremult) {
 649         flags |= LOOKUP_NON_PREMULT;
 650     }
 651 
 652     // locate/initialize the shader program for the given flags
 653     if (lookupPrograms[flags] == 0) {
 654         lookupPrograms[flags] = OGLBufImgOps_CreateLookupProgram(flags);
 655         if (lookupPrograms[flags] == 0) {
 656             // shouldn't happen, but just in case...
 657             return;
 658         }
 659     }
 660     lookupProgram = lookupPrograms[flags];
 661 
 662     // enable the lookup shader
 663     j2d_glUseProgramObjectARB(lookupProgram);
 664 
 665     // update the "uniform" offset value
 666     loc = j2d_glGetUniformLocationARB(lookupProgram, "offset");
 667     foff = offset / 255.0f;
 668     j2d_glUniform4fARB(loc, foff, foff, foff, foff);
 669 
 670     // bind the lookup table to texture unit 1 and enable texturing
 671     j2d_glActiveTextureARB(GL_TEXTURE1_ARB);
 672     if (lutTextureID == 0) {
 673         /*
 674          * Create the lookup table texture with 4 rows (one band per row)
 675          * and 256 columns (one LUT band element per column) and with an
 676          * internal format of 16-bit luminance values, which will be
 677          * sufficient for either byte or short LUT data.  Note that the
 678          * texture wrap mode will be set to the default of GL_CLAMP_TO_EDGE,
 679          * which means that out-of-range index value will be clamped
 680          * appropriately.
 681          */
 682         lutTextureID =
 683             OGLContext_CreateBlitTexture(GL_LUMINANCE16, GL_LUMINANCE,
 684                                          256, 4);
 685         if (lutTextureID == 0) {
 686             // should never happen, but just to be safe...
 687             return;
 688         }
 689     }
 690     j2d_glBindTexture(GL_TEXTURE_2D, lutTextureID);
 691     j2d_glEnable(GL_TEXTURE_2D);
 692 
 693     // update the lookup table with the user-provided values
 694     if (numBands == 1) {
 695         // replicate the single band for R/G/B; alpha band is unused
 696         for (i = 0; i < 3; i++) {
 697             bands[i] = tableValues;
 698         }
 699         bands[3] = NULL;
 700     } else if (numBands == 3) {
 701         // user supplied band for each of R/G/B; alpha band is unused
 702         for (i = 0; i < 3; i++) {
 703             bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem);
 704         }
 705         bands[3] = NULL;
 706     } else if (numBands == 4) {
 707         // user supplied band for each of R/G/B/A
 708         for (i = 0; i < 4; i++) {
 709             bands[i] = PtrAddBytes(tableValues, i*bandLength*bytesPerElem);
 710         }
 711     }
 712 
 713     // upload the bands one row at a time into our lookup table texture
 714     for (i = 0; i < 4; i++) {
 715         if (bands[i] == NULL) {
 716             continue;
 717         }
 718         j2d_glTexSubImage2D(GL_TEXTURE_2D, 0,
 719                             0, i, bandLength, 1,
 720                             GL_LUMINANCE,
 721                             shortData ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE,
 722                             bands[i]);
 723     }
 724 
 725     // restore texture unit 0 (the default) as the active one since
 726     // the OGLBlitTextureToSurface() method is responsible for binding the
 727     // source image texture, which will happen later
 728     j2d_glActiveTextureARB(GL_TEXTURE0_ARB);
 729 }
 730 
 731 void
 732 OGLBufImgOps_DisableLookupOp(OGLContext *oglc)
 733 {
 734     J2dTraceLn(J2D_TRACE_INFO, "OGLBufImgOps_DisableLookupOp");
 735 
 736     RETURN_IF_NULL(oglc);
 737 
 738     // disable the LookupOp shader
 739     j2d_glUseProgramObjectARB(0);
 740 
 741     // disable the lookup table on texture unit 1
 742     j2d_glActiveTextureARB(GL_TEXTURE1_ARB);
 743     j2d_glDisable(GL_TEXTURE_2D);
 744     j2d_glActiveTextureARB(GL_TEXTURE0_ARB);
 745 }
 746 
 747 #endif /* !HEADLESS */
--- EOF ---