Name parametric gamma curve types

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 "SkEndian.h"
@@ skipping 466 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: {
+                enum ParaCurveType {
+                    kExponential_ParaCurveType = 0,
+                    kGAB_ParaCurveType         = 1,
+                    kGABC_ParaCurveType        = 2,
+                    kGABDE_ParaCurveType       = 3,
+                    kGABCDEF_ParaCurveType     = 4,
+                };
+
                 // Determine the format of the parametric curve tag.
                 uint16_t format = read_big_endian_short(src + 8);
-                if (0 == format) {
+                if (kExponential_ParaCurveType == format) {
                     tagBytes = 12 + 4;
                     if (len < tagBytes) {
                         SkColorSpacePrintf("gamma tag is too small (%d bytes)", len);
                         return false;
                     }
 
                     // Y = X^g
                     int32_t g = read_big_endian_int(src + 12);
                     gammas[i].fValue = SkFixedToFloat(g);
                 } else {
                     // 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.
                     float g = 0.0f, a = 0.0f, b = 0.0f, c = 0.0f, d = 0.0f, e = 0.0f, f = 0.0f;
                     switch(format) {
-                        case 1: {
+                        case kGAB_ParaCurveType: {
                             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
                             g = SkFixedToFloat(read_big_endian_int(src + 12));
                             a = SkFixedToFloat(read_big_endian_int(src + 16));
                             b = SkFixedToFloat(read_big_endian_int(src + 20));
                             d = -b / a;
                             break;
                         }
-                        case 2:
+                        case kGABC_ParaCurveType:
                             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
                             g = SkFixedToFloat(read_big_endian_int(src + 12));
                             a = SkFixedToFloat(read_big_endian_int(src + 16));
                             b = SkFixedToFloat(read_big_endian_int(src + 20));
                             c = SkFixedToFloat(read_big_endian_int(src + 24));
                             d = -b / a;
                             f = c;
                             break;
-                        case 3:
+                        case kGABDE_ParaCurveType:
                             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
                             g = SkFixedToFloat(read_big_endian_int(src + 12));
                             a = SkFixedToFloat(read_big_endian_int(src + 16));
                             b = SkFixedToFloat(read_big_endian_int(src + 20));
                             d = SkFixedToFloat(read_big_endian_int(src + 28));
                             e = SkFixedToFloat(read_big_endian_int(src + 24));
                             break;
-                        case 4:
+                        case kGABCDEF_ParaCurveType:
                             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" in place of "eX" but I think
                             //       it's a typo.
@@ skipping 526 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);
 }