Add SkColorSpaceTransferFn to SkColorSpace

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 256 matching lines @@
  *                     parametric gamma, it is the responsibility of the caller to set
  *                     fOffset.
  *  @param outParams   If this is a parametric gamma, this is set to the appropriate
  *                     parameters on success.
  *  @param outTagBytes Will be set to the length of the tag on success.
  *  @src               Pointer to tag data.
  *  @len               Length of tag data in bytes.
  *
  *  @return            kNone_Type on failure, otherwise the type of the gamma tag.
  */
-static SkGammas::Type parse_gamma(SkGammas::Data* outData, SkGammas::Params* outParams,
-                                      size_t* outTagBytes, const uint8_t* src, size_t len) {
+static SkGammas::Type parse_gamma(SkGammas::Data* outData, SkColorSpaceTransferFn* outParams,
+                                  size_t* outTagBytes, const uint8_t* src, size_t len) {
     if (len < 12) {
         SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
         return SkGammas::Type::kNone_Type;
     }
 
     // In the case of consecutive gamma tags, we need to count the number of bytes in the
     // tag, so that we can move on to the next tag.
     size_t tagBytes;
 
     uint32_t type = read_big_endian_u32(src);
@@ skipping 182 matching lines @@
                     c = read_big_endian_16_dot_16(src + 24);
                     d = read_big_endian_16_dot_16(src + 28);
                     e = read_big_endian_16_dot_16(src + 32);
                     f = read_big_endian_16_dot_16(src + 36);
                     break;
                 default:
                     SkASSERT(false);
                     return SkGammas::Type::kNone_Type;
             }
 
-            // 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 = 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
-                if (0.0f == a || 0.0f == g) {
-                    SkColorSpacePrintf("A or G is zero, constant gamma function "
-                                       "is nonsense");
-                    return SkGammas::Type::kNone_Type;
-                }
-            }
-
-            if (d >= 1.0f) {
-                // Y = eX + f          for always
-                if (0.0f == e) {
-                    SkColorSpacePrintf("E is zero, constant gamma function is "
-                                       "nonsense");
-                    return SkGammas::Type::kNone_Type;
-                }
-            }
-
-            if ((0.0f == a || 0.0f == g) && 0.0f == e) {
-                SkColorSpacePrintf("A or G, and E are zero, constant gamma function "
-                                   "is nonsense");
-                return SkGammas::Type::kNone_Type;
-            }
-
-            *outTagBytes = tagBytes;
-
             outParams->fG = g;
             outParams->fA = a;
             outParams->fB = b;
             outParams->fC = c;
             outParams->fD = d;
             outParams->fE = e;
             outParams->fF = f;
