gpu, cmaa: don't blend the rightmost and topmost edges.

gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_apply_framebuffer_attachment_cmaa_intel.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "ui/gl/gl_context.h"
@@ skipping 1181 matching lines @@
                      pixel12);
       }
       outEdges = STORE_UVEC4(outputEdges);
     }
     \n#endif\n  // DETECT_EDGES1
 
     vec2 UnpackThresholds(uint val) {
       return vec2(val & 0x0Fu, val >> 4u) / 15.0f;
     }
 
-    uint PruneNonDominantEdges(vec4 edges[3]) {
+    uvec4 PruneNonDominantEdges(vec4 edges[3]) {
       vec4 maxE4 = vec4(0.0, 0.0, 0.0, 0.0);
 
       float avg = 0.0;
 
       for (int i = 0; i < 3; i++) {
         maxE4 = max(maxE4, edges[i]);
 
         avg = dot(edges[i], vec4(1, 1, 1, 1) / (3.0 * 4.0));
       }
 
       vec2 maxE2 = max(maxE4.xy, maxE4.zw);
       float maxE = max(maxE2.x, maxE2.y);
 
       float threshold = avg * 0.65 + maxE * 0.35;
 
       // threshold = 0.0001; // this disables non-dominant edge pruning!
 
       uint cx = edges[0].x >= threshold ? 1u : 0u;
       uint cy = edges[0].y >= threshold ? 1u : 0u;
-      return PackEdge(uvec4(cx, cy, 0, 0));
+      return uvec4(cx, cy, 0, 0);
     }
 
     void CollectEdges(int offX,
                       int offY,
                       out vec4 edges[3],
                       const uint packedVals[6 * 6]) {
       vec2 pixelP0P0 = UnpackThresholds(packedVals[(offX)*6+(offY)]);
       vec2 pixelP1P0 = UnpackThresholds(packedVals[(offX+1)*6+(offY)]);
       vec2 pixelP0P1 = UnpackThresholds(packedVals[(offX)*6+(offY+1)]);
       vec2 pixelM1P0 = UnpackThresholds(packedVals[(offX-1)*6 +(offY)]);
@@ skipping 15 matching lines @@
       edges[2].w = pixelM1P1.x;
     }
   );
 
 const char ApplyFramebufferAttachmentCMAAINTELResourceManager::cmaa_frag_s2_[] =
   SHADER(
     \n#ifdef DETECT_EDGES2\n
     layout(early_fragment_tests) in;
     void DetectEdges2() {
       ivec2 screenPosI = ivec2(gl_FragCoord.xy);
+      ivec2 notTopRight =
+          ivec2((screenPosI + 1) != textureSize(g_src0Texture4Uint, 0));

[piman, 2016/06/28 21:09:38]

Actually, going back from the next CL, I think I have the same comment here.
"(screenPosI + 1) != textureSize(g_src0Texture4Uint, 0)" is a scalar boolean, so
notTopRight.x == notTopRight.y - is that what you want?

[dshwang, 2016/06/29 10:41:54]

I explain this code is introduced to avoid "if statement" in 
https://codereview.chromium.org/2103893003/

The shader fetches data one pixel above the current pixel. If current pixel is
(_, height - 1), the shader must avoid storing above pixel.
The intuitive alternative of this code would be

// in "if (bool(packedVals[(3) * 6 + (2)]))" case
uvec4 dominant_edges = PruneNonDominantEdges(edges);
// The rightmost edge of the texture is not edge.
if (screenPosI.y == (textureSize(g_src0Texture4Uint, 0).y - 1)
  dominant_edges = uvec4(dominant_edges.x, 0, dominant_edges.zw);
uint pe = PackEdge(dominant_edges);

I want to avoid using "if statement", so replace "if" to multiplying. WDYT?

[dshwang, 2016/06/29 13:53:01]

oh my bad. I actually want "notEqual((screenPosI + 1),
textureSize(g_src0Texture4Uint, 0))".

Previous bug code fixes the webgl conformance test because the texture size in
tests is 2x2 or 1x1. I updated this CL to use notEqual for component wise
comparison, instead of scalar boolean

 
       // source : edge differences from previous pass
       uint packedVals[6 * 6];
 
       // center pixel (our output)
       UVEC4 packedQ4 = texelFetch(g_src0Texture4Uint, screenPosI.xy, 0);
       packedVals[(2) * 6 + (2)] = LOAD_UINT(packedQ4.x);
       packedVals[(3) * 6 + (2)] = LOAD_UINT(packedQ4.y);
       packedVals[(2) * 6 + (3)] = LOAD_UINT(packedQ4.z);
       packedVals[(3) * 6 + (3)] = LOAD_UINT(packedQ4.w);
@@ skipping 14 matching lines @@
         UVEC4 packedQ3 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(-1, 0));
         packedVals[(0) * 6 + (2)] = LOAD_UINT(packedQ3.x);
         packedVals[(1) * 6 + (2)] = LOAD_UINT(packedQ3.y);
         packedVals[(0) * 6 + (3)] = LOAD_UINT(packedQ3.z);
         packedVals[(1) * 6 + (3)] = LOAD_UINT(packedQ3.w);
       }
 
       if (bool(packedVals[(2) * 6 + (2)])) {
         CollectEdges(2, 2, edges, packedVals);
-        uint pe = PruneNonDominantEdges(edges);
+        uint pe = PackEdge(PruneNonDominantEdges(edges));
         if (pe != 0u) {
           imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 0),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(3) * 6 + (2)]) ||
           bool(packedVals[(3) * 6 + (3)])) {
         UVEC4 packedQ5 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(1, 0));
         packedVals[(4) * 6 + (2)] = LOAD_UINT(packedQ5.x);
         packedVals[(5) * 6 + (2)] = LOAD_UINT(packedQ5.y);
         packedVals[(4) * 6 + (3)] = LOAD_UINT(packedQ5.z);
         packedVals[(5) * 6 + (3)] = LOAD_UINT(packedQ5.w);
       }
 
       if (bool(packedVals[(3) * 6 + (2)])) {
         UVEC4 packedQ2 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(1, -1));
         packedVals[(4) * 6 + (0)] = LOAD_UINT(packedQ2.x);
         packedVals[(5) * 6 + (0)] = LOAD_UINT(packedQ2.y);
         packedVals[(4) * 6 + (1)] = LOAD_UINT(packedQ2.z);
         packedVals[(5) * 6 + (1)] = LOAD_UINT(packedQ2.w);
 
         CollectEdges(3, 2, edges, packedVals);
