cc: custom bilinear filtering for YUV quad.

cc/output/shader.cc

 // Copyright 2011 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 "cc/output/shader.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 2010 matching lines @@
       a_texture_location_(-1),
       lut_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
       yuv_adj_location_(-1),
       ya_clamp_rect_location_(-1),
       uv_clamp_rect_location_(-1),
       resource_multiplier_location_(-1),
       resource_offset_location_(-1) {}
 
-void FragmentShaderYUVVideo::SetFeatures(bool use_alpha_texture,
+void FragmentShaderYUVVideo::SetFeatures(SamplerType sampler,
+                                         bool use_alpha_texture,
                                          bool use_nv12,
                                          bool use_color_lut) {
+  sampler_ = sampler;
   use_alpha_texture_ = use_alpha_texture;
   use_nv12_ = use_nv12;
   use_color_lut_ = use_color_lut;
 }
 
 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "uv_texture",
       "a_texture",
       "lut_texture",
       "resource_multiplier",
       "resource_offset",
       "yuv_matrix",
       "yuv_adj",
+      "ya_size",
+      "uv_subsampling_factor",
       "alpha",
       "ya_clamp_rect",
       "uv_clamp_rect",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
@@ skipping 10 matching lines @@
     a_texture_location_ = locations[4];
   }
   if (use_color_lut_) {
     lut_texture_location_ = locations[5];
     resource_multiplier_location_ = locations[6];
     resource_offset_location_ = locations[7];
   } else {
     yuv_matrix_location_ = locations[8];
     yuv_adj_location_ = locations[9];
   }
