Parse parametric gamma curves

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 "SkAtomics.h"
 #include "SkColorSpace.h"
 #include "SkColorSpacePriv.h"
@@ skipping 344 matching lines @@
         switch (type) {
             case kTAG_CurveType: {
                 uint32_t count = read_big_endian_uint(src + 8);
                 tagBytes = 12 + count * 2;
                 if (0 == count) {
                     // Some tags require a gamma curve, but the author doesn't actually want
                     // to transform the data.  In this case, it is common to see a curve with
                     // a count of 0.
                     gammas[i].fValue = 1.0f;
                     break;
-                } else if (len < 12 + 2 * count) {
+                } else if (len < tagBytes) {
                     SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                     return false;
                 }
 
                 const uint16_t* table = (const uint16_t*) (src + 12);
                 if (1 == count) {
                     // The table entry is the gamma (with a bias of 256).
                     uint16_t value = read_big_endian_short((const uint8_t*) table);
                     gammas[i].fValue = value / 256.0f;
                     SkColorSpacePrintf("gamma %d %g\n", value, gammas[i].fValue);
@@ skipping 46 matching lines @@
                 // Otherwise, fill in the interpolation table.
                 gammas[i].fTableSize = count;
                 gammas[i].fTable = std::unique_ptr<float[]>(new float[count]);
                 for (uint32_t j = 0; j < count; j++) {
                     gammas[i].fTable[j] =
                             (read_big_endian_short((const uint8_t*) &table[j])) / 65535.0f;
                 }
                 break;
             }
             case kTAG_ParaCurveType:
-                // Guess 2.2f.
-                // FIXME (msarett): Handle parametric curves.
-                SkColorSpacePrintf("parametric curve\n");
-                gammas[i].fValue = 2.2f;
+                // Determine the format of the parametric curve tag.
+                switch(read_big_endian_short(src + 8)) {
+                    case 0: {
+                        tagBytes = 12 + 4;
+                        if (len < tagBytes) {
+                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
+                            return false;
+                        }
 
-                // Determine the size of the parametric curve tag.
-                switch(read_big_endian_short(src + 8)) {
-                    case 0:
-                        tagBytes = 12 + 4;
+                        // Y = X^g
+                        int32_t g = read_big_endian_int(src + 12);
+                        gammas[i].fValue = SkFixedToFloat(g);
                         break;
-                    case 1:
+                    }
+
+                    // Here's where the real parametric gammas start.  There are many
+                    // permutations of the same equations.
+                    //
+                    // Y = (aX + b)^g + c  for X >= d
+                    // Y = eX + f          otherwise
+                    //
+                    // We will fill in with zeros as necessary to always match the above form.
+                    // Note that there is no need to actually write zero, since the struct is
+                    // zero initialized.
+                    case 1: {
                         tagBytes = 12 + 12;
+                        if (len < tagBytes) {
+                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
+                            return false;
+                        }
+
+                        // Y = (aX + b)^g  for X >= -b/a
+                        // Y = 0           otherwise
+                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
+                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
+                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
+                        gammas[i].fD = -gammas[i].fB / gammas[i].fA;
                         break;
+                    }
                     case 2:
                         tagBytes = 12 + 16;
+                        if (len < tagBytes) {
+                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
+                            return false;
+                        }
+
+                        // Y = (aX + b)^g + c  for X >= -b/a
+                        // Y = c               otherwise
+                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
+                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
+                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
+                        gammas[i].fC = SkFixedToFloat(read_big_endian_int(src + 24));
+                        gammas[i].fD = -gammas[i].fB / gammas[i].fA;
+                        gammas[i].fF = gammas[i].fC;
                         break;
                     case 3:
                         tagBytes = 12 + 20;
+                        if (len < tagBytes) {
+                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
+                            return false;
+                        }
+
+                        // Y = (aX + b)^g  for X >= d
+                        // Y = cX          otherwise
+                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
+                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
+                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
+                        gammas[i].fD = SkFixedToFloat(read_big_endian_int(src + 28));
+                        gammas[i].fE = SkFixedToFloat(read_big_endian_int(src + 24));
                         break;
                     case 4:
                         tagBytes = 12 + 28;
+                        if (len < tagBytes) {
+                            SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
+                            return false;
+                        }
+
+                        // Y = (aX + b)^g + c  for X >= d
+                        // Y = eX + f          otherwise
+                        // NOTE: The ICC spec writes "cX" instead of "eX" but I think it's a typo.
+                        gammas[i].fG = SkFixedToFloat(read_big_endian_int(src + 12));
+                        gammas[i].fA = SkFixedToFloat(read_big_endian_int(src + 16));
+                        gammas[i].fB = SkFixedToFloat(read_big_endian_int(src + 20));
+                        gammas[i].fC = SkFixedToFloat(read_big_endian_int(src + 24));
+                        gammas[i].fD = SkFixedToFloat(read_big_endian_int(src + 28));
+                        gammas[i].fE = SkFixedToFloat(read_big_endian_int(src + 32));
+                        gammas[i].fF = SkFixedToFloat(read_big_endian_int(src + 36));
                         break;
                     default:
                         SkColorSpacePrintf("Invalid parametric curve type\n");
                         return false;
                 }
                 break;
             default:
                 SkColorSpacePrintf("Unsupported gamma tag type %d\n", type);
                 return false;
         }
@@ skipping 279 matching lines @@
                 }
             }
 
         }
         default:
             break;
     }
 
     return_null("ICC profile contains unsupported colorspace");
 }