Implemented transparent gradients
R=vandebo@chromium.org, edisonn@google.com
Author: richardlin@chromium.org
Review URL: https://chromiumcodereview.appspot.com/18585002
git-svn-id: http://skia.googlecode.com/svn/trunk@10297 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/pdf/SkPDFShader.cpp b/src/pdf/SkPDFShader.cpp
index ef41c01..9394f1b 100644
--- a/src/pdf/SkPDFShader.cpp
+++ b/src/pdf/SkPDFShader.cpp
@@ -13,13 +13,15 @@
#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) {
@@ -399,7 +401,7 @@
public:
SkShader::GradientType fType;
SkShader::GradientInfo fInfo;
- SkAutoFree fColorData;
+ SkAutoFree fColorData; // This provides storage for arrays in fInfo.
SkMatrix fCanvasTransform;
SkMatrix fShaderTransform;
SkIRect fBBox;
@@ -408,9 +410,20 @@
uint32_t fPixelGeneration;
SkShader::TileMode fImageTileModes[2];
- explicit State(const SkShader& shader, const SkMatrix& canvasTransform,
- const SkIRect& bbox);
+ 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 {
@@ -441,6 +454,40 @@
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->getReferencedResources(knownResourceObjects,
+ newResourceObjects,
+ true);
+ }
+
+ SkAutoTUnref<SkPDFObject> fColorShader;
+ SkAutoTUnref<SkPDFResourceDict> fResourceDict;
+};
+
class SkPDFImageShader : public SkPDFStream, public SkPDFShader {
public:
explicit SkPDFImageShader(SkPDFShader::State* state);
@@ -468,21 +515,10 @@
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);
-}
-
-// static
-SkPDFObject* SkPDFShader::GetPDFShader(const SkShader& shader,
- const SkMatrix& matrix,
- const SkIRect& surfaceBBox) {
+SkPDFObject* SkPDFShader::GetPDFShaderByState(State* inState) {
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
@@ -508,10 +544,17 @@
valid = imageShader->isValid();
result = imageShader;
} else {
- SkPDFFunctionShader* functionShader =
- new SkPDFFunctionShader(shaderState.detach());
- valid = functionShader->isValid();
- result = functionShader;
+ if (shaderState.get()->GradientHasAlpha()) {
+ SkPDFAlphaFunctionShader* gradientShader =
+ SkNEW_ARGS(SkPDFAlphaFunctionShader, (shaderState.detach()));
+ valid = gradientShader->isValid();
+ result = gradientShader;
+ } else {
+ SkPDFFunctionShader* functionShader =
+ SkNEW_ARGS(SkPDFFunctionShader, (shaderState.detach()));
+ valid = functionShader->isValid();
+ result = functionShader;
+ }
}
if (!valid) {
delete result;
@@ -523,6 +566,24 @@
}
// 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(
+ SkNEW_ARGS(State, (shader, matrix, surfaceBBox)));
+}
+
+// static
SkTDArray<SkPDFShader::ShaderCanonicalEntry>& SkPDFShader::CanonicalShaders() {
// This initialization is only thread safe with gcc.
static SkTDArray<ShaderCanonicalEntry> gCanonicalShaders;
@@ -556,6 +617,108 @@
return range;
}
+static SkPDFResourceDict* get_gradient_resource_dict(
+ SkPDFObject* functionShader,
+ SkPDFObject* gState) {
+ SkPDFResourceDict* dict = new SkPDFResourceDict();
+
+ if (functionShader != NULL) {
+ dict->insertResourceAsReference(
+ SkPDFResourceDict::kPattern_ResourceType, 0, functionShader);
+ }
+ if (gState != NULL) {
+ dict->insertResourceAsReference(
+ SkPDFResourceDict::kExtGState_ResourceType, 0, gState);
+ }
+
+ return dict;
+}
+
+static void populate_tiling_pattern_dict(SkPDFDict* pattern,
+ SkRect& bbox, SkPDFDict* resources,
+ const SkMatrix& matrix) {
+ const int kTiling_PatternType = 1;
+ const int kColoredTilingPattern_PaintType = 1;
+ const int kConstantSpacing_TilingType = 1;
+
+ pattern->insertName("Type", "Pattern");
+ pattern->insertInt("PatternType", kTiling_PatternType);
+ pattern->insertInt("PaintType", kColoredTilingPattern_PaintType);
+ pattern->insertInt("TilingType", kConstantSpacing_TilingType);
+ 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 gsIndex A graphics state resource index to apply, or <0 if no
+ * graphics state to apply.
+ */
+static SkStream* create_pattern_fill_content(int gsIndex, SkRect& bounds) {
+ SkDynamicMemoryWStream content;
+ if (gsIndex >= 0) {
+ SkPDFUtils::ApplyGraphicState(gsIndex, &content);
+ }
+ SkPDFUtils::ApplyPattern(0, &content);
+ SkPDFUtils::AppendRectangle(bounds, &content);
+ SkPDFUtils::PaintPath(SkPaint::kFill_Style, SkPath::kEvenOdd_FillType,
+ &content);
+
+ return content.detachAsStream();
+}
+
+/**
+ * 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<SkStream> 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()));
+
+ // Create resource dict with alpha graphics state as G0 and
+ // pattern shader as P0, then write content stream.
+ SkAutoTUnref<SkPDFGraphicState> alphaGs(CreateSMaskGraphicState());
+ fResourceDict.reset(
+ get_gradient_resource_dict(fColorShader.get(), alphaGs.get()));
+
+ SkAutoTUnref<SkStream> 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) {
@@ -831,28 +994,14 @@
}
}
- 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<SkStream> content(pattern.content());
setData(content.get());
SkPDFResourceDict* resourceDict = pattern.getResourceDict();
resourceDict->getReferencedResources(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();
}
@@ -958,11 +1107,86 @@
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);
+ for (int i = 0; i < fInfo.fColorCount; i++) {
+ newState->fInfo.fColors[i] = SkColorSetA(fInfo.fColors[i],
+ SK_AlphaOPAQUE);
+ }
+
+ 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;
+ }
+
+ for (int i = 0; i < fInfo.fColorCount; i++) {
+ SkAlpha alpha = SkColorGetA(fInfo.fColors[i]);
+ if (alpha != SK_AlphaOPAQUE) {
+ 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);
+}