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>();
+    
+    auto c0 = sk_make_sp<SkPDFArray>();
+    c0->appendScalar(color1[0]);
+    c0->appendScalar(color1[1]);
+    c0->appendScalar(color1[2]);
+    retval->insertObject("C0", sk_ref_sp(c0.get()));

[hal.canary, 2016/04/29 09:56:24]

     retval->insertObject("C0", c0);

should work.  sk_sp has a copy constructor for that.

     retval->insertObject("C0", std:move(c0));

is even better.

+    
+    auto c1 = sk_make_sp<SkPDFArray>();
+    c1->appendScalar(color2[0]);
+    c1->appendScalar(color2[1]);
+    c1->appendScalar(color2[2]);
+    retval->insertObject("C1", sk_ref_sp(c1.get()));
+    
+    auto domain = sk_make_sp<SkPDFArray>();
+    domain->appendScalar(0);
+    domain->appendScalar(1.0f);
+    retval->insertObject("Domain", sk_ref_sp(domain.get()));
+    
+    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>();
+    
+    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);
+    }
+    
+    // no need for a stitch function if there are only 2 stops.
+    if (info.fColorCount == 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", sk_ref_sp(domain.get()));
+    retval->insertInt("FunctionType", 3);
+    
+    for (int i = 1; i < info.fColorCount; i++) {
+        SkScalar offset = 0;
+        if (functions->size() > 0) {
+            offset = info.fColorOffsets[i-1];
+            if (offset >= 0.99998f) {
+                bounds->appendScalar(1.0f);
+            } else if (offset == 0) {// if a colorstop has offset 0, remove previous stops.
+                encode = sk_make_sp<SkPDFArray>();
+                bounds = sk_make_sp<SkPDFArray>();
+                functions = sk_make_sp<SkPDFArray>();
+            } else {
+                bounds->appendScalar(offset);
+            }
+        }
+        
+        encode->appendScalar(0);
+        encode->appendScalar(1.0f);
+    
+        functions->appendObject(createInterpolationFunction(colorData[i-1], colorData[i]));
+        
+        if (offset >= 0.99998f) { // stop at colorstop that has 100% offset. ignore later ones.
+            break;
+        }
+    }
+    
+    retval->insertObject("Encode", sk_ref_sp(encode.get()));
+    retval->insertObject("Bounds", sk_ref_sp(bounds.get()));
+    retval->insertObject("Functions", sk_ref_sp(functions.get()));
+    
+    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 510 matching lines @@
 }
 
 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];
+    const SkShader::GradientInfo* info = &state.fInfo;
 
-    // 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);
+    bool doStitchFunctions = (state.fType == SkShader::kLinear_GradientType ||
+                                state.fType == SkShader::kRadial_GradientType ||
+                                state.fType == SkShader::kConical_GradientType) &&
+                                info->fTileMode == SkShader::kClamp_TileMode;

[caryclark, 2016/05/04 17:38:26]

It is unfortunate that this leaves the old way of doing things in cases other
than clamp mode. 

We'd like to 'round trip' so that the PDF generated by Skia can be consumed by
PDFium and generate efficient Skia pictures. The non-clamp path can't be turned
back into Skia shaders.

 
     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;
-    }
 
     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", sk_ref_sp(gradientStitchCode(*info).get()));
+        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", sk_ref_sp(extend.get()));
+        
+        auto coords = sk_make_sp<SkPDFArray>();
+        if (state.fType == SkShader::kConical_GradientType) {
+            coords->reserve(6);
+            coords->appendScalar(info->fPoint[0].fX);
+            coords->appendScalar(info->fPoint[0].fY);
+            coords->appendScalar(info->fRadius[0]);
+            
+            coords->appendScalar(info->fPoint[1].fX);
+            coords->appendScalar(info->fPoint[1].fY);
+            coords->appendScalar(info->fRadius[1]);
+        } else if (state.fType == SkShader::kRadial_GradientType) {
+            coords->reserve(6);
+            coords->appendScalar(info->fPoint[0].fX);
+            coords->appendScalar(info->fPoint[0].fY);
+            coords->appendScalar(0);
+            
+            coords->appendScalar(info->fPoint[0].fX);
+            coords->appendScalar(info->fPoint[0].fY);
+            coords->appendScalar(info->fRadius[0]);
+        } else {
+            coords->reserve(4);
+            coords->appendScalar(info->fPoint[0].fX);
+            coords->appendScalar(info->fPoint[0].fY);
+            
+            coords->appendScalar(info->fPoint[1].fX);
+            coords->appendScalar(info->fPoint[1].fY);
+        }
+
+        pdfShader->insertObject("Coords", sk_ref_sp(coords.get()));
+    } 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);
 }