Implemented transparent gradients

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"
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkPDFCatalog.h"
 #include "SkPDFDevice.h"
+#include "SkPDFFormXObject.h"
+#include "SkPDFGraphicState.h"
 #include "SkPDFTypes.h"
 #include "SkPDFUtils.h"
 #include "SkScalar.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkThread.h"
+#include "SkTSet.h"
 #include "SkTypes.h"
 
 static bool transformBBox(const SkMatrix& matrix, SkRect* bbox) {
     SkMatrix inverse;
     if (!matrix.invert(&inverse)) {
         return false;
     }
     inverse.mapRect(bbox);
     return true;
 }
@@ skipping 359 matching lines @@
     tileModeCode(info.fTileMode, &function);
     gradientFunctionCode(info, &function);
     function.append("}");
     return function;
 }
 
 class SkPDFShader::State {
 public:
     SkShader::GradientType fType;
     SkShader::GradientInfo fInfo;
-    SkAutoFree fColorData;
+    SkAutoFree fColorData;    // this provides storage for arrays in fInfo

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Full sentences please. 

[ducky, 2013/07/03 23:32:09]

Done.

     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
     explicit State(const SkShader& shader, const SkMatrix& canvasTransform,
                    const SkIRect& bbox);
+    State(const State& other);

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Make this private.

[ducky, 2013/07/03 23:32:09]

Done.

+
+    SkPDFShader::State* CreateAlphaToRGBState() const;

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

nit: CreateLuminosityState()?

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

nit: Put these methods after the operator== method.

[ducky, 2013/07/03 23:32:09]

Changed to CreateAlphaToLuminosityState(). I think luminosity by itself can be
confusing, but RGB is too clear either. Though it does become somewhat wordy and
long...

[ducky, 2013/07/03 23:32:09]

Done.

+    SkPDFShader::State* CreateOpaqueState() const;
     bool operator==(const State& b) const;
+
+    bool GradientHasAlpha() const;
 };
 
 class SkPDFFunctionShader : public SkPDFDict, public SkPDFShader {
 public:
     explicit SkPDFFunctionShader(SkPDFShader::State* state);
     virtual ~SkPDFFunctionShader() {
         if (isValid()) {
             RemoveShader(this);
         }
         fResources.unrefAll();
     }
 
     virtual bool isValid() { return fResources.count() > 0; }
 
     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
                       SkTSet<SkPDFObject*>* newResourceObjects) {
         GetResourcesHelper(&fResources,
                            knownResourceObjects,
                            newResourceObjects);
     }
 
+    SkPDFFunctionShader* CreateAlphaToRGBShader();
+
 private:
     static SkPDFObject* RangeObject();
 
     SkTDArray<SkPDFObject*> fResources;
     SkAutoTDelete<const SkPDFShader::State> fState;
 
     SkPDFStream* makePSFunction(const SkString& psCode, SkPDFArray* domain);
 };
 
