cc: Add support for non-2D texture targets to YUVVideoQuad.

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 194 matching lines @@
 std::string VertexShaderPosTex::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       gl_Position = matrix * a_position;
       v_texCoord = a_texCoord;
     }
   });
 }
 
 VertexShaderPosTexYUVStretchOffset::VertexShaderPosTexYUVStretchOffset()
-    : matrix_location_(-1), tex_scale_location_(-1), tex_offset_location_(-1) {
+    : matrix_location_(-1),
+      ya_tex_scale_location_(-1),
+      ya_tex_offset_location_(-1),
+      uv_tex_scale_location_(-1),
+      uv_tex_offset_location_(-1) {
 }
 
 void VertexShaderPosTexYUVStretchOffset::Init(GLES2Interface* context,
                                               unsigned program,
                                               int* base_uniform_index) {
   static const char* uniforms[] = {
-      "matrix", "texScale", "texOffset",
+      "matrix", "yaTexScale", "yaTexOffset", "uvTexScale", "uvTexOffset",
   };
   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];
+  ya_tex_scale_location_ = locations[1];
+  ya_tex_offset_location_ = locations[2];
+  uv_tex_scale_location_ = locations[3];
+  uv_tex_offset_location_ = locations[4];
 }
 
 std::string VertexShaderPosTexYUVStretchOffset::GetShaderString() const {
   return VERTEX_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string VertexShaderPosTexYUVStretchOffset::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     attribute vec4 a_position;
     attribute TexCoordPrecision vec2 a_texCoord;
     uniform mat4 matrix;
-    varying TexCoordPrecision vec2 v_texCoord;
-    uniform TexCoordPrecision vec2 texScale;
-    uniform TexCoordPrecision vec2 texOffset;
+    varying TexCoordPrecision vec2 v_yaTexCoord;
+    varying TexCoordPrecision vec2 v_uvTexCoord;
+    uniform TexCoordPrecision vec2 yaTexScale;
+    uniform TexCoordPrecision vec2 yaTexOffset;
+    uniform TexCoordPrecision vec2 uvTexScale;
+    uniform TexCoordPrecision vec2 uvTexOffset;
   });
 }
 
 std::string VertexShaderPosTexYUVStretchOffset::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       gl_Position = matrix * a_position;
-      v_texCoord = a_texCoord * texScale + texOffset;
+      v_yaTexCoord = a_texCoord * yaTexScale + yaTexOffset;
+      v_uvTexCoord = a_texCoord * uvTexScale + uvTexOffset;
     }
   });
 }
 
 VertexShaderPos::VertexShaderPos() : matrix_location_(-1) {
 }
 
 void VertexShaderPos::Init(GLES2Interface* context,
                            unsigned program,
                            int* base_uniform_index) {
@@ skipping 1771 matching lines @@
 
 std::string FragmentShaderYUVVideo::GetShaderString(TexCoordPrecision precision,
                                                     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderYUVVideo::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     precision mediump int;
-    varying TexCoordPrecision vec2 v_texCoord;
+    varying TexCoordPrecision vec2 v_yaTexCoord;
+    varying TexCoordPrecision vec2 v_uvTexCoord;
     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 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
 }
 
 std::string FragmentShaderYUVVideo::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec2 ya_clamped =
-          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_texCoord));
+          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));

[Daniele Castagna, 2015/05/09 00:43:44]

nit: clamp?

[reveman, 2015/05/09 00:56:39]

In follow up patch, maybe.

       float y_raw = TextureLookup(y_texture, ya_clamped).x;
       vec2 uv_clamped =
-          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_texCoord));
+          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       float u_unsigned = TextureLookup(u_texture, uv_clamped).x;
       float v_unsigned = TextureLookup(v_texture, uv_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;
     }
   });
 }
 
 FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
@@ skipping 42 matching lines @@
 std::string FragmentShaderYUVAVideo::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     precision mediump int;
-    varying TexCoordPrecision vec2 v_texCoord;
+    varying TexCoordPrecision vec2 v_yaTexCoord;
+    varying TexCoordPrecision vec2 v_uvTexCoord;
     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 ya_clamp_rect;
     uniform vec4 uv_clamp_rect;
   });
 }
 
 std::string FragmentShaderYUVAVideo::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec2 ya_clamped =
-          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_texCoord));
+          max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
       float y_raw = TextureLookup(y_texture, ya_clamped).x;
       vec2 uv_clamped =
-          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_texCoord));
+          max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       float u_unsigned = TextureLookup(u_texture, uv_clamped).x;
       float v_unsigned = TextureLookup(v_texture, uv_clamped).x;
       float a_raw = TextureLookup(a_texture, ya_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);
     }
   });
 }
 
@@ skipping 133 matching lines @@
       vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
       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;
     }
   });
 }
 
 }  // namespace cc