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 */