make LUT calculation 3x faster

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 @@
   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<unsigned char> lut(lut_entries * 4);
-  std::vector<gfx::ColorTransform::TriStim> samples(lut_samples * 3);
+  std::vector<gfx::ColorTransform::TriStim> samples(lut_samples);
   unsigned char* lutp = lut.data();
   for (int y = 0; y < lut_samples; y++) {
     for (int v = 0; v < lut_samples; v++) {
       for (int u = 0; u < lut_samples; u++) {
         samples[u].set_x(y * inverse);

[danakj, 2016/09/29 20:09:08]

Wait.. this is setting samples[0] once for each value of u, once or each value
of v, once for each value of u. But only keeping the value for
y=v=lut_samples-1.

This seems like you can make this exponentially faster?

[hubbe, 2016/09/29 20:31:52]

It's not *keeping* any of the values.
We iterate over all y,u,v, values, but batch-transform one "row" of values and
save the output into lutp.

I could calculate y * inverse and u * inverse in an outer loop, but I assume
that the compiler is smart enough to do that, and even if it is not, it wouldn't
save that much time I think.

[danakj, 2016/09/29 20:38:07]

Ah, the transform() happens for each y and v also, I see.

         samples[u].set_y(u * inverse);
         samples[u].set_z(v * inverse);
       }
       transform->transform(samples.data(), samples.size());
       for (int u = 0; u < lut_samples; u++) {
         *(lutp++) = FloatToLUT(samples[u].x());
         *(lutp++) = FloatToLUT(samples[u].y());
         *(lutp++) = FloatToLUT(samples[u].z());
         *(lutp++) = 255;  // alpha
       }
@@ skipping 30 matching lines @@
 
 void ColorLUTCache::Swap() {
   current_frame_++;
   while (!lut_cache_.empty() &&
          current_frame_ - lut_cache_.rbegin()->second.first >
              kMaxFramesUnused) {
     gl_->DeleteTextures(1, &lut_cache_.rbegin()->second.first);
     lut_cache_.ShrinkToSize(lut_cache_.size() - 1);
   }
 }