Video Color Managament

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>
 #include <limits>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
+#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "cc/base/container_util.h"
@@ skipping 15 matching lines @@
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
+#include "media/base/media_switches.h"
 #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/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 320 matching lines @@
       is_backbuffer_discarded_(false),
       is_scissor_enabled_(false),
       scissor_rect_needs_reset_(true),
       stencil_shadow_(false),
       blend_shadow_(false),
       highp_threshold_min_(highp_threshold_min),
       highp_threshold_cache_(0),
       use_sync_query_(false),
       gl_composited_texture_quad_border_(
           settings->gl_composited_texture_quad_border),
-      bound_geometry_(NO_BINDING) {
+      bound_geometry_(NO_BINDING),
+      color_lut_cache_(gl_) {
   DCHECK(gl_);
   DCHECK(context_support_);
 
   const auto& context_caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   capabilities_.using_partial_swap =
       settings_->partial_swap_enabled && context_caps.post_sub_buffer;
   capabilities_.allow_empty_swap =
       capabilities_.using_partial_swap || context_caps.commit_overlay_planes;
@@ skipping 1792 matching lines @@
                                   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());
 
   bool use_alpha_plane = quad->a_plane_resource_id() != 0;
   bool use_nv12 = quad->v_plane_resource_id() == quad->u_plane_resource_id();
-
+  bool use_color_lut =
+      base::FeatureList::IsEnabled(media::kVideoColorManagement);
   DCHECK(!(use_nv12 && use_alpha_plane));
 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_, quad->y_plane_resource_id(), GL_TEXTURE1, GL_LINEAR);
   ResourceProvider::ScopedSamplerGL u_plane_lock(
       resource_provider_, quad->u_plane_resource_id(), GL_TEXTURE2, GL_LINEAR);
   DCHECK_EQ(y_plane_lock.target(), u_plane_lock.target());
   // TODO(jbauman): Use base::Optional when available.
   std::unique_ptr<ResourceProvider::ScopedSamplerGL> v_plane_lock;
   if (!use_nv12) {
@@ skipping 18 matching lines @@
   int ya_tex_offset_location = -1;
   int uv_tex_scale_location = -1;
   int uv_tex_offset_location = -1;
   int ya_clamp_rect_location = -1;
   int uv_clamp_rect_location = -1;
   int y_texture_location = -1;
   int u_texture_location = -1;
   int v_texture_location = -1;
   int uv_texture_location = -1;
   int a_texture_location = -1;
+  int lut_texture_location = -1;
   int yuv_matrix_location = -1;
   int yuv_adj_location = -1;
   int alpha_location = -1;
+  int resource_multiplier_location = -1;
+  int resource_offset_location = -1;
   const VideoYUVProgram* program = GetVideoYUVProgram(
-      tex_coord_precision, sampler, use_alpha_plane, use_nv12);
+      tex_coord_precision, sampler, use_alpha_plane, use_nv12, use_color_lut);
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
   matrix_location = program->vertex_shader().matrix_location();
   ya_tex_scale_location = program->vertex_shader().ya_tex_scale_location();
   ya_tex_offset_location = program->vertex_shader().ya_tex_offset_location();
   uv_tex_scale_location = program->vertex_shader().uv_tex_scale_location();
   uv_tex_offset_location = program->vertex_shader().uv_tex_offset_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();
   uv_texture_location = program->fragment_shader().uv_texture_location();
   a_texture_location = program->fragment_shader().a_texture_location();
+  lut_texture_location = program->fragment_shader().lut_texture_location();
   yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
   yuv_adj_location = program->fragment_shader().yuv_adj_location();
   ya_clamp_rect_location = program->fragment_shader().ya_clamp_rect_location();
   uv_clamp_rect_location = program->fragment_shader().uv_clamp_rect_location();
   alpha_location = program->fragment_shader().alpha_location();