+/**
+ * A shader for PDF gradients. This encapsulates the function shader
+ * inside a tiling pattern while providing a common pattern interface.
+ * The encapsulation allows the use of a SMask for transparency gradients.
+ */
+class SkPDFGradientShader : public SkPDFStream, public SkPDFShader {
+public:
+    explicit SkPDFGradientShader(SkPDFShader::State* state);
+    virtual ~SkPDFGradientShader() {
+        RemoveShader(this);
+    }
+
+    virtual bool isValid() { return size() > 0; }
+
+private:
+    SkAutoTDelete<const SkPDFShader::State> fState;
+
+    void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
+                      SkTSet<SkPDFObject*>* newResourceObjects) {
+        GetResourcesHelper(&fResources,
+                           knownResourceObjects,
+                           newResourceObjects);
+    }
+    SkTDArray<SkPDFObject*> fResources;
+
+    SkAutoTUnref<SkPDFObject> fColorPattern;
+    SkAutoTUnref<SkPDFGraphicState> fAlphaGs;
+
+    SkAutoTUnref<SkPDFDict> fResourceDict;
+};
+
 class SkPDFImageShader : public SkPDFStream, public SkPDFShader {
 public:
     explicit SkPDFImageShader(SkPDFShader::State* state);
     virtual ~SkPDFImageShader() {
         RemoveShader(this);
         fResources.unrefAll();
     }
 
     virtual bool isValid() { return size() > 0; }
 
@@ skipping 14 matching lines @@
 // static
 void SkPDFShader::RemoveShader(SkPDFObject* shader) {
     SkAutoMutexAcquire lock(CanonicalShadersMutex());
     ShaderCanonicalEntry entry(shader, NULL);
     int index = CanonicalShaders().find(entry);
     SkASSERT(index >= 0);
     CanonicalShaders().removeShuffle(index);
 }
 
 // static
-SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
-                                       const SkMatrix& matrix,
-                                       const SkIRect& surfaceBBox) {
+// This is an internal method. CanonicalShadersMutex() should already be acquired.
+SkPDFObject* SkPDFShader::GetPDFShaderByState(State* inState) {

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Definition order should match declaration order, so you probably need to move
this method around.

[ducky, 2013/07/03 23:32:09]

Done.

[vandebo (ex-Chrome), 2013/07/08 19:02:25]

Not done

     SkPDFObject* result;
-    SkAutoMutexAcquire lock(CanonicalShadersMutex());
-    SkAutoTDelete<State> shaderState(new State(shader, matrix, surfaceBBox));
+
+    SkAutoTDelete<State> shaderState(inState);
     if (shaderState.get()->fType == SkShader::kNone_GradientType &&
             shaderState.get()->fImage.isNull()) {
         // TODO(vandebo) This drops SKComposeShader on the floor.  We could
         // handle compose shader by pulling things up to a layer, drawing with
         // the first shader, applying the xfer mode and drawing again with the
         // second shader, then applying the layer to the original drawing.
         return NULL;
     }
 
     ShaderCanonicalEntry entry(NULL, shaderState.get());
     int index = CanonicalShaders().find(entry);
     if (index >= 0) {
         result = CanonicalShaders()[index].fPDFShader;
         result->ref();
         return result;
     }
 
     bool valid = false;
     // The PDFShader takes ownership of the shaderSate.
     if (shaderState.get()->fType == SkShader::kNone_GradientType) {
         SkPDFImageShader* imageShader =
             new SkPDFImageShader(shaderState.detach());
         valid = imageShader->isValid();
         result = imageShader;
     } else {
-        SkPDFFunctionShader* functionShader =
-            new SkPDFFunctionShader(shaderState.detach());
-        valid = functionShader->isValid();
-        result = functionShader;
+        if (shaderState.get()->GradientHasAlpha()) {
+            SkPDFGradientShader* gradientShader =
+                new SkPDFGradientShader(shaderState.detach());
+            valid = gradientShader->isValid();
+            result = gradientShader;
+        } else {
+            SkPDFFunctionShader* functionShader =
+                new SkPDFFunctionShader(shaderState.detach());
+            valid = functionShader->isValid();
+            result = functionShader;
+        }
     }
     if (!valid) {
         delete result;
         return NULL;
     }
     entry.fPDFShader = result;
     CanonicalShaders().push(entry);
     return result;  // return the reference that came from new.
 }
 
 // static
+SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
+                                       const SkMatrix& matrix,
+                                       const SkIRect& surfaceBBox) {
+    SkAutoMutexAcquire lock(CanonicalShadersMutex());
+    return GetPDFShaderByState(new State(shader, matrix, surfaceBBox));
+}
+
+// static
 SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::CanonicalShaders() {
     // This initialization is only thread safe with gcc.
     static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
     return gCanonicalShaders;
 }
 
 // static
 SkBaseMutex& SkPDFShader::CanonicalShadersMutex() {
     // This initialization is only thread safe with gcc or when
     // POD-style mutex initialization is used.
@@ skipping 13 matching lines @@
         range->appendInt(0);
         range->appendInt(1);
         range->appendInt(0);
         range->appendInt(1);
         range->appendInt(0);
         range->appendInt(1);
     }
     return range;
 }
 
