1 /* 2 * Copyright (c) 2019, 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 "MTLBufImgOps.h" 31 #include "MTLContext.h" 32 #include "MTLRenderQueue.h" 33 #include "MTLSurfaceDataBase.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 MTLBufImgOps_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 MTLBufImgOps_CreateConvolveProgram(jint flags) 130 { 131 //TODO 132 J2dTraceNotImplPrimitive("MTLBufImgOps_CreateConvolveProgram"); 133 return NULL; 134 } 135 136 void 137 MTLBufImgOps_EnableConvolveOp(MTLContext *mtlc, jlong pSrcOps, 138 jboolean edgeZeroFill, 139 jint kernelWidth, jint kernelHeight, 140 unsigned char *kernel) 141 { 142 //TODO 143 J2dTraceNotImplPrimitive("MTLBufImgOps_EnableConvolveOp"); 144 } 145 146 void 147 MTLBufImgOps_DisableConvolveOp(MTLContext *mtlc) 148 { 149 //TODO 150 J2dTraceNotImplPrimitive("MTLBufImgOps_EnableConvolveOp"); 151 J2dTraceLn(J2D_TRACE_INFO, "MTLBufImgOps_DisableConvolveOp"); 152 } 153 154 /**************************** RescaleOp support *****************************/ 155 156 /** 157 * The RescaleOp shader is one of the simplest possible. Each fragment 158 * from the source image is multiplied by the user's scale factor and added 159 * to the user's offset value (these are component-wise operations). 160 * Finally, the resulting value is multiplied by the current OpenGL color, 161 * which contains the extra alpha value. 162 * 163 * The RescaleOp spec says that the operation is performed regardless of 164 * whether the source data is premultiplied or non-premultiplied. This is 165 * a problem for the OpenGL pipeline in that a non-premultiplied 166 * BufferedImage will have already been converted into premultiplied 167 * when uploaded to an OpenGL texture. Therefore, we have a special mode 168 * called RESCALE_NON_PREMULT (used only for source images that were 169 * originally non-premultiplied) that un-premultiplies the source color 170 * prior to the rescale operation, then re-premultiplies the resulting 171 * color before returning from the fragment shader. 172 * 173 * Note that this shader source code includes some "holes" marked by "%s". 174 * This allows us to build different shader programs (e.g. one for 175 * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on) 176 * simply by filling in these "holes" with a call to sprintf(). See the 177 * MTLBufImgOps_CreateRescaleProgram() method for more details. 178 */ 179 static const char *rescaleShaderSource = 180 // image to be rescaled 181 "uniform sampler%s baseImage;" 182 // vector containing scale factors 183 "uniform vec4 scaleFactors;" 184 // vector containing offsets 185 "uniform vec4 offsets;" 186 "" 187 "void main(void)" 188 "{" 189 " vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);" 190 // (placeholder for un-premult code) 191 " %s" 192 // rescale source value 193 " vec4 result = (srcColor * scaleFactors) + offsets;" 194 // (placeholder for re-premult code) 195 " %s" 196 // modulate with gl_Color in order to apply extra alpha 197 " gl_FragColor = result * gl_Color;" 198 "}"; 199 200 /** 201 * Flags that can be bitwise-or'ed together to control how the shader 202 * source code is generated. 203 */ 204 #define RESCALE_RECT (1 << 0) 205 #define RESCALE_NON_PREMULT (1 << 1) 206 207 /** 208 * The handles to the RescaleOp fragment program objects. The index to 209 * the array should be a bitwise-or'ing of the RESCALE_* flags defined 210 * above. Note that most applications will likely need to initialize one 211 * or two of these elements, so the array is usually sparsely populated. 212 */ 213 static GLhandleARB rescalePrograms[4]; 214 215 /** 216 * Compiles and links the RescaleOp shader program. If successful, this 217 * function returns a handle to the newly created shader program; otherwise 218 * returns 0. 219 */ 220 static GLhandleARB 221 MTLBufImgOps_CreateRescaleProgram(jint flags) 222 { 223 //TODO 224 J2dTraceNotImplPrimitive("MTLBufImgOps_CreateRescaleProgram"); 225 return NULL; 226 } 227 228 void 229 MTLBufImgOps_EnableRescaleOp(MTLContext *mtlc, jlong pSrcOps, 230 jboolean nonPremult, 231 unsigned char *scaleFactors, 232 unsigned char *offsets) 233 { 234 //TODO 235 J2dTraceNotImplPrimitive("MTLBufImgOps_EnableRescaleOp"); 236 } 237 238 void 239 MTLBufImgOps_DisableRescaleOp(MTLContext *mtlc) 240 { 241 //TODO 242 J2dTraceNotImplPrimitive("MTLBufImgOps_DisableRescaleOp"); 243 J2dTraceLn(J2D_TRACE_INFO, "MTLBufImgOps_DisableRescaleOp"); 244 RETURN_IF_NULL(mtlc); 245 } 246 247 /**************************** LookupOp support ******************************/ 248 249 /** 250 * The LookupOp shader takes a fragment color (from the source texture) as 251 * input, subtracts the optional user offset value, and then uses the 252 * resulting value to index into the lookup table texture to provide 253 * a new color result. Finally, the resulting value is multiplied by 254 * the current OpenGL color, which contains the extra alpha value. 255 * 256 * The lookup step requires 3 texture accesses (or 4, when alpha is included), 257 * which is somewhat unfortunate because it's not ideal from a performance 258 * standpoint, but that sort of thing is getting faster with newer hardware. 259 * In the 3-band case, we could consider using a three-dimensional texture 260 * and performing the lookup with a single texture access step. We already 261 * use this approach in the LCD text shader, and it works well, but for the 262 * purposes of this LookupOp shader, it's probably overkill. Also, there's 263 * a difference in that the LCD text shader only needs to populate the 3D LUT 264 * once, but here we would need to populate it on every invocation, which 265 * would likely be a waste of VRAM and CPU/GPU cycles. 266 * 267 * The LUT texture is currently hardcoded as 4 rows/bands, each containing 268 * 256 elements. This means that we currently only support user-provided 269 * tables with no more than 256 elements in each band (this is checked at 270 * at the Java level). If the user provides a table with less than 256 271 * elements per band, our shader will still work fine, but if elements are 272 * accessed with an index >= the size of the LUT, then the shader will simply 273 * produce undefined values. Typically the user would provide an offset 274 * value that would prevent this from happening, but it's worth pointing out 275 * this fact because the software LookupOp implementation would usually 276 * throw an ArrayIndexOutOfBoundsException in this scenario (although it is 277 * not something demanded by the spec). 278 * 279 * The LookupOp spec says that the operation is performed regardless of 280 * whether the source data is premultiplied or non-premultiplied. This is 281 * a problem for the OpenGL pipeline in that a non-premultiplied 282 * BufferedImage will have already been converted into premultiplied 283 * when uploaded to an OpenGL texture. Therefore, we have a special mode 284 * called LOOKUP_NON_PREMULT (used only for source images that were 285 * originally non-premultiplied) that un-premultiplies the source color 286 * prior to the lookup operation, then re-premultiplies the resulting 287 * color before returning from the fragment shader. 288 * 289 * Note that this shader source code includes some "holes" marked by "%s". 290 * This allows us to build different shader programs (e.g. one for 291 * GL_TEXTURE_2D targets, one for GL_TEXTURE_RECTANGLE_ARB targets, and so on) 292 * simply by filling in these "holes" with a call to sprintf(). See the 293 * MTLBufImgOps_CreateLookupProgram() method for more details. 294 */ 295 static const char *lookupShaderSource = 296 // source image (bound to texture unit 0) 297 "uniform sampler%s baseImage;" 298 // lookup table (bound to texture unit 1) 299 "uniform sampler2D lookupTable;" 300 // offset subtracted from source index prior to lookup step 301 "uniform vec4 offset;" 302 "" 303 "void main(void)" 304 "{" 305 " vec4 srcColor = texture%s(baseImage, gl_TexCoord[0].st);" 306 // (placeholder for un-premult code) 307 " %s" 308 // subtract offset from original index 309 " vec4 srcIndex = srcColor - offset;" 310 // use source value as input to lookup table (note that 311 // "v" texcoords are hardcoded to hit texel centers of 312 // each row/band in texture) 313 " vec4 result;" 314 " result.r = texture2D(lookupTable, vec2(srcIndex.r, 0.125)).r;" 315 " result.g = texture2D(lookupTable, vec2(srcIndex.g, 0.375)).r;" 316 " result.b = texture2D(lookupTable, vec2(srcIndex.b, 0.625)).r;" 317 // (placeholder for alpha store code) 318 " %s" 319 // (placeholder for re-premult code) 320 " %s" 321 // modulate with gl_Color in order to apply extra alpha 322 " gl_FragColor = result * gl_Color;" 323 "}"; 324 325 /** 326 * Flags that can be bitwise-or'ed together to control how the shader 327 * source code is generated. 328 */ 329 #define LOOKUP_RECT (1 << 0) 330 #define LOOKUP_USE_SRC_ALPHA (1 << 1) 331 #define LOOKUP_NON_PREMULT (1 << 2) 332 333 /** 334 * The handles to the LookupOp fragment program objects. The index to 335 * the array should be a bitwise-or'ing of the LOOKUP_* flags defined 336 * above. Note that most applications will likely need to initialize one 337 * or two of these elements, so the array is usually sparsely populated. 338 */ 339 static GLhandleARB lookupPrograms[8]; 340 341 /** 342 * The handle to the lookup table texture object used by the shader. 343 */ 344 static GLuint lutTextureID = 0; 345 346 /** 347 * Compiles and links the LookupOp shader program. If successful, this 348 * function returns a handle to the newly created shader program; otherwise 349 * returns 0. 350 */ 351 static GLhandleARB 352 MTLBufImgOps_CreateLookupProgram(jint flags) 353 { 354 //TODO 355 J2dTraceNotImplPrimitive("MTLBufImgOps_CreateLookupProgram"); 356 357 return NULL; 358 } 359 360 void 361 MTLBufImgOps_EnableLookupOp(MTLContext *mtlc, jlong pSrcOps, 362 jboolean nonPremult, jboolean shortData, 363 jint numBands, jint bandLength, jint offset, 364 void *tableValues) 365 { 366 //TODO 367 J2dTraceNotImplPrimitive("MTLBufImgOps_EnableLookupOp"); 368 } 369 370 void 371 MTLBufImgOps_DisableLookupOp(MTLContext *mtlc) 372 { 373 //TODO 374 J2dTraceNotImplPrimitive("MTLBufImgOps_DisableLookupOp"); 375 J2dTraceLn(J2D_TRACE_INFO, "MTLBufImgOps_DisableLookupOp"); 376 } 377 378 #endif /* !HEADLESS */