Store SkColorSpaceXform gamma LUTs in a malloced field

src/core/SkColorSpaceXform.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorPriv.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 238 matching lines @@
     nullptr,
     nullptr,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
     &build_table_linear_to_gamma,
 };
 
 // Build tables to transform src gamma to linear.
 template <typename T>
 static void build_gamma_tables(const T* outGammaTables[3], T* gammaTableStorage, int gammaTableSize,
-                               const sk_sp<SkColorSpace>& space, const GammaFns<T>& fns) {
+                               const sk_sp<SkColorSpace>& space, const GammaFns<T>& fns,
+                               bool gammasAreMatching) {
     switch (as_CSB(space)->gammaNamed()) {
         case kSRGB_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRGBTable;
             break;
         case k2Dot2Curve_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Dot2Table;
             break;
         case kLinear_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = nullptr;
             break;
         default: {
             const SkGammas* gammas = as_CSB(space)->gammas();
             SkASSERT(gammas);
 
-            for (int i = 0; i < 3; i++) {
-                if (i > 0) {
-                    // Check if this curve matches the first curve.  In this case, we can
-                    // share the same table pointer.  This should almost always be true.
-                    // I've never seen a profile where all three gamma curves didn't match.
-                    // But it is possible that they won't.
-                    if (gammas->type(0) == gammas->type(i) && gammas->data(0) == gammas->data(i)) {
-                        outGammaTables[i] = outGammaTables[0];
-                        continue;
-                    }
-                }
-
+            auto build_table = [=](int i) {
                 if (gammas->isNamed(i)) {
                     switch (gammas->data(i).fNamed) {
                         case kSRGB_SkGammaNamed:
                             (*fns.fBuildFromParam)(&gammaTableStorage[i * gammaTableSize], 2.4f,
                                                    (1.0f / 1.055f), (0.055f / 1.055f), 0.0f,
                                                    0.04045f, (1.0f / 12.92f), 0.0f);
                             outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
                             break;
                         case k2Dot2Curve_SkGammaNamed:
                             (*fns.fBuildFromValue)(&gammaTableStorage[i * gammaTableSize], 2.2f);
@@ skipping 16 matching lines @@
                                            gammas->data(i).fTable.fSize);
                     outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
                 } else {
                     SkASSERT(gammas->isParametric(i));
                     const SkGammas::Params& params = gammas->params(i);
                     (*fns.fBuildFromParam)(&gammaTableStorage[i * gammaTableSize], params.fG,
                                            params.fA, params.fB, params.fC, params.fD, params.fE,
                                            params.fF);
                     outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
                 }
+            };
+
+            if (gammasAreMatching) {
+                build_table(0);
+                outGammaTables[1] = outGammaTables[0];
+                outGammaTables[2] = outGammaTables[0];
+            } else {
+                build_table(0);
+                build_table(1);
+                build_table(2);
             }
+
+            break;
         }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 static inline bool is_almost_identity(const SkMatrix44& srcToDst) {
     for (int i = 0; i < 4; i++) {
         for (int j = 0; j < 4; j++) {
             float expected = (i == j) ? 1.0f : 0.0f;
@@ skipping 819 matching lines @@
             break;
     }
 
     do_color_xform<kAlphaType, kCSM>
             (dst, src, len, srcTables, matrix, dstTables, load, load_1, store, store_1,
              sizeOfDstPixel);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
+static inline int num_tables(SkColorSpace* space) {
+    switch (as_CSB(space)->gammaNamed()) {
+        case kSRGB_SkGammaNamed:
+        case k2Dot2Curve_SkGammaNamed:
+        case kLinear_SkGammaNamed:
+            return 0;
+        default: {
+            const SkGammas* gammas = as_CSB(space)->gammas();
+            SkASSERT(gammas);
+
+            bool gammasAreMatching = (gammas->type(0) == gammas->type(1)) &&
+                                     (gammas->data(0) == gammas->data(1)) &&
+                                     (gammas->type(0) == gammas->type(2)) &&
+                                     (gammas->data(0) == gammas->data(2));
+
+            // It's likely that each component will have the same gamma.  In this case,
+            // we only need to build one table.
+            return gammasAreMatching ? 1 : 3;
+        }
+    }
+}
+
 template <SrcGamma kSrc, DstGamma kDst, ColorSpaceMatch kCSM>
 SkColorSpaceXform_Base<kSrc, kDst, kCSM>
 ::SkColorSpaceXform_Base(const sk_sp<SkColorSpace>& srcSpace, const SkMatrix44& srcToDst,
                          const sk_sp<SkColorSpace>& dstSpace)
     : fColorLUT(sk_ref_sp((SkColorLookUpTable*) as_CSB(srcSpace)->colorLUT()))
 {
     srcToDst.asColMajorf(fSrcToDst);
-    build_gamma_tables(fSrcGammaTables, fSrcGammaTableStorage, 256, srcSpace, kToLinear);
-    build_gamma_tables(fDstGammaTables, fDstGammaTableStorage, kDstGammaTableSize, dstSpace,
-                       kFromLinear);
+
+    const int numSrcTables = num_tables(srcSpace.get());
+    const int numDstTables = num_tables(dstSpace.get());
+    const size_t srcTableBytes = numSrcTables * 256 * sizeof(float);
+    const size_t dstTableBytes = numDstTables * kDstGammaTableSize * sizeof(uint8_t);
+    fStorage.reset(srcTableBytes + dstTableBytes);
+    float* srcStorage = (float*) fStorage.get();
+    uint8_t* dstStorage = SkTAddOffset<uint8_t>(fStorage.get(), srcTableBytes);
+
+    const bool srcGammasAreMatching = (1 >= numSrcTables);
+    const bool dstGammasAreMatching = (1 >= numDstTables);
+    build_gamma_tables(fSrcGammaTables, srcStorage, 256, srcSpace, kToLinear, srcGammasAreMatching);
+    build_gamma_tables(fDstGammaTables, dstStorage, kDstGammaTableSize, dstSpace, kFromLinear,
+                       dstGammasAreMatching);
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 template <SrcFormat kSrc, DstFormat kDst, ColorSpaceMatch kCSM, SwapRB kSwap>
 static inline void apply_set_alpha(void* dst, const uint32_t* src, int len, SkAlphaType alphaType,
                                    const float* const srcTables[3], const float matrix[16],
                                    const uint8_t* const dstTables[3]) {
     switch (alphaType) {
         case kOpaque_SkAlphaType:
             return color_xform_RGBA<kSrc, kDst, kOpaque_SkAlphaType, kCSM, kSwap>
                     (dst, src, len, srcTables, matrix, dstTables);
         case kPremul_SkAlphaType:
             return color_xform_RGBA<kSrc, kDst, kPremul_SkAlphaType, kCSM, kSwap>
@@ skipping 100 matching lines @@
                 default:
                     SkASSERT(false);
                     return;
             }
         default:
             SkASSERT(false);
             return;
     }
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
 std::unique_ptr<SkColorSpaceXform> SlowIdentityXform(const sk_sp<SkColorSpace>& space) {
         return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
                 <kTable_SrcGamma, kTable_DstGamma, kNone_ColorSpaceMatch>
                 (space, SkMatrix::I(), space));
 }