+static SkPDFDict* getGradientResourceDict(
+        SkPDFObject* functionShader,
+        SkPDFObject* gState) {
+    SkPDFDict* dict = new SkPDFDict();
+
+    if (functionShader != NULL) {
+        SkAutoTUnref<SkPDFDict> patterns(new SkPDFDict());
+        patterns->insert("P0", new SkPDFObjRef(functionShader))->unref();
+        dict->insert("Pattern", patterns.get());
+    }
+
+    if (gState != NULL) {
+        SkAutoTUnref<SkPDFDict> extGState(new SkPDFDict());
+        extGState->insert("G0", new SkPDFObjRef(gState))->unref();
+        dict->insert("ExtGState", extGState.get());
+    }
+

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Should this also include a ProcSet entry?

[ducky, 2013/07/03 23:32:09]

Done.

+    return dict;
+}
+
+static void writePatternFillContent(SkWStream* content, SkRect bounds) {
+    // set pattern
+    content->writeText("/Pattern CS /Pattern cs /P0 SCN /P0 scn ");

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

nit: omit extra whitespace.

[ducky, 2013/07/03 23:32:09]

Done.

+    // draw rectangle and fill
+    content->writeScalarAsText(bounds.left());

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

SkPDFUtils::AppendRectangle()
SkPDFUtils::PaintPath()

[ducky, 2013/07/03 23:32:09]

Done.

+    content->writeText(" ");
+    content->writeScalarAsText(bounds.top());
+    content->writeText(" ");
+    content->writeScalarAsText(bounds.right());
+    content->writeText(" ");
+    content->writeScalarAsText(bounds.bottom());
+    content->writeText(" re f");
+}
+
+SkPDFGradientShader::SkPDFGradientShader(SkPDFShader::State* state) : fState(state) {
+    SkRect bbox;
+    bbox.set(fState.get()->fBBox);
+
+    fColorPattern.reset(SkPDFShader::GetPDFShaderByState(
+            state->CreateOpaqueState()));
+    fResources.push(fColorPattern.get());
+
+    // create alpha graphics state, including SMask and alpha luminosity pattern
+    SkAutoTUnref<SkPDFObject>

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

nit indent:
    SkAutoTUnref<SkPDFObject> alphaShader(SkPDFShader::GetPDFShaderByState(
            state->CreateAlphaToRGBState()));

[ducky, 2013/07/03 23:32:09]

Done.

+        alphaShader(SkPDFShader::GetPDFShaderByState(
+                state->CreateAlphaToRGBState()));
+    SkAutoTUnref<SkPDFDict>
+        alphaResources(getGradientResourceDict(alphaShader.get(), NULL));
+    SkTSet<SkPDFObject*> resourcesArray;
+    resourcesArray.add(alphaShader.get());
+
+    SkAutoTDelete<SkDynamicMemoryWStream> alphaContent(new SkDynamicMemoryWStream());
+    writePatternFillContent(alphaContent.get(), bbox);
+    SkAutoTUnref<SkData> alphaData(alphaContent->copyToData());

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

This mess is caused by incomplete conversion of SkStream to SkData from
SkStream.  Can you do a pre-CL that finishes that conversion?

[ducky, 2013/07/03 23:32:09]

Done.

+    SkAutoTUnref<SkMemoryStream> alphaStream(new SkMemoryStream());
+    alphaStream->setData(alphaData.get());
+    SkAutoTUnref<SkPDFFormXObject>
+        alphaMask(new SkPDFFormXObject(alphaStream.get(), alphaResources.get(), resourcesArray, bbox));
+
+    fAlphaGs.reset(SkPDFGraphicState::GetSMaskGraphicState(alphaMask.get(), false, false));

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Not sure, but I think you want to pull this all out to a helper function/method
that take state as an argument and return the smask graphic state as a result.

[ducky, 2013/07/03 23:32:09]

Done.

+    fResources.push(fAlphaGs.get());
+
+    fResourceDict.reset(getGradientResourceDict(fColorPattern.get(), fAlphaGs.get()));
+
+    SkAutoTUnref<SkPDFArray> bboxArray(new SkPDFArray);

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Use rectToArray here as well.

[ducky, 2013/07/03 23:32:09]

Done.

+    bboxArray->reserve(4);
+    bboxArray->appendScalar(bbox.fLeft);
+    bboxArray->appendScalar(bbox.fTop);
+    bboxArray->appendScalar(bbox.fRight);
+    bboxArray->appendScalar(bbox.fBottom);
+
+    SkAutoTDelete<SkDynamicMemoryWStream> colorContent(new SkDynamicMemoryWStream());
+    colorContent->writeText("/G0 gs ");
+    writePatternFillContent(colorContent.get(), bbox);

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Make this method return an SkDyrnamicMemoryWStream and take an option to emit
"/G0 gs" or not.

[ducky, 2013/07/03 23:32:09]

Done.

+    SkAutoTUnref<SkData> colorData(colorContent->copyToData());
+    SkAutoTUnref<SkMemoryStream> colorStream(new SkMemoryStream());
+    colorStream->setData(colorData.get());
+    setData(colorStream.get());
+
+    insertName("Type", "Pattern");

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Most of this can get pulled out and shared with
SkPDFImageShader::SkPDFImageShader()

[ducky, 2013/07/03 23:32:09]

Done.

+    insertInt("PatternType", 1);
+    insertInt("PaintType", 1);
+    insertInt("TilingType", 1);
+    insert("BBox", bboxArray.get());
+    insertScalar("XStep", bbox.width());
+    insertScalar("YStep", bbox.height());
+    insert("Resources", fResourceDict.get());
+}
+
 SkPDFFunctionShader::SkPDFFunctionShader(SkPDFShader::State* state)
         : SkPDFDict("Pattern"),
           fState(state) {
     SkString (*codeFunction)(const SkShader::GradientInfo& info) = NULL;
     SkPoint transformPoints[2];
 
     // Depending on the type of the gradient, we want to transform the
     // coordinate space in different ways.
     const SkShader::GradientInfo* info = &fState.get()->fInfo;
     transformPoints[0] = info->fPoint[0];
@@ skipping 86 matching lines @@
 
     SkPDFStream* function = makePSFunction(functionCode, domain.get());
     pdfShader->insert("Function", new SkPDFObjRef(function))->unref();
     fResources.push(function);  // Pass ownership to resource list.
 
     insertInt("PatternType", 2);
     insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
     insert("Shading", pdfShader.get());
 }
 
