color: Add support for shader generation

cc/output/color_lut_cache.cc

 // Copyright 2016 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/color_lut_cache.h"
 
 #include <stdint.h>
 #include <cmath>
 #include <vector>
 
@@ skipping 33 matching lines @@
 
 void FloatToLUT(float* f, unsigned char* out, size_t num) {
   for (size_t i = 0; i < num; i++) {
     out[i] = std::min<int>(255, std::max<int>(0, floorf(f[i] * 255.0f + 0.5f)));
   }
 }
 
 }  // namespace
 
 template <typename T>
-unsigned int ColorLUTCache::MakeLUT(const gfx::ColorSpace& from,
-                                    gfx::ColorSpace to,
+unsigned int ColorLUTCache::MakeLUT(const gfx::ColorTransform* transform,
                                     int lut_samples) {
-  if (to == gfx::ColorSpace()) {
-    to = gfx::ColorSpace::CreateSRGB();
-  }
-  std::unique_ptr<gfx::ColorTransform> transform(
-      gfx::ColorTransform::NewColorTransform(
-          from, to, gfx::ColorTransform::Intent::INTENT_PERCEPTUAL));
-
   int lut_entries = lut_samples * lut_samples * lut_samples;
   float inverse = 1.0f / (lut_samples - 1);
   std::vector<T> lut(lut_entries * 4);
   std::vector<gfx::ColorTransform::TriStim> samples(lut_samples);
   T* lutp = lut.data();
   float one = 1.0f;
   T alpha;
   FloatToLUT(&one, &alpha, 1);
   for (int v = 0; v < lut_samples; v++) {
     for (int u = 0; u < lut_samples; u++) {
@@ skipping 22 matching lines @@
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   gl_->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, lut_samples,
                   lut_samples * lut_samples, 0, GL_RGBA,
                   sizeof(T) == 1 ? GL_UNSIGNED_BYTE : GL_HALF_FLOAT_OES,
                   lut.data());
   return lut_texture;
 }
 
-ColorLUTCache::LUT ColorLUTCache::GetLUT(const gfx::ColorSpace& from,
-                                         const gfx::ColorSpace& to) {
-  CacheKey key(from, to);
-  auto iter = lut_cache_.Get(key);
+ColorLUTCache::LUT ColorLUTCache::GetLUT(const gfx::ColorTransform* transform) {
+  auto iter = lut_cache_.Get(transform);
   if (iter != lut_cache_.end()) {
     iter->second.last_used_frame = current_frame_;
     return iter->second.lut;
   }
 
   LUT lut;
   // If input is HDR, and the output is scRGB, we're going to need
   // to produce values outside of 0-1, so we'll need to make a half-float
   // LUT. Also, we'll need to build a larger lut to maintain accuracy.
   // All LUT sizes should be odd a some transforms hav a knee at 0.5.
-  if (to == gfx::ColorSpace::CreateSCRGBLinear() && from.IsHDR() &&
-      texture_half_float_linear_) {
+  if (transform->GetDstColorSpace() == gfx::ColorSpace::CreateSCRGBLinear() &&
+      transform->GetSrcColorSpace().IsHDR() && texture_half_float_linear_) {
     lut.size = 37;
-    lut.texture = MakeLUT<uint16_t>(from, to, lut.size);
+    lut.texture = MakeLUT<uint16_t>(transform, lut.size);
   } else {
     lut.size = 17;
-    lut.texture = MakeLUT<unsigned char>(from, to, lut.size);
+    lut.texture = MakeLUT<unsigned char>(transform, lut.size);
   }
-  lut_cache_.Put(key, CacheVal(lut, current_frame_));
+  lut_cache_.Put(transform, CacheVal(lut, current_frame_));
   return lut;
 }
 
 void ColorLUTCache::Swap() {
   current_frame_++;
   while (!lut_cache_.empty() &&
          current_frame_ - lut_cache_.rbegin()->second.last_used_frame >
              kMaxFramesUnused) {
     gl_->DeleteTextures(1, &lut_cache_.rbegin()->second.lut.texture);
     lut_cache_.ShrinkToSize(lut_cache_.size() - 1);
   }
 }