Clamp YUV videos to their visible size in the shader

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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 173 matching lines @@
       void main() {
         gl_Position = matrix * a_position;
         v_texCoord = a_texCoord;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 VertexShaderPosTexYUVStretchOffset::VertexShaderPosTexYUVStretchOffset()
-    : matrix_location_(-1), tex_scale_location_(-1), tex_offset_location_(-1) {
+    : matrix_location_(-1),
+      tex_scale_location_(-1),
+      tex_offset_location_(-1) {
 }
 
 void VertexShaderPosTexYUVStretchOffset::Init(GLES2Interface* context,
                                               unsigned program,
                                               int* base_uniform_index) {
   static const char* uniforms[] = {
       "matrix", "texScale", "texOffset",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   matrix_location_ = locations[0];
   tex_scale_location_ = locations[1];
   tex_offset_location_ = locations[2];
 }
 
 std::string VertexShaderPosTexYUVStretchOffset::GetShaderString() const {
   // clang-format off
   return VERTEX_SHADER(
       // clang-format on
-      precision mediump float;
-      attribute vec4 a_position;
+      precision mediump float; attribute vec4 a_position;

[danakj, 2015/02/02 18:43:03]

?

       attribute TexCoordPrecision vec2 a_texCoord;
       uniform mat4 matrix;
       varying TexCoordPrecision vec2 v_texCoord;
       uniform TexCoordPrecision vec2 texScale;
       uniform TexCoordPrecision vec2 texOffset;
       void main() {
         gl_Position = matrix * a_position;
         v_texCoord = a_texCoord * texScale + texOffset;
       }
       // clang-format off
@@ skipping 1502 matching lines @@
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
-      yuv_adj_location_(-1) {
+      yuv_adj_location_(-1),
+      clamp_rect_location_(-1) {
 }
 
 void FragmentShaderYUVVideo::Init(GLES2Interface* context,
                                   unsigned program,
                                   int* base_uniform_index) {
-  static const char* uniforms[] = {
-      "y_texture", "u_texture", "v_texture", "alpha", "yuv_matrix", "yuv_adj",
-  };
+  static const char* uniforms[] = {"y_texture",
+                                   "u_texture",
+                                   "v_texture",
+                                   "alpha",
+                                   "yuv_matrix",
+                                   "yuv_adj",
+                                   "clamp_rect"};
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   alpha_location_ = locations[3];
   yuv_matrix_location_ = locations[4];
   yuv_adj_location_ = locations[5];
+  clamp_rect_location_ = locations[6];
 }
 
 std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
                                                     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
       precision mediump int;
       varying TexCoordPrecision vec2 v_texCoord;
       uniform SamplerType y_texture;
       uniform SamplerType u_texture;
       uniform SamplerType v_texture;
       uniform float alpha;
       uniform vec3 yuv_adj;
       uniform mat3 yuv_matrix;
+      uniform vec4 clamp_rect;
       void main() {
-        float y_raw = TextureLookup(y_texture, v_texCoord).x;
-        float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
-        float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
+        vec2 clamped = max(clamp_rect.xy, min(clamp_rect.zw, v_texCoord));

[enne (OOO), 2015/01/31 01:32:14]

I moved the clamping from the vertex to the fragment shader, because otherwise
it would cause stretching of the texture, rather than just more localized
clamping.

+        float y_raw = TextureLookup(y_texture, clamped).x;
+        float u_unsigned = TextureLookup(u_texture, clamped).x;
+        float v_unsigned = TextureLookup(v_texture, clamped).x;
         vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
         vec3 rgb = yuv_matrix * yuv;
         gl_FragColor = vec4(rgb, 1.0) * alpha;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
@@ skipping 10 matching lines @@
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
       "y_texture",
       "u_texture",
       "v_texture",
       "a_texture",
       "alpha",
       "cc_matrix",
       "yuv_adj",
+      "clamp_rect",
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
                              arraysize(uniforms),
                              uniforms,
                              locations,
                              base_uniform_index);
   y_texture_location_ = locations[0];
   u_texture_location_ = locations[1];
   v_texture_location_ = locations[2];
   a_texture_location_ = locations[3];
   alpha_location_ = locations[4];
   yuv_matrix_location_ = locations[5];
   yuv_adj_location_ = locations[6];
+  clamp_rect_location_ = locations[7];
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   // clang-format off
   return FRAGMENT_SHADER(
       // clang-format on
       precision mediump float;
       precision mediump int;
       varying TexCoordPrecision vec2 v_texCoord;
       uniform SamplerType y_texture;
       uniform SamplerType u_texture;
       uniform SamplerType v_texture;
       uniform SamplerType a_texture;
       uniform float alpha;
       uniform vec3 yuv_adj;
       uniform mat3 yuv_matrix;
+      uniform vec4 clamp_rect;
       void main() {
-        float y_raw = TextureLookup(y_texture, v_texCoord).x;
-        float u_unsigned = TextureLookup(u_texture, v_texCoord).x;
-        float v_unsigned = TextureLookup(v_texture, v_texCoord).x;
-        float a_raw = TextureLookup(a_texture, v_texCoord).x;
+        vec2 clamped = max(clamp_rect.xy, min(clamp_rect.zw, v_texCoord));
+        float y_raw = TextureLookup(y_texture, clamped).x;
+        float u_unsigned = TextureLookup(u_texture, clamped).x;
+        float v_unsigned = TextureLookup(v_texture, clamped).x;
+        float a_raw = TextureLookup(a_texture, clamped).x;
         vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
         vec3 rgb = yuv_matrix * yuv;
         gl_FragColor = vec4(rgb, 1.0) * (alpha * a_raw);
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 FragmentShaderColor::FragmentShaderColor() : color_location_(-1) {
@@ skipping 118 matching lines @@
         vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
         float picker = abs(coord.x - coord.y);  // NOLINT
         gl_FragColor = mix(color1, color2, picker) * alpha;
       }
       // clang-format off
   );  // NOLINT(whitespace/parens)
   // clang-format on
 }
 
 }  // namespace cc