+/**
+ * Creates a copy of this gradient PDF shader, with the alpha channel
+ * mapped to RGB luminosity. Intended to be used as a SMask for gradients
+ * with transparency.
+ */
+SkPDFFunctionShader* SkPDFFunctionShader::CreateAlphaToRGBShader() {

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

This isn't used, remove.

[ducky, 2013/07/03 23:32:09]

D'oh.

+    // copy the current state, allocating new storage
+    return new SkPDFFunctionShader(fState.get()->CreateAlphaToRGBState());
+}
+
 SkPDFImageShader::SkPDFImageShader(SkPDFShader::State* state) : fState(state) {
     fState.get()->fImage.lockPixels();
 
     SkMatrix finalMatrix = fState.get()->fCanvasTransform;

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Do you not need to do this stuff for the gradient shader?

[ducky, 2013/07/03 23:32:09]

Matrix transforms are handled in the color and alpha patterns. From an overall
code point of view, it means that the State copy constructor can be cleaner, and
I don't need to (possibly unintuitively) clear the transform matrices when
creating an luminosity / opaque state.

I'm also assuming that in the rendere, some kind of matrix is applied for every
draw operation, so having the identity in the alpha and color patterns probably
won't be less efficient than having it here. Not that it's significant at all..

     finalMatrix.preConcat(fState.get()->fShaderTransform);
     SkRect surfaceBBox;
     surfaceBBox.set(fState.get()->fBBox);
     if (!transformBBox(finalMatrix, &surfaceBBox)) {
         return;
     }
 
     SkMatrix unflip;
     unflip.setTranslate(0, SkScalarRoundToScalar(surfaceBBox.height()));
     unflip.preScale(SK_Scalar1, -SK_Scalar1);
@@ skipping 279 matching lines @@
         fPixelGeneration = fImage.getGenerationID();
     } else {
         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);
         shader.asAGradient(&fInfo);
     }
 }
