Delete SkColorSpace::gammaNamed() from public API

src/core/SkColorSpace_ICC.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 "SkColorSpace.h"
 #include "SkColorSpace_Base.h"
 #include "SkColorSpacePriv.h"
@@ skipping 222 matching lines @@
     dst[2] = SkFixedToFloat(read_big_endian_i32(src + 16));
     SkColorSpacePrintf("XYZ %g %g %g\n", dst[0], dst[1], dst[2]);
     return true;
 }
 
 static constexpr uint32_t kTAG_CurveType     = SkSetFourByteTag('c', 'u', 'r', 'v');
 static constexpr uint32_t kTAG_ParaCurveType = SkSetFourByteTag('p', 'a', 'r', 'a');
 
 static SkGammas::Type set_gamma_value(SkGammas::Data* data, float value) {
     if (color_space_almost_equal(2.2f, value)) {
-        data->fNamed = SkColorSpace::k2Dot2Curve_GammaNamed;
+        data->fNamed = k2Dot2Curve_SkGammaNamed;
         return SkGammas::Type::kNamed_Type;
     }
 
     if (color_space_almost_equal(1.0f, value)) {
-        data->fNamed = SkColorSpace::kLinear_GammaNamed;
+        data->fNamed = kLinear_SkGammaNamed;
         return SkGammas::Type::kNamed_Type;
     }
 
     if (color_space_almost_equal(0.0f, value)) {
         return SkGammas::Type::kNone_Type;
     }
 
     data->fValue = value;
     return SkGammas::Type::kValue_Type;
 }
