Line data Source code
1 : /*
2 : * Copyright 2011 Google Inc.
3 : *
4 : * Use of this source code is governed by a BSD-style license that can be
5 : * found in the LICENSE file.
6 : */
7 :
8 : #include "SkData.h"
9 : #include "SkPaint.h"
10 : #include "SkPDFCanon.h"
11 : #include "SkPDFFormXObject.h"
12 : #include "SkPDFGraphicState.h"
13 : #include "SkPDFUtils.h"
14 :
15 0 : static const char* as_blend_mode(SkBlendMode mode) {
16 0 : switch (mode) {
17 : case SkBlendMode::kSrcOver:
18 0 : return "Normal";
19 : case SkBlendMode::kMultiply:
20 0 : return "Multiply";
21 : case SkBlendMode::kScreen:
22 0 : return "Screen";
23 : case SkBlendMode::kOverlay:
24 0 : return "Overlay";
25 : case SkBlendMode::kDarken:
26 0 : return "Darken";
27 : case SkBlendMode::kLighten:
28 0 : return "Lighten";
29 : case SkBlendMode::kColorDodge:
30 0 : return "ColorDodge";
31 : case SkBlendMode::kColorBurn:
32 0 : return "ColorBurn";
33 : case SkBlendMode::kHardLight:
34 0 : return "HardLight";
35 : case SkBlendMode::kSoftLight:
36 0 : return "SoftLight";
37 : case SkBlendMode::kDifference:
38 0 : return "Difference";
39 : case SkBlendMode::kExclusion:
40 0 : return "Exclusion";
41 : case SkBlendMode::kHue:
42 0 : return "Hue";
43 : case SkBlendMode::kSaturation:
44 0 : return "Saturation";
45 : case SkBlendMode::kColor:
46 0 : return "Color";
47 : case SkBlendMode::kLuminosity:
48 0 : return "Luminosity";
49 :
50 : // These are handled in SkPDFDevice::setUpContentEntry.
51 : case SkBlendMode::kClear:
52 : case SkBlendMode::kSrc:
53 : case SkBlendMode::kDst:
54 : case SkBlendMode::kDstOver:
55 : case SkBlendMode::kSrcIn:
56 : case SkBlendMode::kDstIn:
57 : case SkBlendMode::kSrcOut:
58 : case SkBlendMode::kDstOut:
59 : case SkBlendMode::kSrcATop:
60 : case SkBlendMode::kDstATop:
61 : case SkBlendMode::kModulate:
62 0 : return "Normal";
63 :
64 : // TODO(vandebo): Figure out if we can support more of these modes.
65 : case SkBlendMode::kXor:
66 : case SkBlendMode::kPlus:
67 0 : return nullptr;
68 : }
69 0 : return nullptr;
70 : }
71 :
72 : // If a SkXfermode is unsupported in PDF, this function returns
73 : // SrcOver, otherwise, it returns that Xfermode as a Mode.
74 0 : static SkBlendMode mode_for_pdf(SkBlendMode mode) {
75 0 : switch (mode) {
76 : case SkBlendMode::kSrcOver:
77 : case SkBlendMode::kMultiply:
78 : case SkBlendMode::kScreen:
79 : case SkBlendMode::kOverlay:
80 : case SkBlendMode::kDarken:
81 : case SkBlendMode::kLighten:
82 : case SkBlendMode::kColorDodge:
83 : case SkBlendMode::kColorBurn:
84 : case SkBlendMode::kHardLight:
85 : case SkBlendMode::kSoftLight:
86 : case SkBlendMode::kDifference:
87 : case SkBlendMode::kExclusion:
88 : case SkBlendMode::kHue:
89 : case SkBlendMode::kSaturation:
90 : case SkBlendMode::kColor:
91 : case SkBlendMode::kLuminosity:
92 : // Mode is suppported and handled by pdf graphics state.
93 0 : return mode;
94 : default:
95 0 : return SkBlendMode::kSrcOver; // Default mode.
96 : }
97 : }
98 :
99 0 : SkPDFGraphicState::SkPDFGraphicState(const SkPaint& p)
100 0 : : fStrokeWidth(p.getStrokeWidth())
101 0 : , fStrokeMiter(p.getStrokeMiter())
102 0 : , fAlpha(p.getAlpha())
103 0 : , fStrokeCap(SkToU8(p.getStrokeCap()))
104 0 : , fStrokeJoin(SkToU8(p.getStrokeJoin()))
105 0 : , fMode(SkToU8((unsigned)mode_for_pdf(p.getBlendMode()))) {}
106 :
107 : // static
108 0 : SkPDFGraphicState* SkPDFGraphicState::GetGraphicStateForPaint(
109 : SkPDFCanon* canon, const SkPaint& paint) {
110 0 : SkASSERT(canon);
111 0 : SkPDFGraphicState key(paint);
112 0 : if (const SkPDFGraphicState* canonGS = canon->findGraphicState(key)) {
113 : // The returned SkPDFGraphicState must be made non-const,
114 : // since the emitObject() interface is non-const. But We
115 : // promise that there is no way to mutate this object from
116 : // here on out.
117 0 : return SkRef(const_cast<SkPDFGraphicState*>(canonGS));
118 : }
119 0 : SkPDFGraphicState* pdfGraphicState = new SkPDFGraphicState(paint);
120 0 : canon->addGraphicState(pdfGraphicState);
121 0 : return pdfGraphicState;
122 : }
123 :
124 0 : sk_sp<SkPDFStream> SkPDFGraphicState::MakeInvertFunction() {
125 : // Acrobat crashes if we use a type 0 function, kpdf crashes if we use
126 : // a type 2 function, so we use a type 4 function.
127 0 : auto domainAndRange = sk_make_sp<SkPDFArray>();
128 0 : domainAndRange->reserve(2);
129 0 : domainAndRange->appendInt(0);
130 0 : domainAndRange->appendInt(1);
131 :
132 : static const char psInvert[] = "{1 exch sub}";
133 : // Do not copy the trailing '\0' into the SkData.
134 : auto invertFunction = sk_make_sp<SkPDFStream>(
135 0 : SkData::MakeWithoutCopy(psInvert, strlen(psInvert)));
136 0 : invertFunction->dict()->insertInt("FunctionType", 4);
137 0 : invertFunction->dict()->insertObject("Domain", domainAndRange);
138 0 : invertFunction->dict()->insertObject("Range", std::move(domainAndRange));
139 0 : return invertFunction;
140 : }
141 :
142 0 : sk_sp<SkPDFDict> SkPDFGraphicState::GetSMaskGraphicState(
143 : sk_sp<SkPDFObject> sMask,
144 : bool invert,
145 : SkPDFSMaskMode sMaskMode,
146 : SkPDFCanon* canon) {
147 : // The practical chances of using the same mask more than once are unlikely
148 : // enough that it's not worth canonicalizing.
149 0 : auto sMaskDict = sk_make_sp<SkPDFDict>("Mask");
150 0 : if (sMaskMode == kAlpha_SMaskMode) {
151 0 : sMaskDict->insertName("S", "Alpha");
152 0 : } else if (sMaskMode == kLuminosity_SMaskMode) {
153 0 : sMaskDict->insertName("S", "Luminosity");
154 : }
155 0 : sMaskDict->insertObjRef("G", std::move(sMask));
156 0 : if (invert) {
157 : // Instead of calling SkPDFGraphicState::MakeInvertFunction,
158 : // let the canon deduplicate this object.
159 0 : sMaskDict->insertObjRef("TR", canon->makeInvertFunction());
160 : }
161 :
162 0 : auto result = sk_make_sp<SkPDFDict>("ExtGState");
163 0 : result->insertObject("SMask", std::move(sMaskDict));
164 0 : return result;
165 : }
166 :
167 0 : sk_sp<SkPDFDict> SkPDFGraphicState::MakeNoSmaskGraphicState() {
168 0 : auto noSMaskGS = sk_make_sp<SkPDFDict>("ExtGState");
169 0 : noSMaskGS->insertName("SMask", "None");
170 0 : return noSMaskGS;
171 : }
172 :
173 0 : void SkPDFGraphicState::emitObject(
174 : SkWStream* stream,
175 : const SkPDFObjNumMap& objNumMap) const {
176 0 : auto dict = sk_make_sp<SkPDFDict>("ExtGState");
177 0 : dict->insertName("Type", "ExtGState");
178 :
179 0 : SkScalar alpha = SkIntToScalar(fAlpha) / 0xFF;
180 0 : dict->insertScalar("CA", alpha);
181 0 : dict->insertScalar("ca", alpha);
182 :
183 0 : SkPaint::Cap strokeCap = (SkPaint::Cap)fStrokeCap;
184 0 : SkPaint::Join strokeJoin = (SkPaint::Join)fStrokeJoin;
185 :
186 : static_assert(SkPaint::kButt_Cap == 0, "paint_cap_mismatch");
187 : static_assert(SkPaint::kRound_Cap == 1, "paint_cap_mismatch");
188 : static_assert(SkPaint::kSquare_Cap == 2, "paint_cap_mismatch");
189 : static_assert(SkPaint::kCapCount == 3, "paint_cap_mismatch");
190 0 : SkASSERT(strokeCap >= 0 && strokeCap <= 2);
191 0 : dict->insertInt("LC", strokeCap);
192 :
193 : static_assert(SkPaint::kMiter_Join == 0, "paint_join_mismatch");
194 : static_assert(SkPaint::kRound_Join == 1, "paint_join_mismatch");
195 : static_assert(SkPaint::kBevel_Join == 2, "paint_join_mismatch");
196 : static_assert(SkPaint::kJoinCount == 3, "paint_join_mismatch");
197 0 : SkASSERT(strokeJoin >= 0 && strokeJoin <= 2);
198 0 : dict->insertInt("LJ", strokeJoin);
199 :
200 0 : dict->insertScalar("LW", fStrokeWidth);
201 0 : dict->insertScalar("ML", fStrokeMiter);
202 0 : dict->insertBool("SA", true); // SA = Auto stroke adjustment.
203 0 : dict->insertName("BM", as_blend_mode((SkBlendMode)fMode));
204 0 : dict->emitObject(stream, objNumMap);
205 0 : }
|