+
+SkPDFShader::State::State(const SkPDFShader::State& other)
+  : fType(other.fType),
+    fCanvasTransform(other.fCanvasTransform),
+    fShaderTransform(other.fShaderTransform),
+    fBBox(other.fBBox)

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Also need to copy over fImageTileModes

[ducky, 2013/07/03 23:32:09]

That seems to be for image shaders only, and that isn't handled currently. See
SkPDFShader::State::operator==, where fImageTileModes is only compared when
fType == SkShader::kNone_GradientType

+{
+    if (fType != SkShader::kNone_GradientType) {
+        fInfo = other.fInfo;
+
+        // allocate new storage to prevent pointer aliasing

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

nit: comment unnecessary. 

[ducky, 2013/07/03 23:32:09]

I would actually say that this piece of code is pretty confusing and its intent
isn't obvious, but it's a moot point since breaking it out into a new function
implicitly adds a comment now.

+        fColorData.set(sk_malloc_throw(

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

All this allocation is the same as the other constructor, but it into a shared
method.

[ducky, 2013/07/03 23:32:09]

Done.

+                   fInfo.fColorCount * (sizeof(SkColor) + sizeof(SkScalar))));
+        fInfo.fColors = reinterpret_cast<SkColor*>(fColorData.get());
+        fInfo.fColorOffsets =
+                        reinterpret_cast<SkScalar*>(fInfo.fColors + fInfo.fColorCount);
+        for (int i = 0; i < fInfo.fColorCount; i++) {
+            fInfo.fColors[i] = other.fInfo.fColors[i];
+            fInfo.fColorOffsets[i] = other.fInfo.fColorOffsets[i];
+        }
+    } else {
+        // if needed, image state copy constructor can be added here later...
+        // but only gradients supported for now
+        SkASSERT(fType != SkShader::kNone_GradientType);

[vandebo (ex-Chrome), 2013/07/03 17:07:01]

Put this after line 1126

[ducky, 2013/07/03 23:32:09]

Done.

+    }
+}
+
+/**
+ * Create a copy of this gradient state with alpha assigned to RGB luminousity.
+ * Only valid for gradient states!
+ */
+SkPDFShader::State* SkPDFShader::State::CreateAlphaToRGBState() const {
+    SkASSERT(fType != SkShader::kNone_GradientType);
+
+    SkPDFShader::State* newState = new SkPDFShader::State(*this);
+
+    for (int i = 0; i < fInfo.fColorCount; i++) {
+        SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
+        newState->fInfo.fColors[i] = SkColorSetARGB(255, alpha, alpha, alpha);
+    }
+
+    return newState;
+}
+
+/**
+ * Create a copy of this gradient state with alpha set to fully opaque
+ * Only valid for gradient states!
+ */
+SkPDFShader::State* SkPDFShader::State::CreateOpaqueState() const {
+    SkASSERT(fType != SkShader::kNone_GradientType);
+
+    SkPDFShader::State* newState = new SkPDFShader::State(*this);
+    SkAlpha opaque = SkColorGetA(SK_ColorBLACK);
+    for (int i = 0; i < fInfo.fColorCount; i++) {
+        newState->fInfo.fColors[i] = SkColorSetA(fInfo.fColors[i], opaque);
+    }
+
+    return newState;
+}
+
+/**
+ * Returns true if state is a gradient and the gradient has alpha.
+ */
+bool SkPDFShader::State::GradientHasAlpha() const {
+    if (fType == SkShader::kNone_GradientType) {
+        return false;
+    }
+
+    SkAlpha opaque = SkColorGetA(SK_ColorBLACK);
+    for (int i = 1; i < fInfo.fColorCount; i++) {
+        SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
+        if (alpha != opaque) {
+            return true;
+        }
+    }
+    return false;
+}