SkPdf: smaller color serialization

src/pdf/SkPDFShader.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkPDFShader.h"
 
@@ skipping 22 matching lines @@
     SkVector    vec = pts[1] - pts[0];
     SkScalar    mag = vec.length();
     SkScalar    inv = mag ? SkScalarInvert(mag) : 0;
 
     vec.scale(inv);
     matrix->setSinCos(vec.fY, vec.fX);
     matrix->preScale(mag, mag);
     matrix->postTranslate(pts[0].fX, pts[0].fY);
 }
 
+static const int kColorComponents = 3;
+typedef uint8_t ColorTuple[kColorComponents];
+
 /* Assumes t + startOffset is on the stack and does a linear interpolation on t
    between startOffset and endOffset from prevColor to curColor (for each color
    component), leaving the result in component order on the stack. It assumes
    there are always 3 components per color.
    @param range                  endOffset - startOffset
    @param curColor[components]   The current color components.
    @param prevColor[components]  The previous color components.
    @param result                 The result ps function.
  */
-static void interpolateColorCode(SkScalar range, SkScalar* curColor,
-                                 SkScalar* prevColor,
+static void interpolateColorCode(SkScalar range, const ColorTuple& curColor,
+                                 const ColorTuple& prevColor,
                                  SkDynamicMemoryWStream* result) {
     SkASSERT(range != SkIntToScalar(0));
-    static const int kColorComponents = 3;
 
     // Figure out how to scale each color component.
     SkScalar multiplier[kColorComponents];
     for (int i = 0; i < kColorComponents; i++) {
-        multiplier[i] = (curColor[i] - prevColor[i]) / range;
+        static const SkScalar kColorScale = SkScalarInvert(255);
+        multiplier[i] = kColorScale * (curColor[i] - prevColor[i]) / range;
     }
 
     // Calculate when we no longer need to keep a copy of the input parameter t.
     // If the last component to use t is i, then dupInput[0..i - 1] = true
     // and dupInput[i .. components] = false.
     bool dupInput[kColorComponents];
     dupInput[kColorComponents - 1] = false;
     for (int i = kColorComponents - 2; i >= 0; i--) {
         dupInput[i] = dupInput[i + 1] || multiplier[i + 1] != 0;
     }
 
     if (!dupInput[0] && multiplier[0] == 0) {
         result->writeText("pop ");
     }
 
     for (int i = 0; i < kColorComponents; i++) {
         // If the next components needs t and this component will consume a
         // copy, make another copy.
         if (dupInput[i] && multiplier[i] != 0) {
             result->writeText("dup ");
         }
 
         if (multiplier[i] == 0) {
-            SkPDFUtils::AppendScalar(prevColor[i], result);
+            SkPDFUtils::AppendColorComponent(prevColor[i], result);
             result->writeText(" ");
         } else {
             if (multiplier[i] != 1) {
                 SkPDFUtils::AppendScalar(multiplier[i], result);
                 result->writeText(" mul ");
             }
             if (prevColor[i] != 0) {
-                SkPDFUtils::AppendScalar(prevColor[i], result);
+                SkPDFUtils::AppendColorComponent(prevColor[i], result);
                 result->writeText(" add ");
             }
         }
 
         if (dupInput[i]) {
             result->writeText("exch\n");
         }
     }
 }
 
@@ skipping 11 matching lines @@
                                               colorData[2][r,g,b]);
                } else {
 
                 ...    } else {
                            return colorData[info.fColorCount - 1][r,g,b];
                        }
                 ...
            }
        }
  */
