Adding YUVA support for enabling Alpha Playback

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 61 matching lines @@
 bool NeedsIOSurfaceReadbackWorkaround() {
 #if defined(OS_MACOSX)
   // This isn't strictly required in DumpRenderTree-mode when Mesa is used,
   // but it doesn't seem to hurt.
   return true;
 #else
   return false;
 #endif
 }
 
+// These values are magic numbers that are used in the transformation from YUV

[danakj, 2013/04/11 21:10:00]

Seems like these can stay local to the DrawYUVQuad function now since they are
only used there?

[vignesh, 2013/05/30 23:28:25]

Done.

+// to RGB color values. They are taken from the following webpage:
+// http://www.fourcc.org/fccyvrgb.php
+float yuv_to_rgb[9] = {
+    1.164f, 1.164f, 1.164f,
+    0.f, -.391f, 2.018f,
+    1.596f, -.813f, 0.f,
+};
+
+// These values map to 16, 128, and 128 respectively, and are computed
+// as a fraction over 256 (e.g. 16 / 256 = 0.0625).
+// They are used in the YUV to RGBA conversion formula:
+//   Y - 16   : Gives 16 values of head and footroom for overshooting
+//   U - 128  : Turns unsigned U into signed U [-128,127]
+//   V - 128  : Turns unsigned V into signed V [-128,127]
+float yuv_adjust[3] = { -0.0625f, -0.5f, -0.5f, };
+
 }  // anonymous namespace
 
 scoped_ptr<GLRenderer> GLRenderer::Create(RendererClient* client,
                                           OutputSurface* output_surface,
                                           ResourceProvider* resource_provider) {
   scoped_ptr<GLRenderer> renderer(
       new GLRenderer(client, output_surface, resource_provider));
   if (!renderer->Initialize())
     return scoped_ptr<GLRenderer>();
 
@@ skipping 1100 matching lines @@
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
   DrawQuadGeometry(
       frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
-  const VideoYUVProgram* program = GetVideoYUVProgram();
-  DCHECK(program && (program->initialized() || IsContextLost()));
-
   const VideoLayerImpl::FramePlane& y_plane = quad->y_plane;
   const VideoLayerImpl::FramePlane& u_plane = quad->u_plane;
   const VideoLayerImpl::FramePlane& v_plane = quad->v_plane;
+  const VideoLayerImpl::FramePlane& a_plane = quad->a_plane;
+  bool use_alpha_plane = a_plane.resource_id != 0;
 
   GLC(Context(), Context()->activeTexture(GL_TEXTURE1));
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, y_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
   GLC(Context(), Context()->activeTexture(GL_TEXTURE2));
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, u_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
   GLC(Context(), Context()->activeTexture(GL_TEXTURE3));
   ResourceProvider::ScopedSamplerGL v_plane_lock(
       resource_provider_, v_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
+  if (use_alpha_plane) {
+    scoped_ptr<ResourceProvider::ScopedSamplerGL> a_plane_lock;
+    a_plane_lock.reset(new ResourceProvider::ScopedSamplerGL(
+        resource_provider_,
+        a_plane.resource_id,
+        GL_TEXTURE_2D,
+        GL_LINEAR));
+  }
 
-  SetUseProgram(program->program());
+  int tex_scale_location = -1;
+  int matrix_location = -1;
+  int y_texture_location = -1;
+  int u_texture_location = -1;
+  int v_texture_location = -1;
+  int a_texture_location = -1;
+  int yuv_matrix_location = -1;
+  int yuv_adj_location = -1;
+  int alpha_location = -1;
+  if (use_alpha_plane) {

[danakj, 2013/04/11 21:10:00]

If (use_alpha_plane) is true, you are using the YUV program instead of the YUVA
program.

I think you might want to test this to make sure it's working as expected.

[vignesh, 2013/05/30 23:28:25]

Done.

+    const VideoYUVProgram* program = GetVideoYUVProgram();
+    DCHECK(program && (program->initialized() || IsContextLost()));
+    SetUseProgram(program->program());
+    tex_scale_location = program->vertex_shader().tex_scale_location();
+    matrix_location = program->vertex_shader().matrix_location();
+    y_texture_location = program->fragment_shader().y_texture_location();
+    u_texture_location = program->fragment_shader().u_texture_location();
+    v_texture_location = program->fragment_shader().v_texture_location();
+    yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
+    yuv_adj_location = program->fragment_shader().yuv_adj_location();
+    alpha_location = program->fragment_shader().alpha_location();
+  } else {
+    const VideoYUVAProgram* program = GetVideoYUVAProgram();
+    DCHECK(program && (program->initialized() || IsContextLost()));
+    SetUseProgram(program->program());
+    tex_scale_location = program->vertex_shader().tex_scale_location();
+    matrix_location = program->vertex_shader().matrix_location();
+    y_texture_location = program->fragment_shader().y_texture_location();
+    u_texture_location = program->fragment_shader().u_texture_location();
+    v_texture_location = program->fragment_shader().v_texture_location();
+    a_texture_location = program->fragment_shader().a_texture_location();
+    yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
+    yuv_adj_location = program->fragment_shader().yuv_adj_location();
+    alpha_location = program->fragment_shader().alpha_location();
+  }
 
   GLC(Context(),
-      Context()->uniform2f(program->vertex_shader().tex_scale_location(),
+      Context()->uniform2f(tex_scale_location,
                            quad->tex_scale.width(),
                            quad->tex_scale.height()));
+  GLC(Context(), Context()->uniform1i(y_texture_location, 1));
+  GLC(Context(), Context()->uniform1i(u_texture_location, 2));
+  GLC(Context(), Context()->uniform1i(v_texture_location, 3));
+  if (use_alpha_plane) {
+    GLC(Context(), Context()->uniform1i(a_texture_location, 4));

[danakj, 2013/04/11 21:10:00]

nit: no {} for 1 line body

[vignesh, 2013/05/30 23:28:25]

Done.

+  }
+
   GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().y_texture_location(), 1));
-  GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().u_texture_location(), 2));
-  GLC(Context(),
-      Context()->uniform1i(program->fragment_shader().v_texture_location(), 3));
+      Context()->uniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
+  GLC(Context(), Context()->uniform3fv(yuv_adj_location, 1, yuv_adjust));
 