+
+            if (!is_valid_transfer_fn(*outParams)) {
+                return SkGammas::Type::kNone_Type;
+            }
+
+            if (is_almost_srgb(*outParams)) {
+                outData->fNamed = kSRGB_SkGammaNamed;
+                return SkGammas::Type::kNamed_Type;
+            }
+
+            if (is_almost_2dot2(*outParams)) {
+                outData->fNamed = k2Dot2Curve_SkGammaNamed;
+                return SkGammas::Type::kNamed_Type;
+            }
+
+            *outTagBytes = tagBytes;
             return SkGammas::Type::kParam_Type;
         }
         default:
             SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
             return SkGammas::Type::kNone_Type;
     }
 }
 
 /**
  *  Returns the additional size in bytes needed to store the gamma tag.
  */
 static size_t gamma_alloc_size(SkGammas::Type type, const SkGammas::Data& data) {
     switch (type) {
         case SkGammas::Type::kNamed_Type:
         case SkGammas::Type::kValue_Type:
             return 0;
         case SkGammas::Type::kTable_Type:
             return sizeof(float) * data.fTable.fSize;
         case SkGammas::Type::kParam_Type:
-            return sizeof(SkGammas::Params);
+            return sizeof(SkColorSpaceTransferFn);
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 /**
  *  Sets invalid gamma to the default value.
  */
 static void handle_invalid_gamma(SkGammas::Type* type, SkGammas::Data* data) {
@@ skipping 16 matching lines @@
  *  @param offset Bytes of memory (after the SkGammas struct) that are already in use.
  *  @param data   In-out variable.  Will fill in the offset to the table or parameters
  *                if necessary.
  *  @param params Parameters for gamma curve.  Only initialized/used when we have a
  *                parametric gamma.
  *  @param src    Pointer to start of the gamma tag.
  *
  *  @return       Additional bytes of memory that are being used by this gamma curve.
  */
 static size_t load_gammas(void* memory, size_t offset, SkGammas::Type type,
-                        SkGammas::Data* data, const SkGammas::Params& params,
+                        SkGammas::Data* data, const SkColorSpaceTransferFn& params,
                         const uint8_t* src) {
     void* storage = SkTAddOffset<void>(memory, offset + sizeof(SkGammas));
 
     switch (type) {
         case SkGammas::Type::kNamed_Type:
         case SkGammas::Type::kValue_Type:
             // Nothing to do here.
             return 0;
         case SkGammas::Type::kTable_Type: {
             data->fTable.fOffset = offset;
 
             float* outTable = (float*) storage;
             const uint16_t* inTable = (const uint16_t*) (src + 12);
             for (int i = 0; i < data->fTable.fSize; i++) {
                 outTable[i] = (read_big_endian_u16((const uint8_t*) &inTable[i])) / 65535.0f;
             }
 
             return sizeof(float) * data->fTable.fSize;
         }
         case SkGammas::Type::kParam_Type:
             data->fTable.fOffset = offset;
-            memcpy(storage, &params, sizeof(SkGammas::Params));
-            return sizeof(SkGammas::Params);
+            memcpy(storage, &params, sizeof(SkColorSpaceTransferFn));
+            return sizeof(SkColorSpaceTransferFn);
         default:
             SkASSERT(false);
             return 0;
     }
 }
 
 static constexpr uint32_t kTAG_AtoBType = SkSetFourByteTag('m', 'A', 'B', ' ');
 
 static bool load_color_lut(sk_sp<SkColorLookUpTable>* colorLUT, uint32_t inputChannels,
                            const uint8_t* src, size_t len) {
@@ skipping 157 matching lines @@
             SkColorSpacePrintf("Failed to read color LUT from A to B tag.\n");
         }
     }
 
     uint32_t offsetToMCurves = read_big_endian_i32(src + 20);
     if (0 != offsetToMCurves && offsetToMCurves < len) {
         const uint8_t* rTagPtr = src + offsetToMCurves;
         size_t tagLen = len - offsetToMCurves;
 
         SkGammas::Data rData;
-        SkGammas::Params rParams;
+        SkColorSpaceTransferFn rParams;
 
         // On an invalid first gamma, tagBytes remains set as zero.  This causes the two
         // subsequent to be treated as identical (which is what we want).
         size_t tagBytes = 0;
         SkGammas::Type rType = parse_gamma(&rData, &rParams, &tagBytes, rTagPtr, tagLen);
         handle_invalid_gamma(&rType, &rData);
         size_t alignedTagBytes = SkAlign4(tagBytes);
 
         if ((3 * alignedTagBytes <= tagLen) &&
             !memcmp(rTagPtr, rTagPtr + 1 * alignedTagBytes, tagBytes) &&
@@ skipping 14 matching lines @@
                 (*gammas)->fBlueType = rType;
 
                 (*gammas)->fRedData = rData;
                 (*gammas)->fGreenData = rData;
                 (*gammas)->fBlueData = rData;
             }
         } else {
             const uint8_t* gTagPtr = rTagPtr + alignedTagBytes;
             tagLen = tagLen > alignedTagBytes ? tagLen - alignedTagBytes : 0;
             SkGammas::Data gData;
-            SkGammas::Params gParams;
+            SkColorSpaceTransferFn gParams;
             tagBytes = 0;
             SkGammas::Type gType = parse_gamma(&gData, &gParams, &tagBytes, gTagPtr,
-                                                       tagLen);
+                                               tagLen);
             handle_invalid_gamma(&gType, &gData);
 
             alignedTagBytes = SkAlign4(tagBytes);
             const uint8_t* bTagPtr = gTagPtr + alignedTagBytes;
             tagLen = tagLen > alignedTagBytes ? tagLen - alignedTagBytes : 0;
             SkGammas::Data bData;
-            SkGammas::Params bParams;
+            SkColorSpaceTransferFn bParams;
             SkGammas::Type bType = parse_gamma(&bData, &bParams, &tagBytes, bTagPtr,
                                                        tagLen);
             handle_invalid_gamma(&bType, &bData);
 
             size_t allocSize = sizeof(SkGammas);
             return_if_false(safe_add(allocSize, gamma_alloc_size(rType, rData), &allocSize),
                             "SkGammas struct is too large to allocate");
             return_if_false(safe_add(allocSize, gamma_alloc_size(gType, gData), &allocSize),
                             "SkGammas struct is too large to allocate");
             return_if_false(safe_add(allocSize, gamma_alloc_size(bType, bData), &allocSize),
@@ skipping 142 matching lines @@
                         b = r ? r : g;
                     }
                 }
 
                 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;
+                        SkColorSpaceTransferFn params;
                         SkGammas::Type type =
                                 parse_gamma(&data, &params, &tagBytes, r->addr(base), r->fLength);
                         handle_invalid_gamma(&type, &data);
 
                         if (SkGammas::Type::kNamed_Type == type) {
                             gammaNamed = data.fNamed;
                         } else {
                             size_t allocSize = sizeof(SkGammas);
                             if (!safe_add(allocSize, gamma_alloc_size(type, data), &allocSize)) {
                                 return_null("SkGammas struct is too large to allocate");
                             }
                             void* memory = sk_malloc_throw(allocSize);
                             gammas = sk_sp<SkGammas>(new (memory) SkGammas());
                             load_gammas(memory, 0, type, &data, params, r->addr(base));
 
                             gammas->fRedType = type;
                             gammas->fGreenType = type;
                             gammas->fBlueType = type;
 
                             gammas->fRedData = data;
                             gammas->fGreenData = data;
                             gammas->fBlueData = data;
                         }
                     } else {
                         SkGammas::Data rData;
-                        SkGammas::Params rParams;
+                        SkColorSpaceTransferFn rParams;
                         SkGammas::Type rType =
                                 parse_gamma(&rData, &rParams, &tagBytes, r->addr(base), r->fLength);
                         handle_invalid_gamma(&rType, &rData);
 
                         SkGammas::Data gData;
-                        SkGammas::Params gParams;
+                        SkColorSpaceTransferFn gParams;
                         SkGammas::Type gType =
                                 parse_gamma(&gData, &gParams, &tagBytes, g->addr(base), g->fLength);
                         handle_invalid_gamma(&gType, &gData);
 
                         SkGammas::Data bData;
-                        SkGammas::Params bParams;
+                        SkColorSpaceTransferFn bParams;
                         SkGammas::Type bType =
                                 parse_gamma(&bData, &bParams, &tagBytes, b->addr(base), b->fLength);
                         handle_invalid_gamma(&bType, &bData);
 
                         size_t allocSize = sizeof(SkGammas);
                         if (!safe_add(allocSize, gamma_alloc_size(rType, rData), &allocSize) ||
                             !safe_add(allocSize, gamma_alloc_size(gType, gData), &allocSize) ||
                             !safe_add(allocSize, gamma_alloc_size(bType, bData), &allocSize))
                         {
                             return_null("SkGammas struct is too large to allocate");
@@ skipping 284 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);
 }