-static const int kColorComponents = 3;
-typedef SkScalar ColorTuple[kColorComponents];
 static void gradientFunctionCode(const SkShader::GradientInfo& info,
                                  SkDynamicMemoryWStream* result) {
     /* We want to linearly interpolate from the previous color to the next.
        Scale the colors from 0..255 to 0..1 and determine the multipliers
        for interpolation.
        C{r,g,b}(t, section) = t - offset_(section-1) + t * Multiplier{r,g,b}.
      */
 
     SkAutoSTMalloc<4, ColorTuple> colorDataAlloc(info.fColorCount);
     ColorTuple *colorData = colorDataAlloc.get();
-    const SkScalar scale = SkScalarInvert(SkIntToScalar(255));
     for (int i = 0; i < info.fColorCount; i++) {
-        colorData[i][0] = SkScalarMul(SkColorGetR(info.fColors[i]), scale);
-        colorData[i][1] = SkScalarMul(SkColorGetG(info.fColors[i]), scale);
-        colorData[i][2] = SkScalarMul(SkColorGetB(info.fColors[i]), scale);
+        colorData[i][0] = SkColorGetR(info.fColors[i]);
+        colorData[i][1] = SkColorGetG(info.fColors[i]);
+        colorData[i][2] = SkColorGetB(info.fColors[i]);
     }
 
     // Clamp the initial color.
     result->writeText("dup 0 le {pop ");
-    SkPDFUtils::AppendScalar(colorData[0][0], result);
+    SkPDFUtils::AppendColorComponent(colorData[0][0], result);
     result->writeText(" ");
-    SkPDFUtils::AppendScalar(colorData[0][1], result);
+    SkPDFUtils::AppendColorComponent(colorData[0][1], result);
     result->writeText(" ");
-    SkPDFUtils::AppendScalar(colorData[0][2], result);
+    SkPDFUtils::AppendColorComponent(colorData[0][2], result);
     result->writeText(" }\n");
 
     // The gradient colors.
     int gradients = 0;
     for (int i = 1 ; i < info.fColorCount; i++) {
         if (info.fColorOffsets[i] == info.fColorOffsets[i - 1]) {
             continue;
         }
         gradients++;
 
         result->writeText("{dup ");
         SkPDFUtils::AppendScalar(info.fColorOffsets[i], result);
         result->writeText(" le {");
         if (info.fColorOffsets[i - 1] != 0) {
             SkPDFUtils::AppendScalar(info.fColorOffsets[i - 1], result);
             result->writeText(" sub\n");
         }
 
         interpolateColorCode(info.fColorOffsets[i] - info.fColorOffsets[i - 1],
                              colorData[i], colorData[i - 1], result);
         result->writeText("}\n");
     }
 
     // Clamp the final color.
     result->writeText("{pop ");
-    SkPDFUtils::AppendScalar(colorData[info.fColorCount - 1][0], result);
+    SkPDFUtils::AppendColorComponent(colorData[info.fColorCount - 1][0], result);
     result->writeText(" ");
-    SkPDFUtils::AppendScalar(colorData[info.fColorCount - 1][1], result);
+    SkPDFUtils::AppendColorComponent(colorData[info.fColorCount - 1][1], result);
     result->writeText(" ");
-    SkPDFUtils::AppendScalar(colorData[info.fColorCount - 1][2], result);
+    SkPDFUtils::AppendColorComponent(colorData[info.fColorCount - 1][2], result);
 
     for (int i = 0 ; i < gradients + 1; i++) {
         result->writeText("} ifelse\n");
     }
 }
 
 static sk_sp<SkPDFDict> createInterpolationFunction(const ColorTuple& color1,
                                                     const ColorTuple& color2) {
     auto retval = sk_make_sp<SkPDFDict>();
 
     auto c0 = sk_make_sp<SkPDFArray>();
-    c0->appendScalar(color1[0]);
-    c0->appendScalar(color1[1]);
-    c0->appendScalar(color1[2]);
+    c0->appendColorComponent(color1[0]);
+    c0->appendColorComponent(color1[1]);
+    c0->appendColorComponent(color1[2]);
     retval->insertObject("C0", std::move(c0));
 
     auto c1 = sk_make_sp<SkPDFArray>();
-    c1->appendScalar(color2[0]);
-    c1->appendScalar(color2[1]);
-    c1->appendScalar(color2[2]);
+    c1->appendColorComponent(color2[0]);
+    c1->appendColorComponent(color2[1]);
+    c1->appendColorComponent(color2[2]);
     retval->insertObject("C1", std::move(c1));
 
     auto domain = sk_make_sp<SkPDFArray>();
     domain->appendScalar(0);
     domain->appendScalar(1.0f);
     retval->insertObject("Domain", std::move(domain));
 
     retval->insertInt("FunctionType", 2);
     retval->insertScalar("N", 1.0f);
 
@@ skipping 30 matching lines @@
             colorOffsets[i] += 0.00001f;
         }
     }
     // check if last 2 stops coincide
     if (colorOffsets[i - 1] == colorOffsets[i]) {
         colorOffsets[i - 1] -= 0.00001f;
     }
 
     SkAutoSTMalloc<4, ColorTuple> colorDataAlloc(colorCount);
     ColorTuple *colorData = colorDataAlloc.get();
-    const SkScalar scale = SkScalarInvert(SkIntToScalar(255));
     for (int i = 0; i < colorCount; i++) {
-        colorData[i][0] = SkScalarMul(SkColorGetR(colors[i]), scale);
-        colorData[i][1] = SkScalarMul(SkColorGetG(colors[i]), scale);
-        colorData[i][2] = SkScalarMul(SkColorGetB(colors[i]), scale);
+        colorData[i][0] = SkColorGetR(colors[i]);
+        colorData[i][1] = SkColorGetG(colors[i]);
+        colorData[i][2] = SkColorGetB(colors[i]);
     }
 
     // no need for a stitch function if there are only 2 stops.
     if (colorCount == 2)
         return createInterpolationFunction(colorData[0], colorData[1]);
 
     auto encode = sk_make_sp<SkPDFArray>();
     auto bounds = sk_make_sp<SkPDFArray>();
     auto functions = sk_make_sp<SkPDFArray>();
 
@@ skipping 1145 matching lines @@
     return false;
 }
 
 void SkPDFShader::State::AllocateGradientInfoStorage() {
     fColorData.set(sk_malloc_throw(
                fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
     fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
     fInfo.fColorOffsets =
             reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
 }