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 "SkPDFTypes.h"
+#include "SkPDFFormXObject.h"
+#include "SkPDFGraphicState.h"
 #include "SkPDFResourceDict.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.
     SkMatrix fCanvasTransform;
     SkMatrix fShaderTransform;
     SkIRect fBBox;
 
     SkBitmap fImage;
     uint32_t fPixelGeneration;
     SkShader::TileMode fImageTileModes[2];
 
-    explicit State(const SkShader& shader, const SkMatrix& canvasTransform,
+    State(const SkShader& shader, const SkMatrix& canvasTransform,
                    const SkIRect& bbox);
+
     bool operator==(const State& b) const;
+
+    SkPDFShader::State* CreateAlphaToLuminosityState() const;
+    SkPDFShader::State* CreateOpaqueState() const;
+
+    bool GradientHasAlpha() const;
+
+private:
+    State(const State& other);
+    State operator=(const State& rhs);
+    void AllocateGradientInfoStorage();
 };
 
 class SkPDFFunctionShader : public SkPDFDict, public SkPDFShader {
 public:
     explicit SkPDFFunctionShader(SkPDFShader::State* state);
     virtual ~SkPDFFunctionShader() {
         if (isValid()) {
             RemoveShader(this);
         }
         fResources.unrefAll();
@@ skipping 10 matching lines @@
 
 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 SkPDFAlphaFunctionShader : public SkPDFStream, public SkPDFShader {
+public:
+    explicit SkPDFAlphaFunctionShader(SkPDFShader::State* state);
+    virtual ~SkPDFAlphaFunctionShader() {
+        if (isValid()) {
+            RemoveShader(this);
+        }
+    }
+
+    virtual bool isValid() {
+        return fColorShader.get() != NULL;
+    }
+
+private:
+    SkAutoTDelete<const SkPDFShader::State> fState;
+
+    SkPDFGraphicState* CreateSMaskGraphicState();
+
+    void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
+                      SkTSet<SkPDFObject*>* newResourceObjects) {
+        fResourceDict->getResources(knownResourceObjects,
+                                    newResourceObjects,
+                                    true);
+    }
+
+    SkAutoTUnref<SkPDFObject> fColorShader;
+    SkAutoTUnref<SkPDFResourceDict> 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; }
 
     void getResources(const SkTSet<SkPDFObject*>& knownResourceObjects,
                       SkTSet<SkPDFObject*>* newResourceObjects) {
         GetResourcesHelper(&fResources.toArray(),
                            knownResourceObjects,
                            newResourceObjects);
     }
 
 private:
     SkTSet<SkPDFObject*> fResources;
     SkAutoTDelete<const SkPDFShader::State> fState;
 };
 
 SkPDFShader::SkPDFShader() {}
 
 // static
-void SkPDFShader::RemoveShader(SkPDFObject* shader) {
-    SkAutoMutexAcquire lock(CanonicalShadersMutex());
-    ShaderCanonicalEntry entry(shader, NULL);
-    int index = CanonicalShaders().find(entry);
-    SkASSERT(index >= 0);
-    CanonicalShaders().removeShuffle(index);
-}
+SkPDFObject* SkPDFShader::GetPDFShaderByState(State* inState) {
+    SkPDFObject* result;
 
-// static
-SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
-                                       const SkMatrix& matrix,
-                                       const SkIRect& surfaceBBox) {
-    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()) {
+            SkPDFAlphaFunctionShader* gradientShader =
+                new SkPDFAlphaFunctionShader(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
+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) {
+    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 SkPDFResourceDict* get_gradient_resource_dict(
+        SkPDFObject* functionShader,
+        SkPDFObject* gState) {
+    SkPDFResourceDict* dict = new SkPDFResourceDict();
+
+    if (functionShader != NULL) {
+        dict->insertResourceAsRef(SkPDFResourceDict::kPattern_ResourceType, 0,
+                                  functionShader);
+    }
+    if (gState != NULL) {
+        dict->insertResourceAsRef(SkPDFResourceDict::kExtGState_ResourceType, 0,
+                                  gState);
+    }
+
+    return dict;
+}
+
+static void populate_tiling_pattern_dict(SkPDFDict* pattern,
+                                      SkRect& bbox, SkPDFDict* resources,
+                                      const SkMatrix& matrix) {
+    pattern->insertName("Type", "Pattern");
+    pattern->insertInt("PatternType", 1);
+    pattern->insertInt("PaintType", 1);
+    pattern->insertInt("TilingType", 1);
+    pattern->insert("BBox", SkPDFUtils::RectToArray(bbox))->unref();
+    pattern->insertScalar("XStep", bbox.width());
+    pattern->insertScalar("YStep", bbox.height());
+    pattern->insert("Resources", resources);
+    if (!matrix.isIdentity()) {
+        pattern->insert("Matrix", SkPDFUtils::MatrixToArray(matrix))->unref();
+    }
+}
+
+/**
+ * Creates a content stream which fills the pattern P0 across bounds.
+ * @param applyGs A graphics state resource index to apply, or <0 if no
+ * graphics state to apply.
+ */
+static SkData* create_pattern_fill_content(int applyGs, SkRect& bounds) {

[vandebo (ex-Chrome), 2013/07/15 18:11:40]

nit: applyGS -> GSIndex

[ducky, 2013/07/15 18:51:28]

Done.

+    SkDynamicMemoryWStream content;
+    if (applyGs >= 0) {
+        SkPDFUtils::ApplyGraphicState(applyGs, &content);
+    }
+    SkPDFUtils::ApplyPattern(0, &content);
+    SkPDFUtils::AppendRectangle(bounds, &content);
+    SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType,
+                          &content);
+
+    return content.copyToData();
+}
+
+/**
+ * Creates a ExtGState with the SMask set to the luminosityShader in
+ * luminosity mode. The shader pattern extends to the bbox.
+ */
+SkPDFGraphicState* SkPDFAlphaFunctionShader::CreateSMaskGraphicState() {
+    SkRect bbox;
+    bbox.set(fState.get()->fBBox);
+
+    SkAutoTUnref<SkPDFObject> luminosityShader(
+            SkPDFShader::GetPDFShaderByState(
+                 fState->CreateAlphaToLuminosityState()));
+
+    SkAutoTUnref<SkData> alphaStream(create_pattern_fill_content(-1, bbox));
+
+    SkAutoTUnref<SkPDFResourceDict>
+        resources(get_gradient_resource_dict(luminosityShader, NULL));
+
+    SkAutoTUnref<SkPDFFormXObject> alphaMask(
+            new SkPDFFormXObject(alphaStream.get(), bbox, resources.get()));
+
+    return SkPDFGraphicState::GetSMaskGraphicState(
+            alphaMask.get(), false,
+            SkPDFGraphicState::kLuminosity_SMaskMode);
+}
+
+SkPDFAlphaFunctionShader::SkPDFAlphaFunctionShader(SkPDFShader::State* state)
+        : fState(state) {
+    SkRect bbox;
+    bbox.set(fState.get()->fBBox);
+
+    fColorShader.reset(
+            SkPDFShader::GetPDFShaderByState(state->CreateOpaqueState()));
+
+    SkAutoTUnref<SkPDFGraphicState> alphaGs(CreateSMaskGraphicState());
+    fResourceDict.reset(
+            get_gradient_resource_dict(fColorShader.get(), alphaGs.get()));
+
+    SkAutoTUnref<SkData> colorStream(
+            create_pattern_fill_content(0, bbox));
+    setData(colorStream.get());
+
+    populate_tiling_pattern_dict(this, bbox, fResourceDict.get(),
+                                 SkMatrix::I());
+}
+
 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 255 matching lines @@
 
             if (tileModes[0] == SkShader::kMirror_TileMode) {
                 bottomMatrix.postScale(-1, 1);
                 bottomMatrix.postTranslate(2 * width, 0);
                 canvas.drawBitmapMatrix(bottom, bottomMatrix);
             }
             patternBBox.fBottom = surfaceBBox.height();
         }
     }
 
-    SkAutoTUnref<SkPDFArray> patternBBoxArray(new SkPDFArray);
-    patternBBoxArray->reserve(4);
-    patternBBoxArray->appendScalar(patternBBox.fLeft);
-    patternBBoxArray->appendScalar(patternBBox.fTop);
-    patternBBoxArray->appendScalar(patternBBox.fRight);
-    patternBBoxArray->appendScalar(patternBBox.fBottom);
-
     // Put the canvas into the pattern stream (fContent).
     SkAutoTUnref<SkData> content(pattern.copyContentToData());
     setData(content.get());
     SkPDFResourceDict* resourceDict = pattern.getResourceDict();
     resourceDict->getResources(fResources, &fResources, false);
 
-    insertName("Type", "Pattern");
-    insertInt("PatternType", 1);
-    insertInt("PaintType", 1);
-    insertInt("TilingType", 1);
-    insert("BBox", patternBBoxArray.get());
-    insertScalar("XStep", patternBBox.width());
-    insertScalar("YStep", patternBBox.height());
-    insert("Resources", resourceDict);
-    insert("Matrix", SkPDFUtils::MatrixToArray(finalMatrix))->unref();
+    populate_tiling_pattern_dict(this, patternBBox,
+                                 pattern.getResourceDict(), finalMatrix);
 
     fState.get()->fImage.unlockPixels();
 }
 
 SkPDFStream* SkPDFFunctionShader::makePSFunction(const SkString& psCode,
                                                  SkPDFArray* domain) {
     SkAutoDataUnref funcData(SkData::NewWithCopy(psCode.c_str(),
                                                  psCode.size()));
     SkPDFStream* result = new SkPDFStream(funcData.get());
     result->insertInt("FunctionType", 4);
@@ skipping 85 matching lines @@
         SkShader::BitmapType bitmapType;
         SkMatrix matrix;
         bitmapType = shader.asABitmap(&fImage, &matrix, fImageTileModes);
         if (bitmapType != SkShader::kDefault_BitmapType) {
             fImage.reset();
             return;
         }
         SkASSERT(matrix.isIdentity());
         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);
+        AllocateGradientInfoStorage();
         shader.asAGradient(&fInfo);
     }
 }
+
+SkPDFShader::State::State(const SkPDFShader::State& other)
+  : fType(other.fType),
+    fCanvasTransform(other.fCanvasTransform),
+    fShaderTransform(other.fShaderTransform),
+    fBBox(other.fBBox)
+{
+    // Only gradients supported for now, since that is all that is used.
+    // If needed, image state copy constructor can be added here later.
+    SkASSERT(fType != SkShader::kNone_GradientType);
+
+    if (fType != SkShader::kNone_GradientType) {
+        fInfo = other.fInfo;
+
+        AllocateGradientInfoStorage();
+        for (int i = 0; i < fInfo.fColorCount; i++) {
+            fInfo.fColors[i] = other.fInfo.fColors[i];
+            fInfo.fColorOffsets[i] = other.fInfo.fColorOffsets[i];
+        }
+    }
+}
+
+/**
+ * Create a copy of this gradient state with alpha assigned to RGB luminousity.
+ * Only valid for gradient states.
+ */
+SkPDFShader::State* SkPDFShader::State::CreateAlphaToLuminosityState() 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 = 0; i < fInfo.fColorCount; i++) {
+        SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
+        if (alpha != opaque) {
+            return true;
+        }
+    }
+    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);
+}