Fix storage of gamut transform matrices in SkColorSpace

src/core/SkColorSpace.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 16 matching lines @@
                                      sk_sp<SkData> profileData)
     : INHERITED(toXYZD50)
     , fColorLUT(std::move(colorLUT))
     , fGammaNamed(gammaNamed)
     , fGammas(std::move(gammas))
     , fProfileData(std::move(profileData))
     , fFromXYZD50(SkMatrix44::kUninitialized_Constructor)
 {}
 
 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
+    0.4358f, 0.3853f, 0.1430f,    // Rx, Gx, Bx
+    0.2224f, 0.7170f, 0.0606f,    // Ry, Gy, Gz
+    0.0139f, 0.0971f, 0.7139f,    // Rz, Gz, Bz
 };
 
 static constexpr float gAdobeRGB_toXYZD50[] {
-    0.6098f, 0.3111f, 0.0195f,    // * R
-    0.2052f, 0.6257f, 0.0609f,    // * G
-    0.1492f, 0.0632f, 0.7448f,    // * B
+    0.6098f, 0.2052f, 0.1492f,    // Rx, Gx, Bx
+    0.3111f, 0.6257f, 0.0632f,    // Ry, Gy, By
+    0.0195f, 0.0609f, 0.7448f,    // Rz, Gz, Bz
 };
 
 /**
  *  Checks if our toXYZ matrix is a close match to a known color gamut.
  *
  *  @param toXYZD50 transformation matrix deduced from profile data
  *  @param standard 3x3 canonical transformation matrix
  */
 static bool xyz_almost_equal(const SkMatrix44& toXYZD50, const float* standard) {
     return color_space_almost_equal(toXYZD50.getFloat(0, 0), standard[0]) &&
@@ skipping 218 matching lines @@
         // If we have a named gamma, write the enum and the matrix.
         switch (as_CSB(this)->fGammaNamed) {
             case kSRGB_SkGammaNamed:
             case k2Dot2Curve_SkGammaNamed:
             case kLinear_SkGammaNamed: {
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
                                                    ColorSpaceHeader::kMatrix_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
-                    fToXYZD50.as4x3ColMajorf((float*) memory);
+                    fToXYZD50.as3x4RowMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 12 * sizeof(float);
             }
             default:
                 // Otherwise, write the gamma values and the matrix.
                 if (memory) {
                     *((ColorSpaceHeader*) memory) =
                             ColorSpaceHeader::Pack(k0_Version, 0, as_CSB(this)->fGammaNamed,
                                                    ColorSpaceHeader::kFloatGamma_Flag);
                     memory = SkTAddOffset<void>(memory, sizeof(ColorSpaceHeader));
 
                     const SkGammas* gammas = as_CSB(this)->gammas();
                     SkASSERT(gammas);
                     SkASSERT(SkGammas::Type::kValue_Type == gammas->fRedType &&
                              SkGammas::Type::kValue_Type == gammas->fGreenType &&
                              SkGammas::Type::kValue_Type == gammas->fBlueType);
                     *(((float*) memory) + 0) = gammas->fRedData.fValue;
                     *(((float*) memory) + 1) = gammas->fGreenData.fValue;
                     *(((float*) memory) + 2) = gammas->fBlueData.fValue;
                     memory = SkTAddOffset<void>(memory, 3 * sizeof(float));
 
-                    fToXYZD50.as4x3ColMajorf((float*) memory);
+                    fToXYZD50.as3x4RowMajorf((float*) memory);
                 }
                 return sizeof(ColorSpaceHeader) + 15 * sizeof(float);
         }
     }
 
     // Otherwise, serialize the ICC data.
     size_t profileSize = as_CSB(this)->fProfileData->size();
     if (SkAlign4(profileSize) != (uint32_t) SkAlign4(profileSize)) {
         return 0;
     }
@@ skipping 38 matching lines @@
 
     switch ((SkGammaNamed) header.fGammaNamed) {
         case kSRGB_SkGammaNamed:
         case k2Dot2Curve_SkGammaNamed:
         case kLinear_SkGammaNamed: {
             if (ColorSpaceHeader::kMatrix_Flag != header.fFlags || length < 12 * sizeof(float)) {
                 return nullptr;
             }
 
             SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-            toXYZ.set4x3ColMajorf((const float*) data);
+            toXYZ.set3x4RowMajorf((const float*) data);
             return SkColorSpace_Base::NewRGB((SkGammaNamed) header.fGammaNamed, toXYZ);
         }
         default:
             break;
     }
 
     switch (header.fFlags) {
         case ColorSpaceHeader::kICC_Flag: {
             if (length < sizeof(uint32_t)) {
                 return nullptr;
@@ skipping 13 matching lines @@
                 return nullptr;
             }
 
             float gammas[3];
             gammas[0] = *(((const float*) data) + 0);
             gammas[1] = *(((const float*) data) + 1);
             gammas[2] = *(((const float*) data) + 2);
             data = SkTAddOffset<const void>(data, 3 * sizeof(float));
 
             SkMatrix44 toXYZ(SkMatrix44::kUninitialized_Constructor);
-            toXYZ.set4x3ColMajorf((const float*) data);
+            toXYZ.set3x4RowMajorf((const float*) data);
             return SkColorSpace_Base::NewRGB(gammas, toXYZ);
         }
         default:
             return nullptr;
     }
 }
 
 bool SkColorSpace::Equals(const SkColorSpace* src, const SkColorSpace* dst) {
     if (src == dst) {
         return true;
@@ skipping 27 matching lines @@
                 return false;
             }
 
             // It is unlikely that we will reach this case.
             sk_sp<SkData> srcData = src->serialize();
             sk_sp<SkData> dstData = dst->serialize();
             return srcData->size() == dstData->size() &&
                    0 == memcmp(srcData->data(), dstData->data(), srcData->size());
     }
 }