gpu, cmaa: Don't blend large L shape because it would be the intended shape with high probability.

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 1464 matching lines @@
         int _y = _i / 2;
 
         ivec3 screenPosI = screenPosIBase + ivec3(_x, _y, 0);
 
         uint packedEdgesC = packedEdgesArray[(1 + _x) * 4 + (1 + _y)];
 
         uvec4 edges = UnpackEdge(packedEdgesC);
         vec4 edgesFlt = vec4(edges);
 
         float numberOfEdges = dot(edgesFlt, vec4(1, 1, 1, 1));
-        if (numberOfEdges < 2.0)
+        if (numberOfEdges <= 1.0)
           continue;
 
         float fromRight = edgesFlt.r;
         float fromAbove = edgesFlt.g;
         float fromLeft = edgesFlt.b;
         float fromBelow = edgesFlt.a;
 
         vec4 xFroms = vec4(fromBelow, fromAbove, fromRight, fromLeft);
 
         float blurCoeff = 0.0;
 
         // These are additional blurs that complement the main line-based
         // blurring; Unlike line-based, these do not necessarily preserve
         // the total amount of screen colour as they will take
         // neighbouring pixel colours and apply them to the one currently
         // processed.
 
         // 1.) L-like shape.
         // For this shape, the total amount of screen colour will be
         // preserved when this is a part of a (zigzag) diagonal line as the
         // corners from the other side  will do the same and take some of
         // the current pixel's colour in return.
         // However, in the case when this is an actual corner, the pixel's
         // colour will be partially overwritten by it's 2 neighbours.
-        // if( numberOfEdges > 1.0 )
+        if( numberOfEdges == 2.0 )
         {
           // with value of 0.15, the pixel will retain approx 77% of its
           // colour and the remaining 23% will come from its 2 neighbours
           // (which are likely to be blurred too in the opposite direction)
           blurCoeff = 0.08;
 
           // Only do blending if it's L shape - if we're between two
           // parallel edges, don't do anything
           blurCoeff *= (1.0 - fromBelow * fromAbove) *
                        (1.0 - fromRight * fromLeft);
+
+          if (blurCoeff == 0.0)
+            continue;
+
+          uint packedEdgesL = packedEdgesArray[(0 + _x) * 4 + (1 + _y)];
+          uint packedEdgesB = packedEdgesArray[(1 + _x) * 4 + (0 + _y)];
+          uint packedEdgesR = packedEdgesArray[(2 + _x) * 4 + (1 + _y)];
+          uint packedEdgesT = packedEdgesArray[(1 + _x) * 4 + (2 + _y)];
+
+          // Don't blend large L shape because it would be the intended shape
+          // with high probability. e.g. rectangle
+          // large_l1 large_l2 large_l3 large_l4
+          // _ _         |     |         _ _
+          //   X|       X|     |X       |X
+          //    |     ¯¯¯¯     ¯¯¯¯     |
+          bool large_l1 = (packedEdgesC == (0x01u | 0x02u)) &&
+                           bool(packedEdgesL & 0x02u) &&
+                           bool(packedEdgesB & 0x01u);
+          bool large_l2 = (packedEdgesC == (0x01u | 0x08u)) &&
+                           bool(packedEdgesL & 0x08u) &&
+                           bool(packedEdgesT & 0x01u);
+          bool large_l3 = (packedEdgesC == (0x04u | 0x08u)) &&
+                           bool(packedEdgesR & 0x08u) &&
+                           bool(packedEdgesT & 0x04u);
+          bool large_l4 = (packedEdgesC == (0x02u | 0x04u)) &&
+                           bool(packedEdgesR & 0x02u) &&
+                           bool(packedEdgesB & 0x04u);
+          if (large_l1 || large_l2 || large_l3 || large_l4)
+            continue;
         }
 
         // 2.) U-like shape (surrounded with edges from 3 sides)
-        if (numberOfEdges > 2.0) {
+        if (numberOfEdges == 3.0) {
           // with value of 0.13, the pixel will retain approx 72% of its
           // colour and the remaining 28% will be picked from its 3
           // neighbours (which are unlikely to be blurred too but could be)
           blurCoeff = 0.11;
         }
 
         // 3.) Completely surrounded with edges from all 4 sides
-        if (numberOfEdges > 3.0) {
+        if (numberOfEdges == 4.0) {
           // with value of 0.07, the pixel will retain 78% of its colour
           // and the remaining 22% will come from its 4 neighbours (which
           // are unlikely to be blurred)
           blurCoeff = 0.05;
         }
 
-        if (blurCoeff == 0.0) {
-          // this avoids Z search below as well but that's ok because a Z
-          // shape will also always have some blurCoeff
-          continue;
-        }
-
+        // |blurCoeff| must be not zero at this point.
         vec4 blurMap = xFroms * blurCoeff;
 
         vec4 pixelC = texelFetch(g_screenTexture, screenPosI.xy, 0);
 
         const float centerWeight = 1.0;
         float fromBelowWeight = blurMap.x;
         float fromAboveWeight = blurMap.y;
         float fromRightWeight = blurMap.z;
         float fromLeftWeight  = blurMap.w;
 
@@ skipping 273 matching lines @@
       \n#ifdef OUT_FBO\n
         outColor = pixel;
       \n#else\n
         imageStore(outTexture, screenPosI, pixel);
       \n#endif\n
       }
     );
 /* clang-format on */
 
 }  // namespace gpu