Adding YUVA support for enabling Alpha Playback

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 "base/basictypes.h"
 #include "base/logging.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 
@@ skipping 895 matching lines @@
       float y_raw = texture2D(y_texture, v_texCoord).x;
       float u_unsigned = texture2D(u_texture, v_texCoord).x;
       float v_unsigned = texture2D(v_texture, v_texCoord).x;
       vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
       vec3 rgb = yuv_matrix * yuv;
       gl_FragColor = vec4(rgb, float(1)) * alpha;
     }
   );
 }
 
+FragmentShaderYUVAVideo::FragmentShaderYUVAVideo()
+    : y_texture_location_(-1),
+      u_texture_location_(-1),
+      v_texture_location_(-1),
+      a_texture_location_(-1),
+      alpha_location_(-1),
+      yuv_matrix_location_(-1),
+      yuv_adj_location_(-1) {
+}
+
+void FragmentShaderYUVAVideo::Init(WebGraphicsContext3D* context,
+                                   unsigned program,
+                                   bool using_bind_uniform,
+                                   int* base_uniform_index) {
+  static const char* shader_uniforms[] = {
+      "y_texture",
+      "u_texture",
+      "v_texture",
+      "a_texture",
+      "alpha",
+      "cc_matrix",
+      "yuv_adj",
+  };
+  int locations[7];
+
+  GetProgramUniformLocations(context,
+                             program,
+                             shader_uniforms,
+                             arraysize(shader_uniforms),
+                             arraysize(locations),
+                             locations,
+                             using_bind_uniform,
+                             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];
+
+  DCHECK(y_texture_location_ != -1 && u_texture_location_ != -1 &&
+         v_texture_location_ != -1 && a_texture_location_ != -1 &&
+         alpha_location_ != -1 && yuv_matrix_location_ != -1 &&
+         yuv_adj_location_ != -1);
+}
+
+std::string FragmentShaderYUVAVideo::GetShaderString() const {
+  return SHADER(
+    precision mediump float;
+    precision mediump int;
+    varying vec2 y_texCoord;
+    varying vec2 uv_texCoord;

[enne (OOO), 2013/04/05 23:06:53]

I'm still a little confused about how this varying parameter gets hooked up
since there's only one varying parameter in the vertex shader.  Am I missing
something?

[vignesh, 2013/04/09 20:48:03]

You are right, the shader emits only one varying parameter. Have changed it.

+    uniform sampler2D y_texture;
+    uniform sampler2D u_texture;
+    uniform sampler2D v_texture;
+    uniform sampler2D a_texture;
+    uniform float alpha;
+    uniform vec3 yuv_adj;
+    uniform mat3 cc_matrix;
+    void main() {
+      float y_raw = texture2D(y_texture, y_texCoord).x;
+      float u_unsigned = texture2D(u_texture, uv_texCoord).x;
+      float v_unsigned = texture2D(v_texture, uv_texCoord).x;
+      float a_raw = texture2D(a_texture, y_texCoord).x;
+      vec3 yuv = vec3(y_raw, u_unsigned, v_unsigned) + yuv_adj;
+      vec3 rgb = cc_matrix * yuv;
+      gl_FragColor = vec4(rgb, float(1)) * (a_raw * alpha);
+    }
+  );
+}
+
 FragmentShaderColor::FragmentShaderColor()
     : color_location_(-1) {}
 
 void FragmentShaderColor::Init(WebGraphicsContext3D* context,
                                unsigned program,
                                bool using_bind_uniform,
                                int* base_uniform_index) {
   static const char* shader_uniforms[] = {
     "color",
   };
@@ skipping 122 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);
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   );
 }
 
 }  // namespace cc