-  // These values are magic numbers that are used in the transformation from YUV
-  // to RGB color values.  They are taken from the following webpage:
-  // http://www.fourcc.org/fccyvrgb.php
-  float yuv_to_rgb[9] = {
-      1.164f, 1.164f, 1.164f,
-      0.0f, -.391f, 2.018f,
-      1.596f, -.813f, 0.0f,
-  };
-  GLC(Context(),
-      Context()->uniformMatrix3fv(
-          program->fragment_shader().yuv_matrix_location(), 1, 0, yuv_to_rgb));
 
-  // These values map to 16, 128, and 128 respectively, and are computed
-  // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
-  // They are used in the YUV to RGBA conversion formula:
-  //   Y - 16   : Gives 16 values of head and footroom for overshooting
-  //   U - 128  : Turns unsigned U into signed U [-128,127]
-  //   V - 128  : Turns unsigned V into signed V [-128,127]
-  float yuv_adjust[3] = { -0.0625f, -0.5f, -0.5f, };
-  GLC(Context(),
-      Context()->uniform3fv(
-          program->fragment_shader().yuv_adj_location(), 1, yuv_adjust));
-
-  SetShaderOpacity(quad->opacity(),
-                   program->fragment_shader().alpha_location());
-  DrawQuadGeometry(frame,
-                   quad->quadTransform(),
-                   quad->rect,
-                   program->vertex_shader().matrix_location());
+  SetShaderOpacity(quad->opacity(), alpha_location);
+  DrawQuadGeometry(frame, quad->quadTransform(), quad->rect, matrix_location);
 
   // Reset active texture back to texture 0.
   GLC(Context(), Context()->activeTexture(GL_TEXTURE0));
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
@@ skipping 931 matching lines @@
 const GLRenderer::VideoYUVProgram* GLRenderer::GetVideoYUVProgram() {
   if (!video_yuv_program_)
     video_yuv_program_ = make_scoped_ptr(new VideoYUVProgram(context_));
   if (!video_yuv_program_->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
     video_yuv_program_->Initialize(context_, is_using_bind_uniform_);
   }
   return video_yuv_program_.get();
 }
 
+const GLRenderer::VideoYUVAProgram* GLRenderer::GetVideoYUVAProgram() {
+  if (!video_yuva_program_)
+    video_yuva_program_ = make_scoped_ptr(new VideoYUVAProgram(context_));
+  if (!video_yuva_program_->initialized()) {
+    TRACE_EVENT0("cc", "GLRenderer::videoYUVAProgram::initialize");
+    video_yuva_program_->Initialize(context_, is_using_bind_uniform_);
+  }
+  return video_yuva_program_.get();
+}
+
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram() {
   if (!Capabilities().using_egl_image)
     return NULL;
   if (!video_stream_texture_program_)
     video_stream_texture_program_ =
         make_scoped_ptr(new VideoStreamTextureProgram(context_));
   if (!video_stream_texture_program_->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::streamTextureProgram::initialize");
     video_stream_texture_program_->Initialize(context_, is_using_bind_uniform_);
@@ skipping 32 matching lines @@
 
   if (texture_program_)
     texture_program_->Cleanup(context_);
   if (texture_program_flip_)
     texture_program_flip_->Cleanup(context_);
   if (texture_io_surface_program_)
     texture_io_surface_program_->Cleanup(context_);
 
   if (video_yuv_program_)
     video_yuv_program_->Cleanup(context_);
+  if (video_yuva_program_)
+    video_yuva_program_->Cleanup(context_);
   if (video_stream_texture_program_)
     video_stream_texture_program_->Cleanup(context_);
 
   if (debug_border_program_)
     debug_border_program_->Cleanup(context_);
   if (solid_color_program_)
     solid_color_program_->Cleanup(context_);
   if (solid_color_program_aa_)
     solid_color_program_aa_->Cleanup(context_);
 
   if (offscreen_framebuffer_id_)
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   if (on_demand_tile_raster_resource_id_)
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc