Differentiate between sRGBGamma and 2Dot2Gamma

src/codec/SkPngCodec.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmap.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
-#include "SkColorSpace.h"
+#include "SkColorSpace_Base.h"
 #include "SkColorTable.h"
 #include "SkMath.h"
 #include "SkOpts.h"
 #include "SkPngCodec.h"
 #include "SkSize.h"
 #include "SkStream.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 
@@ skipping 143 matching lines @@
     // do the conversion ourselves rather than convert
     // fixed point -> double -> float.
     return ((float) x) * 0.00001f;
 }
 
 static float png_inverted_fixed_point_to_float(png_fixed_point x) {
     // This is necessary because the gAMA chunk actually stores 1/gamma.
     return 1.0f / png_fixed_point_to_float(x);
 }
 
+static constexpr float gSRGB_toXYZD50[] {
+    0.4358f, 0.2224f, 0.0139f,    // * R
+    0.3853f, 0.7170f, 0.0971f,    // * G
+    0.1430f, 0.0606f, 0.7139f,    // * B
+};
+
 // Returns a colorSpace object that represents any color space information in
 // the encoded data.  If the encoded data contains no color space, this will
 // return NULL.
 sk_sp<SkColorSpace> read_color_space(png_structp png_ptr, png_infop info_ptr) {
 
 #if (PNG_LIBPNG_VER_MAJOR > 1) || (PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR >= 6)
 
     // First check for an ICC profile
     png_bytep profile;
     png_uint_32 length;
@@ skipping 31 matching lines @@
 
         // FIXME (msarett): Here we are treating XYZ values as D50 even though the color
         //                  temperature is unspecified.  I suspect that this assumption
         //                  is most often ok, but we could also calculate the color
         //                  temperature (D value) and then convert the XYZ to D50.  Maybe
         //                  we should add a new constructor to SkColorSpace that accepts
         //                  XYZ with D-Unkown?
         for (int i = 0; i < 9; i++) {
             toXYZD50[i] = png_fixed_point_to_float(XYZ[i]);
         }
+        SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+        mat.set3x3ColMajorf(toXYZD50);
 
         if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
             float value = png_inverted_fixed_point_to_float(gamma);
             gammas[0] = value;
             gammas[1] = value;
             gammas[2] = value;
 
-        } else {
-            // Default to sRGB (gamma = 2.2f) if the image has color space information,
-            // but does not specify gamma.
-            gammas[0] = 2.2f;
-            gammas[1] = 2.2f;
-            gammas[2] = 2.2f;
+            return SkColorSpace_Base::NewRGB(gammas, mat);
         }
 
-        SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
-        mat.set3x3ColMajorf(toXYZD50);
-        return SkColorSpace::NewRGB(gammas, mat);
+        // Default to sRGB gamma if the image has color space information,
+        // but does not specify gamma.
+        return SkColorSpace::NewRGB(SkColorSpace::kSRGB_GammaNamed, mat);
     }
 
     // Last, check for gamma.
     if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
 
-        // Guess a default value for cHRM?  Or should we just give up?
-        // Here we use the identity matrix as a default.
-
         // Set the gammas.
         float value = png_inverted_fixed_point_to_float(gamma);
         gammas[0] = value;
         gammas[1] = value;
         gammas[2] = value;
 
-        return SkColorSpace::NewRGB(gammas, SkMatrix44::I());
+        // Since there is no cHRM, we will guess sRGB gamut.
+        SkMatrix44 mat(SkMatrix44::kUninitialized_Constructor);
+        mat.set3x3ColMajorf(gSRGB_toXYZD50);
+
+        return SkColorSpace_Base::NewRGB(gammas, mat);
     }
 
 #endif // LIBPNG >= 1.6
 
-    // Finally, what should we do if there is no color space information in the PNG?
-    // The specification says that this indicates "gamma is unknown" and that the
-    // "color is device dependent".  I'm assuming we can represent this with NULL.
-    // But should we guess sRGB?  Most images are sRGB, even if they don't specify.
+    // Report that there is no color space information in the PNG.  SkPngCodec is currently
+    // implemented to guess sRGB in this case.
     return nullptr;
 }
 
 static int bytes_per_pixel(int bitsPerPixel) {
     // Note that we will have to change this implementation if we start
     // supporting outputs from libpng that are less than 8-bits per component.
     return bitsPerPixel / 8;
 }
 
 // Subclass of SkPngCodec which supports scanline decoding
@@ skipping 530 matching lines @@
     SkCodec* outCodec;
     if (read_header(stream, chunkReader, &outCodec, nullptr, nullptr)) {
         // Codec has taken ownership of the stream.
         SkASSERT(outCodec);
         streamDeleter.release();
         return outCodec;
     }
 
     return nullptr;
 }