+  resource_multiplier_location =
+      program->fragment_shader().resource_multiplier_location();
+  resource_offset_location =
+      program->fragment_shader().resource_offset_location();
 
   gfx::SizeF ya_tex_scale(1.0f, 1.0f);
   gfx::SizeF uv_tex_scale(1.0f, 1.0f);
   if (sampler != SAMPLER_TYPE_2D_RECT) {
     DCHECK(!quad->ya_tex_size.IsEmpty());
     DCHECK(!quad->uv_tex_size.IsEmpty());
     ya_tex_scale = gfx::SizeF(1.0f / quad->ya_tex_size.width(),
                               1.0f / quad->ya_tex_size.height());
     uv_tex_scale = gfx::SizeF(1.0f / quad->uv_tex_size.width(),
                               1.0f / quad->uv_tex_size.height());
@@ skipping 104 matching lines @@
 
   for (int i = 0; i < 9; ++i)
     yuv_to_rgb_multiplied[i] = yuv_to_rgb[i] * quad->resource_multiplier;
 
   for (int i = 0; i < 3; ++i) {
     yuv_adjust_with_offset[i] =
         yuv_adjust[i] * adjustment_multiplier / quad->resource_multiplier -
         quad->resource_offset;
   }
 
+  if (lut_texture_location != -1) {
+    unsigned int lut_texture = color_lut_cache_.GetLUT(
+        quad->video_color_space, output_surface_->color_space(), 32);
+    gl_->ActiveTexture(GL_TEXTURE5);
+    gl_->BindTexture(GL_TEXTURE_2D, lut_texture);
+    gl_->Uniform1i(lut_texture_location, 5);
+    gl_->ActiveTexture(GL_TEXTURE0);
+  }
+
+  if (resource_multiplier_location != -1) {
+    gl_->Uniform1f(resource_multiplier_location, quad->resource_multiplier);
+  }
+
+  if (resource_offset_location != -1) {
+    gl_->Uniform1f(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);
-  gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb_multiplied);
-  gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust_with_offset);
+  if (yuv_matrix_location != -1) {
+    gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb_multiplied);
+  }
+
+  if (yuv_adj_location) {
+    gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust_with_offset);
+  }
 
   SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
   if (!clip_region) {
     DrawQuadGeometry(frame->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      tile_rect, matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
@@ skipping 529 matching lines @@
 }
 
 void GLRenderer::DidReceiveTextureInUseResponses(
     const gpu::TextureInUseResponses& responses) {
   DCHECK(settings_->release_overlay_resources_after_gpu_query);
   for (const gpu::TextureInUseResponse& response : responses) {
     if (!response.in_use) {
       swapped_and_acked_overlay_resources_.erase(response.texture);
     }
   }
+  color_lut_cache_.Swap();
 }
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible()) {
     TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     DiscardBackbuffer();
     output_surface_->context_provider()->DeleteCachedResources();
     gl_->Flush();
   }
@@ skipping 671 matching lines @@
     program->Initialize(output_surface_->context_provider(), precision,
                         sampler);
   }
   return program;
 }
 
 const GLRenderer::VideoYUVProgram* GLRenderer::GetVideoYUVProgram(
     TexCoordPrecision precision,
     SamplerType sampler,
     bool use_alpha_plane,
-    bool use_nv12) {
+    bool use_nv12,
+    bool use_color_lut) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
   DCHECK_GE(sampler, 0);
   DCHECK_LE(sampler, LAST_SAMPLER_TYPE);
   VideoYUVProgram* program =
-      &video_yuv_program_[precision][sampler][use_alpha_plane][use_nv12];
+      &video_yuv_program_[precision][sampler][use_alpha_plane][use_nv12]
+                         [use_color_lut];
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::videoYUVProgram::initialize");
-    program->mutable_fragment_shader()->SetFeatures(use_alpha_plane, use_nv12);
+    program->mutable_fragment_shader()->SetFeatures(use_alpha_plane, use_nv12,
+                                                    use_color_lut);
     program->Initialize(output_surface_->context_provider(), precision,
                         sampler);
   }
   return program;
 }
 
 const GLRenderer::VideoStreamTextureProgram*
 GLRenderer::GetVideoStreamTextureProgram(TexCoordPrecision precision) {
   DCHECK_GE(precision, 0);
   DCHECK_LE(precision, LAST_TEX_COORD_PRECISION);
@@ skipping 23 matching lines @@
         for (int l = 0; l <= LAST_MASK_VALUE; ++l) {
           render_pass_mask_program_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_program_aa_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_color_matrix_program_aa_[i][j][k][l].Cleanup(gl_);
           render_pass_mask_color_matrix_program_[i][j][k][l].Cleanup(gl_);
         }
       }
 
       for (int k = 0; k < 2; k++) {
         for (int l = 0; l < 2; l++) {
-          video_yuv_program_[i][j][k][l].Cleanup(gl_);
+          for (int m = 0; m < 2; m++) {
+            video_yuv_program_[i][j][k][l][m].Cleanup(gl_);
+          }
         }
       }
     }
     for (int j = 0; j <= LAST_BLEND_MODE; j++) {
       render_pass_program_[i][j].Cleanup(gl_);
       render_pass_program_aa_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_[i][j].Cleanup(gl_);
       render_pass_color_matrix_program_aa_[i][j].Cleanup(gl_);
     }
 
@@ skipping 139 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc