SkPDF: Use type 2/3 shading for gradient shaders

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 104 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}.
      */
-    static const int kColorComponents = 3;
-    typedef SkScalar ColorTuple[kColorComponents];
+
     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);
     }
 
     // Clamp the initial color.
@@ skipping 32 matching lines @@
     result->writeText(" ");
     SkPDFUtils::AppendScalar(colorData[info.fColorCount - 1][1], result);
     result->writeText(" ");
     SkPDFUtils::AppendScalar(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>();
+    

[hal.canary, 2016/06/17 17:08:55]

nit: please remove trailing whitespace.

+    auto c0 = sk_make_sp<SkPDFArray>();
+    c0->appendScalar(color1[0]);
+    c0->appendScalar(color1[1]);
+    c0->appendScalar(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]);
+    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);
+    
+    return retval;
+}
+
+static sk_sp<SkPDFDict> gradientStitchCode(const SkShader::GradientInfo& info) {
+    auto retval = sk_make_sp<SkPDFDict>();
+    
+    // normalize color stops
+    int colorCount = info.fColorCount;
+    SkTDArray<SkColor>    colors(info.fColors, colorCount);
+    SkTDArray<SkScalar>   colorOffsets(info.fColorOffsets, colorCount);
+
+    int i = 1;
+    while (i < colorCount - 1) {
+        // ensure stops are in order
+        if (colorOffsets[i - 1] > colorOffsets[i]) {
+            colorOffsets[i] = colorOffsets[i - 1];
+        }
+
+        // remove points that are between 2 coincident points
+        if ((colorOffsets[i - 1] == colorOffsets[i]) && (colorOffsets[i] == colorOffsets[i + 1])) {
+            colorCount -= 1;
+            colors.remove(i);
+            colorOffsets.remove(i);
+        } else {
+            i++;
+        }
+    }
+    // find coincident points and slightly move them over
+    for (i = 1; i < colorCount - 1; i++) {
+        if (colorOffsets[i - 1] == colorOffsets[i]) {
+            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);
+    }
+    
+    // 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>();
+    
+    auto domain = sk_make_sp<SkPDFArray>();
+    domain->appendScalar(0);
+    domain->appendScalar(1.0f);
+    retval->insertObject("Domain", std::move(domain));
+    retval->insertInt("FunctionType", 3);
+    
+    for (int i = 1; i < colorCount; i++) {
+        if (i > 1) {
+            bounds->appendScalar(colorOffsets[i-1]);
+        }
+        
+        encode->appendScalar(0);
+        encode->appendScalar(1.0f);
+    
+        functions->appendObject(createInterpolationFunction(colorData[i-1], colorData[i]));
+    }
+    
+    retval->insertObject("Encode", std::move(encode));
+    retval->insertObject("Bounds", std::move(bounds));
+    retval->insertObject("Functions", std::move(functions));
+    
+    return retval;
+}
+
+
 /* Map a value of t on the stack into [0, 1) for Repeat or Mirror tile mode. */
 static void tileModeCode(SkShader::TileMode mode,
                          SkDynamicMemoryWStream* result) {
     if (mode == SkShader::kRepeat_TileMode) {
         result->writeText("dup truncate sub\n");  // Get the fractional part.
         result->writeText("dup 0 le {1 add} if\n");  // Map (-1,0) => (0,1)
         return;
     }
 
     if (mode == SkShader::kMirror_TileMode) {
@@ skipping 502 matching lines @@
         std::unique_ptr<SkStreamAsset> psCode,
         SkPDFArray* domain,
         sk_sp<SkPDFObject> range) {
     auto result = sk_make_sp<SkPDFStream>(psCode.get());
     result->insertInt("FunctionType", 4);
     result->insertObject("Domain", sk_ref_sp(domain));
     result->insertObject("Range", std::move(range));
     return result;
 }
 
+// catch cases where the inner just touches the outer circle
+// and make the inner circle just inside the outer one to match raster
+static void FixUpRadius(const SkPoint& p1, SkScalar& r1, const SkPoint& p2, SkScalar& r2) {
+    // detect touching circles
+    SkScalar distance = SkPoint::Distance(p1, p2);
+    SkScalar subtractRadii = fabs(r1 - r2);
+    if (fabs(distance - subtractRadii) < 0.002f) {
+        if (r1 > r2) {
+            r1 += 0.002f;
+        } else {
+            r2 += 0.002f;
+        }
+    }
+}
+
 SkPDFFunctionShader* SkPDFFunctionShader::Create(
         SkPDFCanon* canon, std::unique_ptr<SkPDFShader::State>* autoState) {
     const SkPDFShader::State& state = **autoState;
 
     void (*codeFunction)(const SkShader::GradientInfo& info,
                          const SkMatrix& perspectiveRemover,
                          SkDynamicMemoryWStream* function) = nullptr;
     SkPoint transformPoints[2];
-
-    // Depending on the type of the gradient, we want to transform the
-    // coordinate space in different ways.
     const SkShader::GradientInfo* info = &state.fInfo;
-    transformPoints[0] = info->fPoint[0];
-    transformPoints[1] = info->fPoint[1];
-    switch (state.fType) {
-        case SkShader::kLinear_GradientType:
-            codeFunction = &linearCode;
-            break;
-        case SkShader::kRadial_GradientType:
-            transformPoints[1] = transformPoints[0];
-            transformPoints[1].fX += info->fRadius[0];
-            codeFunction = &radialCode;
-            break;
-        case SkShader::kConical_GradientType: {
-            transformPoints[1] = transformPoints[0];
-            transformPoints[1].fX += SK_Scalar1;
-            codeFunction = &twoPointConicalCode;
-            break;
-        }
-        case SkShader::kSweep_GradientType:
-            transformPoints[1] = transformPoints[0];
-            transformPoints[1].fX += SK_Scalar1;
-            codeFunction = &sweepCode;
-            break;
-        case SkShader::kColor_GradientType:
-        case SkShader::kNone_GradientType:
-        default:
-            return nullptr;
-    }
-
-    // Move any scaling (assuming a unit gradient) or translation
-    // (and rotation for linear gradient), of the final gradient from
-    // info->fPoints to the matrix (updating bbox appropriately).  Now
-    // the gradient can be drawn on on the unit segment.
-    SkMatrix mapperMatrix;
-    unitToPointsMatrix(transformPoints, &mapperMatrix);
-
     SkMatrix finalMatrix = state.fCanvasTransform;
     finalMatrix.preConcat(state.fShaderTransform);
-    finalMatrix.preConcat(mapperMatrix);
 
-    // Preserves as much as posible in the final matrix, and only removes
-    // the perspective. The inverse of the perspective is stored in
-    // perspectiveInverseOnly matrix and has 3 useful numbers
-    // (p0, p1, p2), while everything else is either 0 or 1.
-    // In this way the shader will handle it eficiently, with minimal code.
-    SkMatrix perspectiveInverseOnly = SkMatrix::I();
-    if (finalMatrix.hasPerspective()) {
-        if (!split_perspective(finalMatrix,
-                               &finalMatrix, &perspectiveInverseOnly)) {
-            return nullptr;
-        }
-    }
-
-    SkRect bbox;
-    bbox.set(state.fBBox);
-    if (!inverse_transform_bbox(finalMatrix, &bbox)) {
-        return nullptr;
-    }
+    bool doStitchFunctions = (state.fType == SkShader::kLinear_GradientType ||
+                                state.fType == SkShader::kRadial_GradientType ||
+                                state.fType == SkShader::kConical_GradientType) &&
+                                info->fTileMode == SkShader::kClamp_TileMode &&
+                                !finalMatrix.hasPerspective();
 
     auto domain = sk_make_sp<SkPDFArray>();
-    domain->reserve(4);
-    domain->appendScalar(bbox.fLeft);
-    domain->appendScalar(bbox.fRight);
-    domain->appendScalar(bbox.fTop);
-    domain->appendScalar(bbox.fBottom);
 
-    SkDynamicMemoryWStream functionCode;
+    int32_t shadingType = 1;
+    auto pdfShader = sk_make_sp<SkPDFDict>();
     // The two point radial gradient further references
     // state.fInfo
     // in translating from x, y coordinates to the t parameter. So, we have
     // to transform the points and radii according to the calculated matrix.
-    if (state.fType == SkShader::kConical_GradientType) {
-        SkShader::GradientInfo twoPointRadialInfo = *info;
-        SkMatrix inverseMapperMatrix;
-        if (!mapperMatrix.invert(&inverseMapperMatrix)) {
+    if (doStitchFunctions) {
+        pdfShader->insertObject("Function", gradientStitchCode(*info));
+        shadingType = (state.fType == SkShader::kLinear_GradientType) ? 2 : 3;
+        
+        auto extend = sk_make_sp<SkPDFArray>();
+        extend->reserve(2);
+        extend->appendBool(true);
+        extend->appendBool(true);
+        pdfShader->insertObject("Extend", std::move(extend));
+        
+        auto coords = sk_make_sp<SkPDFArray>();
+        if (state.fType == SkShader::kConical_GradientType) {
+            coords->reserve(6);
+            SkScalar r1 = info->fRadius[0];
+            SkScalar r2 = info->fRadius[1];
+            SkPoint pt1 = info->fPoint[0];
+            SkPoint pt2 = info->fPoint[1];
+            FixUpRadius(pt1, r1, pt2, r2);
+
+            coords->appendScalar(pt1.fX);
+            coords->appendScalar(pt1.fY);
+            coords->appendScalar(r1);
+            
+            coords->appendScalar(pt2.fX);
+            coords->appendScalar(pt2.fY);
+            coords->appendScalar(r2);
+        } else if (state.fType == SkShader::kRadial_GradientType) {
+            coords->reserve(6);
+            const SkPoint& pt1 = info->fPoint[0];
+
+            coords->appendScalar(pt1.fX);
+            coords->appendScalar(pt1.fY);
+            coords->appendScalar(0);
+            
+            coords->appendScalar(pt1.fX);
+            coords->appendScalar(pt1.fY);
+            coords->appendScalar(info->fRadius[0]);
+        } else {
+            coords->reserve(4);
+            const SkPoint& pt1 = info->fPoint[0];
+            const SkPoint& pt2 = info->fPoint[1];
+
+            coords->appendScalar(pt1.fX);
+            coords->appendScalar(pt1.fY);
+            
+            coords->appendScalar(pt2.fX);
+            coords->appendScalar(pt2.fY);
+        }
+
+        pdfShader->insertObject("Coords", std::move(coords));
+    } else {
+        // Depending on the type of the gradient, we want to transform the
+        // coordinate space in different ways.
+        transformPoints[0] = info->fPoint[0];
+        transformPoints[1] = info->fPoint[1];
+        switch (state.fType) {
+            case SkShader::kLinear_GradientType:
+                codeFunction = &linearCode;
+                break;
+            case SkShader::kRadial_GradientType:
+                transformPoints[1] = transformPoints[0];
+                transformPoints[1].fX += info->fRadius[0];
+                codeFunction = &radialCode;
+                break;
+            case SkShader::kConical_GradientType: {
+                transformPoints[1] = transformPoints[0];
+                transformPoints[1].fX += SK_Scalar1;
+                codeFunction = &twoPointConicalCode;
+                break;
+            }
+            case SkShader::kSweep_GradientType:
+                transformPoints[1] = transformPoints[0];
+                transformPoints[1].fX += SK_Scalar1;
+                codeFunction = &sweepCode;
+                break;
+            case SkShader::kColor_GradientType:
+            case SkShader::kNone_GradientType:
+            default:
+                return nullptr;
+        }
+
+        // Move any scaling (assuming a unit gradient) or translation
+        // (and rotation for linear gradient), of the final gradient from
+        // info->fPoints to the matrix (updating bbox appropriately).  Now
+        // the gradient can be drawn on on the unit segment.
+        SkMatrix mapperMatrix;
+        unitToPointsMatrix(transformPoints, &mapperMatrix);
+
+        finalMatrix.preConcat(mapperMatrix);
+
+        // Preserves as much as posible in the final matrix, and only removes
+        // the perspective. The inverse of the perspective is stored in
+        // perspectiveInverseOnly matrix and has 3 useful numbers
+        // (p0, p1, p2), while everything else is either 0 or 1.
+        // In this way the shader will handle it eficiently, with minimal code.
+        SkMatrix perspectiveInverseOnly = SkMatrix::I();
+        if (finalMatrix.hasPerspective()) {
+            if (!split_perspective(finalMatrix,
+                                   &finalMatrix, &perspectiveInverseOnly)) {
+                return nullptr;
+            }
+        }
+
+        SkRect bbox;
+        bbox.set(state.fBBox);
+        if (!inverse_transform_bbox(finalMatrix, &bbox)) {
             return nullptr;
         }
-        inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
-        twoPointRadialInfo.fRadius[0] =
-            inverseMapperMatrix.mapRadius(info->fRadius[0]);
-        twoPointRadialInfo.fRadius[1] =
-            inverseMapperMatrix.mapRadius(info->fRadius[1]);
-        codeFunction(twoPointRadialInfo, perspectiveInverseOnly, &functionCode);
-    } else {
-        codeFunction(*info, perspectiveInverseOnly, &functionCode);
+        domain->reserve(4);
+        domain->appendScalar(bbox.fLeft);
+        domain->appendScalar(bbox.fRight);
+        domain->appendScalar(bbox.fTop);
+        domain->appendScalar(bbox.fBottom);
+        
+        SkDynamicMemoryWStream functionCode;
+        
+        if (state.fType == SkShader::kConical_GradientType) {
+            SkShader::GradientInfo twoPointRadialInfo = *info;
+            SkMatrix inverseMapperMatrix;
+            if (!mapperMatrix.invert(&inverseMapperMatrix)) {
+                return nullptr;
+            }
+            inverseMapperMatrix.mapPoints(twoPointRadialInfo.fPoint, 2);
+            twoPointRadialInfo.fRadius[0] =
+                inverseMapperMatrix.mapRadius(info->fRadius[0]);
+            twoPointRadialInfo.fRadius[1] =
+                inverseMapperMatrix.mapRadius(info->fRadius[1]);
+            codeFunction(twoPointRadialInfo, perspectiveInverseOnly, &functionCode);
+        } else {
+            codeFunction(*info, perspectiveInverseOnly, &functionCode);
+        }
+        
+        pdfShader->insertObject("Domain", sk_ref_sp(domain.get()));
+
+        // Call canon->makeRangeObject() instead of
+        // SkPDFShader::MakeRangeObject() so that the canon can
+        // deduplicate.
+        std::unique_ptr<SkStreamAsset> functionStream(
+                functionCode.detachAsStream());
+        auto function = make_ps_function(std::move(functionStream), domain.get(),
+            canon->makeRangeObject());
+        pdfShader->insertObjRef("Function", std::move(function));
     }
 
-    auto pdfShader = sk_make_sp<SkPDFDict>();
-    pdfShader->insertInt("ShadingType", 1);
+    pdfShader->insertInt("ShadingType", shadingType);
     pdfShader->insertName("ColorSpace", "DeviceRGB");
-    pdfShader->insertObject("Domain", sk_ref_sp(domain.get()));
-
-    // Call canon->makeRangeObject() instead of
-    // SkPDFShader::MakeRangeObject() so that the canon can
-    // deduplicate.
-    std::unique_ptr<SkStreamAsset> functionStream(
-            functionCode.detachAsStream());
-    auto function = make_ps_function(std::move(functionStream), domain.get(),
-        canon->makeRangeObject());
-    pdfShader->insertObjRef("Function", std::move(function));
 
     sk_sp<SkPDFFunctionShader> pdfFunctionShader(
             new SkPDFFunctionShader(autoState->release()));
     pdfFunctionShader->insertInt("PatternType", 2);
     pdfFunctionShader->insertObject("Matrix",
                                     SkPDFUtils::MatrixToArray(finalMatrix));
     pdfFunctionShader->insertObject("Shading", std::move(pdfShader));
 
     canon->addFunctionShader(pdfFunctionShader.get());
     return pdfFunctionShader.release();
@@ skipping 402 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);
 }