Delete SkColorSpace::gammaNamed() from public API

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 243 matching lines @@
     if (v >= 254.5f) {
         return 255;
     } else if (v >= 0.5f) {
         return (uint8_t) (v + 0.5f);
     } else {
         return 0;
     }
 }
 
 static const int kDstGammaTableSize =
-        SkColorSpaceXform_Base<SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+        SkColorSpaceXform_Base<kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
         ::kDstGammaTableSize;
 
 static void build_table_linear_to_gamma(uint8_t* outTable, float exponent) {
     float toGammaExp = 1.0f / exponent;
 
     for (int i = 0; i < kDstGammaTableSize; i++) {
         float x = ((float) i) * (1.0f / ((float) (kDstGammaTableSize - 1)));
         outTable[i] = clamp_normalized_float_to_byte(powf(x, toGammaExp));
     }
 }
@@ skipping 98 matching lines @@
     linear_to_2dot2_table,
     &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) {
-    switch (space->gammaNamed()) {
-        case SkColorSpace::kSRGB_GammaNamed:
+    switch (as_CSB(space)->gammaNamed()) {
+        case kSRGB_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.fSRGBTable;
             break;
-        case SkColorSpace::k2Dot2Curve_GammaNamed:
+        case k2Dot2Curve_SkGammaNamed:
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = fns.f2Dot2Table;
             break;
-        case SkColorSpace::kLinear_GammaNamed:
+        case kLinear_SkGammaNamed:
             (*fns.fBuildFromValue)(gammaTableStorage, 1.0f);
             outGammaTables[0] = outGammaTables[1] = outGammaTables[2] = gammaTableStorage;
             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;
                     }
                 }
 
                 if (gammas->isNamed(i)) {
                     switch (gammas->data(i).fNamed) {
-                        case SkColorSpace::kSRGB_GammaNamed:
+                        case kSRGB_SkGammaNamed:
                             outGammaTables[i] = fns.fSRGBTable;
                             break;
-                        case SkColorSpace::k2Dot2Curve_GammaNamed:
+                        case k2Dot2Curve_SkGammaNamed:
                             outGammaTables[i] = fns.f2Dot2Table;
                             break;
-                        case SkColorSpace::kLinear_GammaNamed:
+                        case kLinear_SkGammaNamed:
                             (*fns.fBuildFromValue)(&gammaTableStorage[i * gammaTableSize], 1.0f);
                             outGammaTables[i] = &gammaTableStorage[i * gammaTableSize];
                             break;
                         default:
                             SkASSERT(false);
                             break;
                     }
                 } else if (gammas->isValue(i)) {
                     (*fns.fBuildFromValue)(&gammaTableStorage[i * gammaTableSize],
                                            gammas->data(i).fValue);
@@ skipping 55 matching lines @@
         csm = kFull_ColorSpaceMatch;
     } else if (!compute_gamut_xform(&srcToDst, srcSpace->xyz(), dstSpace->xyz())) {
         return nullptr;
     } else if (is_almost_identity(srcToDst)) {
         srcToDst.setIdentity();
         csm = kGamut_ColorSpaceMatch;
     }
 
     switch (csm) {
         case kNone_ColorSpaceMatch:
-            switch (dstSpace->gammaNamed()) {
-                case SkColorSpace::kSRGB_GammaNamed:
+            switch (as_CSB(dstSpace)->gammaNamed()) {
+                case kSRGB_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kSRGB_GammaNamed, kNone_ColorSpaceMatch>
+                            <kSRGB_SkGammaNamed, kNone_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
-                case SkColorSpace::k2Dot2Curve_GammaNamed:
+                case k2Dot2Curve_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::k2Dot2Curve_GammaNamed, kNone_ColorSpaceMatch>
+                            <k2Dot2Curve_SkGammaNamed, kNone_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
                 default:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+                            <kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
             }
         case kGamut_ColorSpaceMatch:
-            switch (dstSpace->gammaNamed()) {
-                case SkColorSpace::kSRGB_GammaNamed:
+            switch (as_CSB(dstSpace)->gammaNamed()) {
+                case kSRGB_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kSRGB_GammaNamed, kGamut_ColorSpaceMatch>
+                            <kSRGB_SkGammaNamed, kGamut_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
-                case SkColorSpace::k2Dot2Curve_GammaNamed:
+                case k2Dot2Curve_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::k2Dot2Curve_GammaNamed, kGamut_ColorSpaceMatch>
+                            <k2Dot2Curve_SkGammaNamed, kGamut_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
                 default:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kNonStandard_GammaNamed, kGamut_ColorSpaceMatch>
+                            <kNonStandard_SkGammaNamed, kGamut_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
             }
         case kFull_ColorSpaceMatch:
-            switch (dstSpace->gammaNamed()) {
-                case SkColorSpace::kSRGB_GammaNamed:
+            switch (as_CSB(dstSpace)->gammaNamed()) {
+                case kSRGB_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kSRGB_GammaNamed, kFull_ColorSpaceMatch>
+                            <kSRGB_SkGammaNamed, kFull_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
-                case SkColorSpace::k2Dot2Curve_GammaNamed:
+                case k2Dot2Curve_SkGammaNamed:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::k2Dot2Curve_GammaNamed, kFull_ColorSpaceMatch>
+                            <k2Dot2Curve_SkGammaNamed, kFull_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
                 default:
                     return std::unique_ptr<SkColorSpaceXform>(new SkColorSpaceXform_Base
-                            <SkColorSpace::kNonStandard_GammaNamed, kFull_ColorSpaceMatch>
+                            <kNonStandard_SkGammaNamed, kFull_ColorSpaceMatch>
                             (srcSpace, srcToDst, dstSpace));
             }
         default:
             SkASSERT(false);
             return nullptr;
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 415 matching lines @@
     rgba = Sk4f::Min(Sk4f::Max(1023.0f * rgba, 0.0f), 1023.0f);
 
     Sk4i indices = Sk4f_round(rgba);
 
     *((uint32_t*) dst) = dstTables[0][indices[0]] << kRShift
                        | dstTables[1][indices[1]] << kGShift
                        | dstTables[2][indices[2]] << kBShift
                        | (*src & 0xFF000000);
 }
 
-template <SkColorSpace::GammaNamed kDstGamma,
+template <SkGammaNamed kDstGamma,
           ColorSpaceMatch kCSM,
           SkAlphaType kAlphaType,
           SwapRB kSwapRB>
 static void color_xform_RGBA(void* dst, const uint32_t* src, int len,
                              const float* const srcTables[3], const float matrix[16],
                              const uint8_t* const dstTables[3]) {
     decltype(store_srgb            )* store;
     decltype(store_srgb_1          )* store_1;
     decltype(load_rgb_from_tables  )* load;
     decltype(load_rgb_from_tables_1)* load_1;
     size_t sizeOfDstPixel;
     switch (kDstGamma) {
-        case SkColorSpace::kSRGB_GammaNamed:
+        case kSRGB_SkGammaNamed:
             load    = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
                                                             load_rgb_from_tables;
             load_1  = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
                                                             load_rgb_from_tables_1;
             store   = store_srgb;
             store_1 = store_srgb_1;
             sizeOfDstPixel = 4;
             break;
-        case SkColorSpace::k2Dot2Curve_GammaNamed:
+        case k2Dot2Curve_SkGammaNamed:
             load    = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
                                                             load_rgb_from_tables;
             load_1  = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
                                                             load_rgb_from_tables_1;
             store   = store_2dot2;
             store_1 = store_2dot2_1;
             sizeOfDstPixel = 4;
             break;
-        case SkColorSpace::kLinear_GammaNamed:
+        case kLinear_SkGammaNamed:
             load    = load_rgba_from_tables;
             load_1  = load_rgba_from_tables_1;
             store   = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_opaque :
                                                             store_f16;
             store_1 = (kOpaque_SkAlphaType == kAlphaType) ? store_f16_1_opaque :
                                                             store_f16_1;
             sizeOfDstPixel = 8;
             break;
-        case SkColorSpace::kNonStandard_GammaNamed:
+        case kNonStandard_SkGammaNamed:
             load    = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables :
                                                             load_rgb_from_tables;
             load_1  = (kPremul_SkAlphaType == kAlphaType) ? load_rgba_from_tables_1 :
                                                             load_rgb_from_tables_1;
             store   = store_generic;
             store_1 = store_generic_1;
             sizeOfDstPixel = 4;
             break;
     }
 
@@ skipping 69 matching lines @@
         store_1(dst, src, rgba, a, dstTables, kSwapRB);
 
         src += 1;
         len -= 1;
         dst = SkTAddOffset<void>(dst, sizeOfDstPixel);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-template <SkColorSpace::GammaNamed kDst, ColorSpaceMatch kCSM>
+template <SkGammaNamed kDst, ColorSpaceMatch kCSM>
 SkColorSpaceXform_Base<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.asRowMajorf(fSrcToDst);
     build_gamma_tables(fSrcGammaTables, fSrcGammaTableStorage, 256, srcSpace, kToLinear);
     build_gamma_tables(fDstGammaTables, fDstGammaTableStorage, kDstGammaTableSize, dstSpace,
                        kFromLinear);
 }
 
-template <SkColorSpace::GammaNamed kDst, ColorSpaceMatch kCSM>
+template <SkGammaNamed kDst, ColorSpaceMatch kCSM>
 void SkColorSpaceXform_Base<kDst, kCSM>
 ::apply(void* dst, const uint32_t* src, int len, SkColorType dstColorType, SkAlphaType dstAlphaType)
 const
 {
     if (kFull_ColorSpaceMatch == kCSM) {
         switch (dstAlphaType) {
             case kPremul_SkAlphaType:
                 // We can't skip the xform since we need to perform a premultiply in the
                 // linear space.
                 break;
@@ skipping 29 matching lines @@
     switch (dstAlphaType) {
         case kPremul_SkAlphaType:
             switch (dstColorType) {
                 case kRGBA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kPremul_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kBGRA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kPremul_SkAlphaType, kYes_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kRGBA_F16_SkColorType:
-                    return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+                    return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
                                             kPremul_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 default:
                     SkASSERT(false);
                     return;
             }
             break;
         case kUnpremul_SkAlphaType:
             switch (dstColorType) {
                 case kRGBA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kUnpremul_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kBGRA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kUnpremul_SkAlphaType, kYes_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kRGBA_F16_SkColorType:
-                    return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+                    return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
                                             kUnpremul_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 default:
                     SkASSERT(false);
                     return;
             }
         case kOpaque_SkAlphaType:
             switch (dstColorType) {
                 case kRGBA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kOpaque_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kBGRA_8888_SkColorType:
                     return color_xform_RGBA<kDst, kCSM, kOpaque_SkAlphaType, kYes_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 case kRGBA_F16_SkColorType:
-                    return color_xform_RGBA<SkColorSpace::kLinear_GammaNamed, kCSM,
+                    return color_xform_RGBA<kLinear_SkGammaNamed, kCSM,
                                             kOpaque_SkAlphaType, kNo_SwapRB>
                             (dst, src, len, fSrcGammaTables, fSrcToDst, fDstGammaTables);
                 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
-                <SkColorSpace::kNonStandard_GammaNamed, kNone_ColorSpaceMatch>
+                <kNonStandard_SkGammaNamed, kNone_ColorSpaceMatch>
                 (space, SkMatrix::I(), space));
 }