-  alpha_location_ = locations[10];
-  ya_clamp_rect_location_ = locations[11];
-  uv_clamp_rect_location_ = locations[12];
+  if (sampler_ != SAMPLER_TYPE_2D_RECT) {
+    ya_size_location_ = locations[10];
+  } else {
+    uv_subsampling_factor_location_ = locations[11];
+  }
+  alpha_location_ = locations[12];
+  ya_clamp_rect_location_ = locations[13];
+  uv_clamp_rect_location_ = locations[14];
 }
 
 std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
                                                     SamplerType sampler) const {
   std::string head = SHADER0([]() {
     precision mediump float;
     precision mediump int;
     varying TexCoordPrecision vec2 v_yaTexCoord;
     varying TexCoordPrecision vec2 v_uvTexCoord;
     uniform SamplerType y_texture;
     uniform float alpha;
     uniform vec4 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
+  // SHADER0 cannot handle #define
+  head += "\n";
+  head += "  #define PLANE_TYPE int\n";
+  head += "  #define YA 1\n";
+  head += "  #define UV 2\n";
 
-  std::string functions = "";
+  std::string functions = SHADER0([]() {
+    vec2 TextureLookupBilinearInternal(SamplerType sampler, vec2 snap_tex_coord,
+                                       vec2 unit_texel, vec2 factor) {
+      vec2 s1 = TextureLookup(sampler, snap_tex_coord).xy;
+      vec2 s2 =
+          TextureLookup(sampler, snap_tex_coord + vec2(unit_texel.x, 0.)).xy;
+      vec2 s3 =
+          TextureLookup(sampler, snap_tex_coord + vec2(0., unit_texel.y)).xy;
+      vec2 s4 = TextureLookup(sampler, snap_tex_coord + unit_texel).xy;
+      return mix(mix(s1, s2, factor.x), mix(s3, s4, factor.x), factor.y);
+    }
+  });
+  if (sampler_ == SAMPLER_TYPE_2D_RECT) {
+    head += "  uniform vec2 uv_subsampling_factor;\n";
+    functions += SHADER0([]() {
+      vec2 TextureLookupBilinear(SamplerType sampler, vec2 tex_coord,
+                                 PLANE_TYPE type) {
+        vec2 ya_tex_coord = tex_coord;
+        if (type == UV) {
+          ya_tex_coord = tex_coord / uv_subsampling_factor;
+        }
+        vec2 unnorm_tex_coord = ya_tex_coord - vec2(0.5);
+        vec2 f = fract(unnorm_tex_coord);
+        vec2 texel_offset = floor(unnorm_tex_coord) - floor(ya_tex_coord);
+        vec2 unit_texel = vec2(1.);
+        if (type == UV) {
+          texel_offset = texel_offset * uv_subsampling_factor;
+          unit_texel = unit_texel * uv_subsampling_factor;
+        }
+        vec2 snap_tex_coord =
+            floor(tex_coord) + (unit_texel * 0.5) + texel_offset;
+        return TextureLookupBilinearInternal(sampler, snap_tex_coord,
+                                             unit_texel, f);
+      }
+    });
+  } else {
+    head += "  uniform vec2 ya_size;\n";
+    functions += SHADER0([]() {
+      // refer to Mesa sample_2d_linear() in s_texfilter.c
+      // https://cs.chromium.org/chromium/src/third_party/mesa/src/src/mesa/swrast/s_texfilter.c?q=sample_2d_linear&sq=package:chromium
+      //
+      // This shader needs a custom bilinear filter because U plane can be
+      // smaller than Y plane.
+      // For example, look at the following figures. When the current fragment
+      // samples the middle point of (3, 3) texel of Y texture, it points out
+      // upper left of (1, 1) texel of U texture. The default GL_LINEAR samples
+      // 4 texels of U plane, while it samples only (3, 3) texel of Y plane.
+      // TextureLookupBilinear() samples U plane with Y plane fraction to
+      // sample like Y plane.
+      //  Y 4x4      U 2x2    U sampling by GL_LINEAR
+      //  +-+-+-+-+  +--+--+  +--+--+
+      //  | | | | |  |  |  |  |  |  |
+      //  +-------+  |  |  |  | +--++
+      //  | | | | |  +-----+  +-----|
+      //  +-------+  |  |· |  | ||·||
+      //  | | |·| |  |  |  |  | +--+|
+      //  +-------+  +--+--+  +-----+
+      //  | | | | |
+      //  +-+-+-+-+
+      vec2 TextureLookupBilinear(SamplerType sampler, vec2 tex_coord,
+                                 PLANE_TYPE type) {
+        vec2 unit_texel = 1.0 / ya_size;
+        vec2 unnorm_tex_coord = (tex_coord * ya_size) - vec2(0.5);
+        vec2 f = fract(unnorm_tex_coord);
+        vec2 snap_tex_coord = (floor(unnorm_tex_coord) + vec2(0.5)) / ya_size;
+        return TextureLookupBilinearInternal(sampler, snap_tex_coord,
+                                             unit_texel, f);
+      }
+    });
+  }
   if (use_nv12_) {
     head += "  uniform SamplerType uv_texture;\n";
     functions += SHADER0([]() {
       vec2 GetUV(vec2 uv_clamped) {
-        return TextureLookup(uv_texture, uv_clamped).xy;
+        return TextureLookupBilinear(uv_texture, uv_clamped, UV);
       }
     });
   } else {
     head += "  uniform SamplerType u_texture;\n";
     head += "  uniform SamplerType v_texture;\n";
     functions += SHADER0([]() {
       vec2 GetUV(vec2 uv_clamped) {
-        return vec2(TextureLookup(u_texture, uv_clamped).x,
-                    TextureLookup(v_texture, uv_clamped).x);
+        return vec2(TextureLookupBilinear(u_texture, uv_clamped, UV).x,
+                    TextureLookupBilinear(v_texture, uv_clamped, UV).x);
       }
     });
   }
 
   if (use_alpha_texture_) {
     head += "  uniform SamplerType a_texture;\n";
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) {
-        return alpha * TextureLookup(a_texture, ya_clamped).x;
+        return alpha * TextureLookupBilinear(a_texture, ya_clamped, YA).x;
       }
     });
   } else {
     functions += SHADER0([]() {
       float GetAlpha(vec2 ya_clamped) { return alpha; }
     });
   }
 
   if (use_color_lut_) {
     head += "  uniform sampler2D lut_texture;\n";
@@ skipping 23 matching lines @@
     head += "  uniform vec3 yuv_adj;\n";
     functions += SHADER0([]() {
       vec3 yuv2rgb(vec3 yuv) { return yuv_matrix * (yuv + yuv_adj); }
     });
   }
 
   functions += SHADER0([]() {
     void main() {
       vec2 ya_clamped =
           max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
-      float y_raw = TextureLookup(y_texture, ya_clamped).x;
+      float y_raw = TextureLookupBilinear(y_texture, ya_clamped, YA).x;
       vec2 uv_clamped =
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
       gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return FRAGMENT_SHADER(head, functions);
 }
 
@@ skipping 73 matching lines @@
     void main() {
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
       gl_FragColor = color * aa;
     }
   });
 }
 
 }  // namespace cc