More robust check for sRGB gamma tables

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 244 matching lines @@
 
     data->fValue = value;
     return SkGammas::Type::kValue_Type;
 }
 
 static float read_big_endian_16_dot_16(const uint8_t buf[4]) {
     // It just so happens that SkFixed is also 16.16!
     return SkFixedToFloat(read_big_endian_i32(buf));
 }
 
+static inline float srgb_fn(float x) {
+    if (x <= 0.04045f) {
+        return x * (1.0f / 12.92f);
+    }
+
+    return powf(x * (1.0f / 1.055f) + (0.055f / 1.055f), 2.4f);
+}
+
 /**
  *  @param outData     Set to the appropriate value on success.  If we have table or
  *                     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.
  *
@@ skipping 88 matching lines @@
                 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;
                     return SkGammas::Type::kNamed_Type;
                 }
             }
 
-            // Otherwise, we will represent gamma with a table.
-            outData->fTable.fSize = count;
-            return SkGammas::Type::kTable_Type;
+            // Perform a more robust check for sRGB.  See if the table is a close
+            // match to an sRGB table.  This is in addition to the previous sRGB
+            // checks for a couple reasons:
+            // (1) It is much slower.
+            // (2) The 26 entry "sRGB" curve is actually so inaccurate that it fails
+            //     this check.  But it still wants to be sRGB.
+            float x = 0.0f;
+            float dx = 1.0f / ((float) (count - 1));
+            for (uint32_t i = 0; i < count; i++) {
+                float y = srgb_fn(x);
+
+                // Convert y to the same format as the table (0.16 fixed point), so we can
+                // compare values.
+                uint16_t srgbY = sk_float_round2int(y * (float) (1 << 16));
+                uint16_t actualY = read_big_endian_u16((const uint8_t*) &table[i]);
+
+                // We allow "off by 1" curves to try to not be affected by rounding decisions.
+                if (SkTAbs((int32_t) srgbY - (int32_t) actualY) > 1) {
+                    // Curve is not sRGB, will use table representation.
+                    outData->fTable.fSize = count;
+                    return SkGammas::Type::kTable_Type;
+                }
+
+                x += dx;
+            }
+
+            outData->fNamed = SkColorSpace::kSRGB_GammaNamed;
+            return SkGammas::Type::kNamed_Type;
+
         }
         case kTAG_ParaCurveType: {
             enum ParaCurveType {
                 kExponential_ParaCurveType = 0,
                 kGAB_ParaCurveType         = 1,
                 kGABC_ParaCurveType        = 2,
                 kGABDE_ParaCurveType       = 3,
                 kGABCDEF_ParaCurveType     = 4,
             };
 
@@ skipping 937 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);
 }