@@ skipping 44 matching lines @@
             if (len < tagBytes) {
                 SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                 return SkGammas::Type::kNone_Type;
             }
             *outTagBytes = tagBytes;
 
             if (0 == count) {
                 // Some tags require a gamma curve, but the author doesn't actually want
                 // to transform the data.  In this case, it is common to see a curve with
                 // a count of 0.
-                outData->fNamed = SkColorSpace::kLinear_GammaNamed;
+                outData->fNamed = kLinear_SkGammaNamed;
                 return SkGammas::Type::kNamed_Type;
             }
 
             const uint16_t* table = (const uint16_t*) (src + 12);
             if (1 == count) {
                 // The table entry is the gamma (with a bias of 256).
                 float value = (read_big_endian_u16((const uint8_t*) table)) / 256.0f;
                 SkColorSpacePrintf("gamma %g\n", value);
 
                 return set_gamma_value(outData, value);
             }
 
             // Check for frequently occurring sRGB curves.
             // We do this by sampling a few values and see if they match our expectation.
             // A more robust solution would be to compare each value in this curve against
             // an sRGB curve to see if we remain below an error threshold.  At this time,
             // we haven't seen any images in the wild that make this kind of
             // calculation necessary.  We encounter identical gamma curves over and
             // over again, but relatively few variations.
             if (1024 == count) {
                 // The magic values were chosen because they match both the very common
                 // HP sRGB gamma table and the less common Canon sRGB gamma table (which use
                 // different rounding rules).
                 if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
                         3366 == read_big_endian_u16((const uint8_t*) &table[257]) &&
                         14116 == read_big_endian_u16((const uint8_t*) &table[513]) &&
                         34318 == read_big_endian_u16((const uint8_t*) &table[768]) &&
                         65535 == read_big_endian_u16((const uint8_t*) &table[1023])) {
-                    outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+                    outData->fNamed = kSRGB_SkGammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             if (26 == count) {
                 // The magic values were chosen because they match a very common LCMS sRGB
                 // gamma table.
                 if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
                         3062 == read_big_endian_u16((const uint8_t*) &table[6]) &&
                         12824 == read_big_endian_u16((const uint8_t*) &table[12]) &&
                         31237 == read_big_endian_u16((const uint8_t*) &table[18]) &&
                         65535 == read_big_endian_u16((const uint8_t*) &table[25])) {
-                    outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+                    outData->fNamed = kSRGB_SkGammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             if (4096 == count) {
                 // The magic values were chosen because they match Nikon, Epson, and
                 // LCMS sRGB gamma tables (all of which use different rounding rules).
                 if (0 == read_big_endian_u16((const uint8_t*) &table[0]) &&
                         950 == read_big_endian_u16((const uint8_t*) &table[515]) &&
                         3342 == read_big_endian_u16((const uint8_t*) &table[1025]) &&
                         14079 == read_big_endian_u16((const uint8_t*) &table[2051]) &&
                         65535 == read_big_endian_u16((const uint8_t*) &table[4095])) {
-                    outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+                    outData->fNamed = kSRGB_SkGammaNamed;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
             // Otherwise, we will represent gamma with a table.
             outData->fTable.fSize = count;
             return SkGammas::Type::kTable_Type;
         }
         case kTAG_ParaCurveType: {
             enum ParaCurveType {
@@ skipping 100 matching lines @@
             }
 
             // Recognize and simplify a very common parametric representation of sRGB gamma.
             if (color_space_almost_equal(0.9479f, a) &&
                     color_space_almost_equal(0.0521f, b) &&
                     color_space_almost_equal(0.0000f, c) &&
                     color_space_almost_equal(0.0405f, d) &&
                     color_space_almost_equal(0.0774f, e) &&
                     color_space_almost_equal(0.0000f, f) &&
                     color_space_almost_equal(2.4000f, g)) {
-                outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+                outData->fNamed = kSRGB_SkGammaNamed;
                 return SkGammas::Type::kNamed_Type;
             }
 
             // Fail on invalid gammas.
             if (SkScalarIsNaN(d)) {
                 return SkGammas::Type::kNone_Type;
             }
 
             if (d <= 0.0f) {
                 // Y = (aX + b)^g + c  for always
@@ skipping 55 matching lines @@
 }
 
 /**
  *  Sets invalid gamma to the default value.
  */
 static void handle_invalid_gamma(SkGammas::Type* type, SkGammas::Data* data) {
     if (SkGammas::Type::kNone_Type == *type) {
         *type = SkGammas::Type::kNamed_Type;
 
         // Guess sRGB in the case of a malformed transfer function.
-        data->fNamed = SkColorSpace::kSRGB_GammaNamed;
+        data->fNamed = kSRGB_SkGammaNamed;
     }
 }
 
 /**
  *  Finish loading the gammas, now that we have allocated memory for the SkGammas struct.
  *
  *  There's nothing to do for the simple cases, but for table gammas we need to actually
  *  read the table into heap memory.  And for parametric gammas, we need to copy over the
  *  parameter values.
  *
@@ skipping 135 matching lines @@
     array[10] = scale * SkFixedToFloat(read_big_endian_i32(src + 32));
     array[11] = scale * SkFixedToFloat(read_big_endian_i32(src + 44)); // translate B
     array[12] = 0.0f;
     array[13] = 0.0f;
     array[14] = 0.0f;
     array[15] = 1.0f;
     toXYZ->setColMajorf(array);
     return true;
 }
 
-static inline SkColorSpace::GammaNamed is_named(const sk_sp<SkGammas>& gammas) {
+static inline SkGammaNamed is_named(const sk_sp<SkGammas>& gammas) {
     if (gammas->isNamed(0) && gammas->isNamed(1) && gammas->isNamed(2) &&
         gammas->fRedData.fNamed == gammas->fGreenData.fNamed &&
         gammas->fRedData.fNamed == gammas->fBlueData.fNamed)
     {
         return gammas->fRedData.fNamed;
     }
 
-    return SkColorSpace::kNonStandard_GammaNamed;
+    return kNonStandard_SkGammaNamed;
 }
 
 
-static bool load_a2b0(sk_sp<SkColorLookUpTable>* colorLUT, SkColorSpace::GammaNamed* gammaNamed,
+static bool load_a2b0(sk_sp<SkColorLookUpTable>* colorLUT, SkGammaNamed* gammaNamed,
                       sk_sp<SkGammas>* gammas, SkMatrix44* toXYZ, const uint8_t* src, size_t len) {
     if (len < 32) {
         SkColorSpacePrintf("A to B tag is too small (%d bytes).", len);
         return false;
     }
 
     uint32_t type = read_big_endian_u32(src);
     if (kTAG_AtoBType != type) {
         // FIXME (msarett): Need to support lut8Type and lut16Type.
         SkColorSpacePrintf("Unsupported A to B tag type.\n");
@@ skipping 110 matching lines @@
 
             (*gammas)->fBlueType = bType;
             load_gammas(memory, offset, bType, &bData, bParams, bTagPtr);
 
             (*gammas)->fRedData = rData;
             (*gammas)->fGreenData = gData;
             (*gammas)->fBlueData = bData;
         }
     } else {
         // Guess sRGB if the chunk is missing a transfer function.
-        *gammaNamed = SkColorSpace::kSRGB_GammaNamed;
+        *gammaNamed = kSRGB_SkGammaNamed;
     }
 
-    if (SkColorSpace::kNonStandard_GammaNamed == *gammaNamed) {
+    if (kNonStandard_SkGammaNamed == *gammaNamed) {
         *gammaNamed = is_named(*gammas);
-        if (SkColorSpace::kNonStandard_GammaNamed != *gammaNamed) {
+        if (kNonStandard_SkGammaNamed != *gammaNamed) {
             // No need to keep the gammas struct, the enum is enough.
             *gammas = nullptr;
         }
     }
 
     uint32_t offsetToMatrix = read_big_endian_i32(src + 16);
     if (0 != offsetToMatrix && offsetToMatrix < len) {
         if (!load_matrix(toXYZ, src + offsetToMatrix, len - offsetToMatrix)) {
             SkColorSpacePrintf("Failed to read matrix from A to B tag.\n");
             toXYZ->setIdentity();
@@ skipping 98 matching lines @@
 
                     if (!g) {
                         g = r ? r : b;
                     }
 
                     if (!b) {
                         b = r ? r : g;
                     }
                 }
 
-                GammaNamed gammaNamed = kNonStandard_GammaNamed;
+                SkGammaNamed gammaNamed = kNonStandard_SkGammaNamed;
                 sk_sp<SkGammas> gammas = nullptr;
                 size_t tagBytes;
                 if (r && g && b) {
                     if (tag_equals(r, g, base) && tag_equals(g, b, base)) {
                         SkGammas::Data data;
                         SkGammas::Params params;
                         SkGammas::Type type =
                                 parse_gamma(&data, &params, &tagBytes, r->addr(base), r->fLength);
                         handle_invalid_gamma(&type, &data);
 
@@ skipping 56 matching lines @@
 
                         gammas->fBlueType = bType;
                         load_gammas(memory, offset, bType, &bData, bParams, b->addr(base));
 
                         gammas->fRedData = rData;
                         gammas->fGreenData = gData;
                         gammas->fBlueData = bData;
                     }
                 } else {
                     // Guess sRGB if the profile is missing transfer functions.
-                    gammaNamed = kSRGB_GammaNamed;
+                    gammaNamed = kSRGB_SkGammaNamed;
                 }
 
-                if (kNonStandard_GammaNamed == gammaNamed) {
+                if (kNonStandard_SkGammaNamed == gammaNamed) {
                     // It's possible that we'll initially detect non-matching gammas, only for
                     // them to evaluate to the same named gamma curve.
                     gammaNamed = is_named(gammas);
-                    if (kNonStandard_GammaNamed == gammaNamed) {
+                    if (kNonStandard_SkGammaNamed == gammaNamed) {
                         return sk_sp<SkColorSpace>(new SkColorSpace_Base(nullptr, gammaNamed,
                                                                          std::move(gammas), mat,
                                                                          std::move(data)));
                     }
                 }
 
                 return SkColorSpace_Base::NewRGB(gammaNamed, mat);
             }
 
             // Recognize color profile specified by A2B0 tag.
             const ICCTag* a2b0 = ICCTag::Find(tags.get(), tagCount, kTAG_A2B0);
             if (a2b0) {
-                GammaNamed gammaNamed = kNonStandard_GammaNamed;
+                SkGammaNamed gammaNamed = kNonStandard_SkGammaNamed;
                 sk_sp<SkGammas> gammas = nullptr;
                 sk_sp<SkColorLookUpTable> colorLUT = nullptr;
                 SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
                 if (!load_a2b0(&colorLUT, &gammaNamed, &gammas, &toXYZ, a2b0->addr(base),
                                a2b0->fLength)) {
                     return_null("Failed to parse A2B0 tag");
                 }
 
-                if (colorLUT || kNonStandard_GammaNamed == gammaNamed) {
+                if (colorLUT || kNonStandard_SkGammaNamed == gammaNamed) {
                     return sk_sp<SkColorSpace>(new SkColorSpace_Base(std::move(colorLUT),
                                                                      gammaNamed, std::move(gammas),
                                                                      toXYZ, std::move(data)));
                 }
 
                 return SkColorSpace_Base::NewRGB(gammaNamed, toXYZ);
             }
         }
         default:
             break;
@@ skipping 165 matching lines @@
 
     // Write XYZ tags
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 0);
     ptr += kTAG_XYZ_Bytes;
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 1);
     ptr += kTAG_XYZ_Bytes;
     write_xyz_tag((uint32_t*) ptr, fToXYZD50, 2);
     ptr += kTAG_XYZ_Bytes;
 
     // Write TRC tags
-    GammaNamed gammaNamed = this->gammaNamed();
-    if (kNonStandard_GammaNamed == gammaNamed) {
+    SkGammaNamed gammaNamed = this->gammaNamed();
+    if (kNonStandard_SkGammaNamed == gammaNamed) {
         // FIXME (msarett):
         // Write the correct gamma representation rather than 2.2f.
         write_trc_tag((uint32_t*) ptr, 2.2f);
         ptr += SkAlign4(kTAG_TRC_Bytes);
         write_trc_tag((uint32_t*) ptr, 2.2f);
         ptr += SkAlign4(kTAG_TRC_Bytes);
         write_trc_tag((uint32_t*) ptr, 2.2f);
         ptr += SkAlign4(kTAG_TRC_Bytes);
     } else {
         switch (gammaNamed) {
-            case SkColorSpace::kSRGB_GammaNamed:
+            case kSRGB_SkGammaNamed:
                 // FIXME (msarett):
                 // kSRGB cannot be represented by a value.  Here we fall through to 2.2f,
                 // which is a close guess.  To be more accurate, we need to represent sRGB
                 // gamma with a parametric curve.
-            case SkColorSpace::k2Dot2Curve_GammaNamed:
+            case k2Dot2Curve_SkGammaNamed:
                 write_trc_tag((uint32_t*) ptr, 2.2f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 write_trc_tag((uint32_t*) ptr, 2.2f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 write_trc_tag((uint32_t*) ptr, 2.2f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 break;
-            case SkColorSpace::kLinear_GammaNamed:
+            case kLinear_SkGammaNamed:
                 write_trc_tag((uint32_t*) ptr, 1.0f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 write_trc_tag((uint32_t*) ptr, 1.0f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 write_trc_tag((uint32_t*) ptr, 1.0f);
                 ptr += SkAlign4(kTAG_TRC_Bytes);
                 break;
             default:
                 SkASSERT(false);
                 break;
@@ skipping 11 matching lines @@
     ptr32[4] = SkEndian_SwapBE32(0x000116cc);
     ptr += kTAG_XYZ_Bytes;
 
     // Write copyright tag
     memcpy(ptr, gEmptyTextTag, sizeof(gEmptyTextTag));
 
     // TODO (msarett): Should we try to hold onto the data so we can return immediately if
     //                 the client calls again?
     return SkData::MakeFromMalloc(profile.release(), kICCProfileSize);
 }