-        uint pe = PruneNonDominantEdges(edges);
+        uvec4 dominant_edges = PruneNonDominantEdges(edges);
+        // The rightmost edge of the texture is not edge.
+        // Note: texelFetch() on out of range gives an undefined value.
+        uint pe = PackEdge(dominant_edges * uvec4(notTopRight.x, 1, 1, 1));
         if (pe != 0u) {
           imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 0),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(2) * 6 + (3)]) ||
           bool(packedVals[(3) * 6 + (3)])) {
         UVEC4 packedQ7 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(0, 1));
         packedVals[(2) * 6 + (4)] = LOAD_UINT(packedQ7.x);
         packedVals[(3) * 6 + (4)] = LOAD_UINT(packedQ7.y);
         packedVals[(2) * 6 + (5)] = LOAD_UINT(packedQ7.z);
         packedVals[(3) * 6 + (5)] = LOAD_UINT(packedQ7.w);
       }
 
       if (bool(packedVals[(2) * 6 + (3)])) {
         UVEC4 packedQ6 = texelFetchOffset(g_src0Texture4Uint,
                                           screenPosI.xy, 0, ivec2(-1, -1));
         packedVals[(0) * 6 + (4)] = LOAD_UINT(packedQ6.x);
         packedVals[(1) * 6 + (4)] = LOAD_UINT(packedQ6.y);
         packedVals[(0) * 6 + (5)] = LOAD_UINT(packedQ6.z);
         packedVals[(1) * 6 + (5)] = LOAD_UINT(packedQ6.w);
 
         CollectEdges(2, 3, edges, packedVals);
-        uint pe = PruneNonDominantEdges(edges);
+        uvec4 dominant_edges = PruneNonDominantEdges(edges);
+        uint pe = PackEdge(dominant_edges * uvec4(1, notTopRight.y, 1, 1));
         if (pe != 0u) {
           imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(0, 1),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
 
       if (bool(packedVals[(3) * 6 + (3)])) {
         CollectEdges(3, 3, edges, packedVals);
-        uint pe = PruneNonDominantEdges(edges);
+        uvec4 dominant_edges = PruneNonDominantEdges(edges);
+        uint pe = PackEdge(dominant_edges * uvec4(notTopRight, 1, 1));
         if (pe != 0u) {
           imageStore(g_resultTexture, 2 * screenPosI.xy + ivec2(1, 1),
                      vec4(float(0x80u | pe) / 255.0, 0, 0, 0));
         }
       }
     }
     \n#endif\n  // DETECT_EDGES2
 
     \n#ifdef COMBINE_EDGES\n
     void CombineEdges() {
@@ skipping 464 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu