color: Add support for shader generation

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 45 matching lines @@
 #include "skia/ext/texture_handle.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "third_party/skia/include/gpu/gl/GrGLTypes.h"
 #include "ui/gfx/color_space.h"
+#include "ui/gfx/color_transform.h"
 #include "ui/gfx/geometry/quad_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 namespace {
 
 Float4 UVTransform(const TextureDrawQuad* quad) {
@@ skipping 1946 matching lines @@
       tile_quad.p3().x(), tile_quad.p3().y(),
   };
   gl_->Uniform2fv(current_program_->quad_location(), 4, gl_quad);
 
   SetShaderMatrix(current_frame()->projection_matrix *
                   quad->shared_quad_state->quad_to_target_transform);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
-// TODO(ccameron): This has been replicated in ui/gfx/color_transform.cc. Delete
-// one of the instances.
-void ComputeYUVToRGBMatrices(const gfx::ColorSpace& src_color_space,
-                             const gfx::ColorSpace& dst_color_space,
-                             uint32_t bits_per_channel,
-                             float resource_multiplier,
-                             float resource_offset,
-                             float* yuv_to_rgb_matrix) {
-  // Compute the matrix |full_transform| which converts input YUV values to RGB
-  // values.
-  SkMatrix44 full_transform;
-
-  // Start with the resource adjust.
-  full_transform.setScale(resource_multiplier, resource_multiplier,
-                          resource_multiplier);
-  full_transform.preTranslate(-resource_offset, -resource_offset,
-                              -resource_offset);
-
-  // If we're using a LUT for conversion, we only need the resource adjust,
-  // so just return this matrix.
-  if (dst_color_space.IsValid()) {
-    full_transform.asColMajorf(yuv_to_rgb_matrix);
-    return;
-  }
-
-  // Then apply the range adjust.
-  {
-    SkMatrix44 range_adjust;
-    src_color_space.GetRangeAdjustMatrix(&range_adjust);
-    full_transform.postConcat(range_adjust);
-  }
-
-  // Then apply the YUV to RGB full_transform.
-  {
-    SkMatrix44 rgb_to_yuv;
-    src_color_space.GetTransferMatrix(&rgb_to_yuv);
-    SkMatrix44 yuv_to_rgb;
-    rgb_to_yuv.invert(&yuv_to_rgb);
-    full_transform.postConcat(yuv_to_rgb);
-  }
-
-  full_transform.asColMajorf(yuv_to_rgb_matrix);
-}
-
 void GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
   YUVAlphaTextureMode alpha_texture_mode = quad->a_plane_resource_id()
                                                ? YUV_HAS_ALPHA_TEXTURE
                                                : YUV_NO_ALPHA_TEXTURE;
@@ skipping 112 matching lines @@
   gl_->Uniform1i(current_program_->y_texture_location(), 1);
   if (uv_texture_mode == UV_TEXTURE_MODE_UV) {
     gl_->Uniform1i(current_program_->uv_texture_location(), 2);
   } else {
     gl_->Uniform1i(current_program_->u_texture_location(), 2);
     gl_->Uniform1i(current_program_->v_texture_location(), 3);
   }
   if (alpha_texture_mode == YUV_HAS_ALPHA_TEXTURE)
     gl_->Uniform1i(current_program_->a_texture_location(), 4);
 
-  float yuv_to_rgb_matrix[16] = {0};
-  ComputeYUVToRGBMatrices(src_color_space, dst_color_space,
-                          quad->bits_per_channel, quad->resource_multiplier,
-                          quad->resource_offset, yuv_to_rgb_matrix);
-  gl_->UniformMatrix4fv(current_program_->yuv_and_resource_matrix_location(), 1,
-                        0, yuv_to_rgb_matrix);
+  gl_->Uniform1f(current_program_->resource_multiplier_location(),
+                 quad->resource_multiplier);
+  gl_->Uniform1f(current_program_->resource_offset_location(),
+                 quad->resource_offset);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   auto tile_rect = gfx::RectF(quad->rect);
 
   SetShaderOpacity(quad);
   if (!clip_region) {
     DrawQuadGeometry(current_frame()->projection_matrix,
@@ skipping 801 matching lines @@
   gfx::ColorSpace dst_color_space;
   if (settings_->enable_color_correct_rendering)
     dst_color_space = current_frame()->current_render_pass->color_space;
   SetUseProgram(program_key, src_color_space, dst_color_space);
 }
 
 void GLRenderer::SetUseProgram(const ProgramKey& program_key_no_color,
                                const gfx::ColorSpace& src_color_space,
                                const gfx::ColorSpace& dst_color_space) {
   ProgramKey program_key = program_key_no_color;
-  if (src_color_space.IsValid() && dst_color_space.IsValid())
-    program_key.SetColorConversionMode(COLOR_CONVERSION_MODE_LUT);
+  const gfx::ColorTransform* color_transform =
+      GetColorTransform(src_color_space, dst_color_space);
+  program_key.SetColorTransform(color_transform);
 
   // Create and set the program if needed.
   std::unique_ptr<Program>& program = program_cache_[program_key];
   if (!program) {
     program.reset(new Program);
     program->Initialize(output_surface_->context_provider(), program_key);
   }
   DCHECK(program);
   if (current_program_ != program.get()) {
     current_program_ = program.get();
@@ skipping 10 matching lines @@
   if (current_program_->viewport_location() != -1) {
     float viewport[4] = {
         static_cast<float>(current_window_space_viewport_.x()),
         static_cast<float>(current_window_space_viewport_.y()),
         static_cast<float>(current_window_space_viewport_.width()),
         static_cast<float>(current_window_space_viewport_.height()),
     };
     gl_->Uniform4fv(current_program_->viewport_location(), 1, viewport);
   }
   if (current_program_->lut_texture_location() != -1) {
-    ColorLUTCache::LUT lut =
-        color_lut_cache_.GetLUT(src_color_space, dst_color_space);
+    ColorLUTCache::LUT lut = color_lut_cache_.GetLUT(color_transform);
     gl_->ActiveTexture(GL_TEXTURE5);
     gl_->BindTexture(GL_TEXTURE_2D, lut.texture);
     gl_->Uniform1i(current_program_->lut_texture_location(), 5);
     gl_->Uniform1f(current_program_->lut_size_location(), lut.size);
     gl_->ActiveTexture(GL_TEXTURE0);
   }
 }
 
 const Program* GLRenderer::GetProgramIfInitialized(
     const ProgramKey& desc) const {
   const auto found = program_cache_.find(desc);
   if (found == program_cache_.end())
     return nullptr;
   return found->second.get();
 }
 
+const gfx::ColorTransform* GLRenderer::GetColorTransform(
+    const gfx::ColorSpace& src,
+    const gfx::ColorSpace& dst) {
+  std::unique_ptr<gfx::ColorTransform>& transform =
+      color_transform_cache_[dst][src];
+  if (!transform) {
+    transform = gfx::ColorTransform::NewColorTransform(
+        src, dst, gfx::ColorTransform::Intent::INTENT_PERCEPTUAL);
+  }
+  return transform.get();
+}
+
 void GLRenderer::CleanupSharedObjects() {
   shared_geometry_ = nullptr;
 
   for (auto& iter : program_cache_)
     iter.second->Cleanup(gl_);
   program_cache_.clear();
+  color_transform_cache_.clear();
 
   if (offscreen_framebuffer_id_)
     gl_->DeleteFramebuffers(1, &offscreen_framebuffer_id_);
 
   if (offscreen_stencil_renderbuffer_id_)
     gl_->DeleteRenderbuffers(1, &offscreen_stencil_renderbuffer_id_);
 
   ReleaseRenderPassTextures();
 }
 
@@ skipping 429 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc