Correct png inverse gAMA when parsing color space

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"
@@ skipping 156 matching lines @@
 }
 
 static float png_fixed_point_to_float(png_fixed_point x) {
     // We multiply by the same factor that libpng used to convert
     // fixed point -> double.  Since we want floats, we choose to
     // 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) {
+    // Multiply by the inverse of the factor used by libpng.
+    // This is necessary because the gAMA chunk actually stores 1/gamma.
+    return ((float) x) * 100000.0f;

[Brian Osman, 2016/03/23 13:01:50]

I think you want 1.0f / (png_fixed_point_to_float(x)), which is not the same
thing.

[msarett, 2016/03/23 13:16:19]

Doh thanks.  Tough day for algebra yesterday.

+}
+
 // 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 32 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.fMat[i] = png_fixed_point_to_float(XYZ[i]);
         }
 
-        if (PNG_INFO_gAMA != png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
-
+        if (PNG_INFO_gAMA == png_get_gAMA_fixed(png_ptr, info_ptr, &gamma)) {
+            gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] =
+                    png_inverted_fixed_point_to_float(gamma);
+        } else {
             // If the image does not specify gamma, let's choose linear.  Should we default
             // to sRGB?  Most images are intended to be sRGB (gamma = 2.2f).
-            gamma = PNG_GAMMA_LINEAR;
+            gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = 1.0f;
         }
-        gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = png_fixed_point_to_float(gamma);
+
 
         return SkColorSpace::NewRGB(toXYZD50, gammas);
     }
 
     // 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.
         // FIXME (msarett): Should SkFloat3x3 have a method to set the identity matrix?
         memset(toXYZD50.fMat, 0, 9 * sizeof(float));
         toXYZD50.fMat[0] = toXYZD50.fMat[4] = toXYZD50.fMat[8] = 1.0f;
 
         // Set the gammas.
-        gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = png_fixed_point_to_float(gamma);
+        gammas.fVec[0] = gammas.fVec[1] = gammas.fVec[2] = png_inverted_fixed_point_to_float(gamma);
 
         return SkColorSpace::NewRGB(toXYZD50, gammas);
     }
 
 #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.
@@ skipping 581 matching lines @@
 
     if (1 == numberPasses) {
         return new SkPngScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                         png_ptr, info_ptr, bitDepth, colorSpace);
     }
 
     return new SkPngInterlacedScanlineDecoder(imageInfo, streamDeleter.release(), chunkReader,
                                               png_ptr, info_ptr, bitDepth, numberPasses,
                                               colorSpace);
 }