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 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 227 matching lines @@
       break;
     case DrawQuad::TEXTURE_CONTENT:
       EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::YUVA_VIDEO_CONTENT:
+      DrawYUVAVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
+      break;
   }
 }
 
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
                                       const CheckerboardDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
@@ skipping 883 matching lines @@
       Context()->uniform2f(program->vertex_shader().tex_scale_location(),
                            quad->tex_scale.width(),
                            quad->tex_scale.height()));
   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));
 
-  // 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));
+  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());
+
+  // Reset active texture back to texture 0.
+  GLC(Context(), Context()->activeTexture(GL_TEXTURE0));
+}
+
+void GLRenderer::DrawYUVAVideoQuad(const DrawingFrame* frame,

[danakj, 2013/03/28 20:59:24]

Can you merge this function with DrawYUVVideoQuad? Would you need a separate
enum value for it then? How about just leaving the resource id == 0 in the alpha
channel if there's no "A" present in the YUV.

[vignesh, 2013/04/02 20:56:15]

Which enum value are you referring to ? Also, what happens to VideoYUVAProgram
typedef if i need to merge this function into DrawYUVVideoQuad ?

[danakj, 2013/04/03 00:41:12]

Sorry, I am referring to the DrawQuad::Material enum.

You've done a great job eliminating the extra quad type, but I wonder if we can
go further and eliminate the extra enum value as well.

It is fine to have a single "DrawFooQuad" method use different programs
depending on the content of the quad. See the DrawRenderPassQuad() for an
example, it chooses between something like 16 programs depending on the content
of the quad. You could choose to use a program with alpha depending if there was
an alpha resource present in the YUV quad.

[vignesh, 2013/04/04 00:37:33]

I have eliminated the enum type and included both YUV and YUVA in a single
DrawYUVVideoQuad function depending on presence of Alpha channel. Please see if
this implementation is okay. Thanks :)

On 2013/04/03 00:41:12, danakj wrote:

+                                   const YUVVideoDrawQuad* quad)
+{
+  SetBlendEnabled(quad->ShouldDrawWithBlending());
+
+  const VideoYUVAProgram* program = GetVideoYUVAProgram();
+  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;
+
+  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);
+  ResourceProvider::ScopedSamplerGL A_plane_lock(
+      resource_provider_, a_plane.resource_id, GL_TEXTURE_2D, GL_LINEAR);
+
+  SetUseProgram(program->program());
+
+  GLC(Context(),
+      Context()->uniform2f(program->vertex_shader().tex_scale_location(),
+                           quad->tex_scale.width(),
+                           quad->tex_scale.height()));
+  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));
+  GLC(Context(),
+      Context()->uniform1i(program->fragment_shader().a_texture_location(), 4));
+
   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());
@@ skipping 941 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