1 /*
2 * Copyright 2006 The Android Open Source Project
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 "include/core/SkPaint.h"
9
10 #include "include/core/SkData.h"
11 #include "include/core/SkGraphics.h"
12 #include "include/core/SkImageFilter.h"
13 #include "include/core/SkMaskFilter.h"
14 #include "include/core/SkPathEffect.h"
15 #include "include/core/SkScalar.h"
16 #include "include/core/SkShader.h"
17 #include "include/core/SkStrokeRec.h"
18 #include "include/core/SkTypeface.h"
19 #include "include/private/SkMutex.h"
20 #include "include/private/SkTo.h"
21 #include "src/core/SkBlenderBase.h"
22 #include "src/core/SkColorFilterBase.h"
23 #include "src/core/SkColorSpacePriv.h"
24 #include "src/core/SkColorSpaceXformSteps.h"
25 #include "src/core/SkDraw.h"
26 #include "src/core/SkMaskGamma.h"
27 #include "src/core/SkOpts.h"
28 #include "src/core/SkPaintDefaults.h"
29 #include "src/core/SkPaintPriv.h"
30 #include "src/core/SkPathEffectBase.h"
31 #include "src/core/SkReadBuffer.h"
32 #include "src/core/SkSafeRange.h"
33 #include "src/core/SkStringUtils.h"
34 #include "src/core/SkStroke.h"
35 #include "src/core/SkSurfacePriv.h"
36 #include "src/core/SkTLazy.h"
37 #include "src/core/SkWriteBuffer.h"
38 #include "src/shaders/SkShaderBase.h"
39
40 // define this to get a printf for out-of-range parameter in setters
41 // e.g. setTextSize(-1)
42 //#define SK_REPORT_API_RANGE_CHECK
43
44
SkPaint()45 SkPaint::SkPaint()
46 : fColor4f{0, 0, 0, 1} // opaque black
47 , fWidth{0}
48 , fMiterLimit{SkPaintDefaults_MiterLimit}
49 , fBitfields{(unsigned)false, // fAntiAlias
50 (unsigned)false, // fDither
51 (unsigned)SkPaint::kDefault_Cap, // fCapType
52 (unsigned)SkPaint::kDefault_Join, // fJoinType
53 (unsigned)SkPaint::kFill_Style, // fStyle
54 0} // fPadding
55 {
56 static_assert(sizeof(fBitfields) == sizeof(fBitfieldsUInt), "");
57 }
58
SkPaint(const SkColor4f & color,SkColorSpace * colorSpace)59 SkPaint::SkPaint(const SkColor4f& color, SkColorSpace* colorSpace) : SkPaint() {
60 this->setColor(color, colorSpace);
61 }
62
63 SkPaint::SkPaint(const SkPaint& src) = default;
64
65 SkPaint::SkPaint(SkPaint&& src) = default;
66
67 SkPaint::~SkPaint() = default;
68
69 SkPaint& SkPaint::operator=(const SkPaint& src) = default;
70
71 SkPaint& SkPaint::operator=(SkPaint&& src) = default;
72
operator ==(const SkPaint & a,const SkPaint & b)73 bool operator==(const SkPaint& a, const SkPaint& b) {
74 #define EQUAL(field) (a.field == b.field)
75 return EQUAL(fPathEffect)
76 && EQUAL(fShader)
77 && EQUAL(fMaskFilter)
78 && EQUAL(fColorFilter)
79 && EQUAL(fBlender)
80 && EQUAL(fImageFilter)
81 && EQUAL(fColor4f)
82 && EQUAL(fWidth)
83 && EQUAL(fMiterLimit)
84 && EQUAL(fBitfieldsUInt)
85 ;
86 #undef EQUAL
87 }
88
89 #define DEFINE_FIELD_REF(type) \
90 sk_sp<Sk##type> SkPaint::ref##type() const { return f##type; }
91 DEFINE_FIELD_REF(ColorFilter)
DEFINE_FIELD_REF(Blender)92 DEFINE_FIELD_REF(Blender)
93 DEFINE_FIELD_REF(ImageFilter)
94 DEFINE_FIELD_REF(MaskFilter)
95 DEFINE_FIELD_REF(PathEffect)
96 DEFINE_FIELD_REF(Shader)
97 #undef DEFINE_FIELD_REF
98
99 #define DEFINE_FIELD_SET(Field) \
100 void SkPaint::set##Field(sk_sp<Sk##Field> f) { f##Field = std::move(f); }
101 DEFINE_FIELD_SET(ColorFilter)
102 DEFINE_FIELD_SET(ImageFilter)
103 DEFINE_FIELD_SET(MaskFilter)
104 DEFINE_FIELD_SET(PathEffect)
105 DEFINE_FIELD_SET(Shader)
106 #undef DEFINE_FIELD_SET
107
108 ///////////////////////////////////////////////////////////////////////////////
109
110 void SkPaint::reset() { *this = SkPaint(); }
111
setStyle(Style style)112 void SkPaint::setStyle(Style style) {
113 if ((unsigned)style < kStyleCount) {
114 fBitfields.fStyle = style;
115 } else {
116 #ifdef SK_REPORT_API_RANGE_CHECK
117 SkDebugf("SkPaint::setStyle(%d) out of range\n", style);
118 #endif
119 }
120 }
121
setStroke(bool isStroke)122 void SkPaint::setStroke(bool isStroke) {
123 fBitfields.fStyle = isStroke ? kStroke_Style : kFill_Style;
124 }
125
setColor(SkColor color)126 void SkPaint::setColor(SkColor color) {
127 fColor4f = SkColor4f::FromColor(color);
128 }
129
setColor(const SkColor4f & color,SkColorSpace * colorSpace)130 void SkPaint::setColor(const SkColor4f& color, SkColorSpace* colorSpace) {
131 SkColorSpaceXformSteps steps{colorSpace, kUnpremul_SkAlphaType,
132 sk_srgb_singleton(), kUnpremul_SkAlphaType};
133 fColor4f = {color.fR, color.fG, color.fB, SkTPin(color.fA, 0.0f, 1.0f)};
134 steps.apply(fColor4f.vec());
135 }
136
setAlphaf(float a)137 void SkPaint::setAlphaf(float a) {
138 fColor4f.fA = SkTPin(a, 0.0f, 1.0f);
139 }
140
setARGB(U8CPU a,U8CPU r,U8CPU g,U8CPU b)141 void SkPaint::setARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
142 this->setColor(SkColorSetARGB(a, r, g, b));
143 }
144
asBlendMode() const145 skstd::optional<SkBlendMode> SkPaint::asBlendMode() const {
146 return fBlender ? as_BB(fBlender)->asBlendMode()
147 : SkBlendMode::kSrcOver;
148 }
149
getBlendMode_or(SkBlendMode defaultMode) const150 SkBlendMode SkPaint::getBlendMode_or(SkBlendMode defaultMode) const {
151 return this->asBlendMode().value_or(defaultMode);
152 }
153
isSrcOver() const154 bool SkPaint::isSrcOver() const {
155 return !fBlender || as_BB(fBlender)->asBlendMode() == SkBlendMode::kSrcOver;
156 }
157
setBlendMode(SkBlendMode mode)158 void SkPaint::setBlendMode(SkBlendMode mode) {
159 this->setBlender(mode == SkBlendMode::kSrcOver ? nullptr : SkBlender::Mode(mode));
160 }
161
setBlender(sk_sp<SkBlender> blender)162 void SkPaint::setBlender(sk_sp<SkBlender> blender) {
163 fBlender = std::move(blender);
164 }
165
setStrokeWidth(SkScalar width)166 void SkPaint::setStrokeWidth(SkScalar width) {
167 if (width >= 0) {
168 fWidth = width;
169 } else {
170 #ifdef SK_REPORT_API_RANGE_CHECK
171 SkDebugf("SkPaint::setStrokeWidth() called with negative value\n");
172 #endif
173 }
174 }
175
setStrokeMiter(SkScalar limit)176 void SkPaint::setStrokeMiter(SkScalar limit) {
177 if (limit >= 0) {
178 fMiterLimit = limit;
179 } else {
180 #ifdef SK_REPORT_API_RANGE_CHECK
181 SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");
182 #endif
183 }
184 }
185
setStrokeCap(Cap ct)186 void SkPaint::setStrokeCap(Cap ct) {
187 if ((unsigned)ct < kCapCount) {
188 fBitfields.fCapType = SkToU8(ct);
189 } else {
190 #ifdef SK_REPORT_API_RANGE_CHECK
191 SkDebugf("SkPaint::setStrokeCap(%d) out of range\n", ct);
192 #endif
193 }
194 }
195
setStrokeJoin(Join jt)196 void SkPaint::setStrokeJoin(Join jt) {
197 if ((unsigned)jt < kJoinCount) {
198 fBitfields.fJoinType = SkToU8(jt);
199 } else {
200 #ifdef SK_REPORT_API_RANGE_CHECK
201 SkDebugf("SkPaint::setStrokeJoin(%d) out of range\n", jt);
202 #endif
203 }
204 }
205
206 ///////////////////////////////////////////////////////////////////////////////
207
208 #include "include/core/SkStream.h"
209
210 #ifdef SK_DEBUG
ASSERT_FITS_IN(uint32_t value,int bitCount)211 static void ASSERT_FITS_IN(uint32_t value, int bitCount) {
212 SkASSERT(bitCount > 0 && bitCount <= 32);
213 uint32_t mask = ~0U;
214 mask >>= (32 - bitCount);
215 SkASSERT(0 == (value & ~mask));
216 }
217 #else
218 #define ASSERT_FITS_IN(value, bitcount)
219 #endif
220
221 enum FlatFlags {
222 kHasTypeface_FlatFlag = 0x1,
223 kHasEffects_FlatFlag = 0x2,
224
225 kFlatFlagMask = 0x3,
226 };
227
228 // SkPaint originally defined flags, some of which now apply to SkFont. These are renames
229 // of those flags, split into categories depending on which objects they (now) apply to.
230
shift_bits(T value,unsigned shift,unsigned bits)231 template <typename T> uint32_t shift_bits(T value, unsigned shift, unsigned bits) {
232 SkASSERT(shift + bits <= 32);
233 uint32_t v = static_cast<uint32_t>(value);
234 ASSERT_FITS_IN(v, bits);
235 return v << shift;
236 }
237
238 constexpr uint8_t CUSTOM_BLEND_MODE_SENTINEL = 0xFF;
239
240 /* Packing the paint
241 flags : 8 // 2...
242 blend : 8 // 30+
243 cap : 2 // 3
244 join : 2 // 3
245 style : 2 // 3
246 filter: 2 // 4
247 flat : 8 // 1...
248 total : 32
249 */
pack_v68(const SkPaint & paint,unsigned flatFlags)250 static uint32_t pack_v68(const SkPaint& paint, unsigned flatFlags) {
251 uint32_t packed = 0;
252 const auto bm = paint.asBlendMode();
253 const unsigned mode = bm ? static_cast<unsigned>(bm.value())
254 : CUSTOM_BLEND_MODE_SENTINEL;
255
256 packed |= shift_bits(((unsigned)paint.isDither() << 1) |
257 (unsigned)paint.isAntiAlias(), 0, 8);
258 packed |= shift_bits(mode, 8, 8);
259 packed |= shift_bits(paint.getStrokeCap(), 16, 2);
260 packed |= shift_bits(paint.getStrokeJoin(), 18, 2);
261 packed |= shift_bits(paint.getStyle(), 20, 2);
262 packed |= shift_bits(0, 22, 2); // was filterquality
263 packed |= shift_bits(flatFlags, 24, 8);
264 return packed;
265 }
266
unpack_v68(SkPaint * paint,uint32_t packed,SkSafeRange & safe)267 static uint32_t unpack_v68(SkPaint* paint, uint32_t packed, SkSafeRange& safe) {
268 paint->setAntiAlias((packed & 1) != 0);
269 paint->setDither((packed & 2) != 0);
270 packed >>= 8;
271 {
272 unsigned mode = packed & 0xFF;
273 if (mode != CUSTOM_BLEND_MODE_SENTINEL) { // sentinel for custom blender
274 paint->setBlendMode(safe.checkLE(mode, SkBlendMode::kLastMode));
275 }
276 // else we will unflatten the custom blender
277 }
278 packed >>= 8;
279 paint->setStrokeCap(safe.checkLE(packed & 0x3, SkPaint::kLast_Cap));
280 packed >>= 2;
281 paint->setStrokeJoin(safe.checkLE(packed & 0x3, SkPaint::kLast_Join));
282 packed >>= 2;
283 paint->setStyle(safe.checkLE(packed & 0x3, SkPaint::kStrokeAndFill_Style));
284 packed >>= 2;
285 // skip the (now ignored) filterquality bits
286 packed >>= 2;
287
288 return packed;
289 }
290
291 /* To save space/time, we analyze the paint, and write a truncated version of
292 it if there are not tricky elements like shaders, etc.
293 */
Flatten(const SkPaint & paint,SkWriteBuffer & buffer)294 void SkPaintPriv::Flatten(const SkPaint& paint, SkWriteBuffer& buffer) {
295 uint8_t flatFlags = 0;
296
297 if (paint.getPathEffect() ||
298 paint.getShader() ||
299 paint.getMaskFilter() ||
300 paint.getColorFilter() ||
301 paint.getImageFilter() ||
302 !paint.asBlendMode()) {
303 flatFlags |= kHasEffects_FlatFlag;
304 }
305
306 buffer.writeScalar(paint.getStrokeWidth());
307 buffer.writeScalar(paint.getStrokeMiter());
308 buffer.writeColor4f(paint.getColor4f());
309
310 buffer.write32(pack_v68(paint, flatFlags));
311
312 if (flatFlags & kHasEffects_FlatFlag) {
313 buffer.writeFlattenable(paint.getPathEffect());
314 buffer.writeFlattenable(paint.getShader());
315 buffer.writeFlattenable(paint.getMaskFilter());
316 buffer.writeFlattenable(paint.getColorFilter());
317 buffer.writeFlattenable(paint.getImageFilter());
318 buffer.writeFlattenable(paint.getBlender());
319 }
320 }
321
Unflatten(SkReadBuffer & buffer)322 SkPaint SkPaintPriv::Unflatten(SkReadBuffer& buffer) {
323 SkPaint paint;
324
325 paint.setStrokeWidth(buffer.readScalar());
326 paint.setStrokeMiter(buffer.readScalar());
327 {
328 SkColor4f color;
329 buffer.readColor4f(&color);
330 paint.setColor(color, sk_srgb_singleton());
331 }
332
333 SkSafeRange safe;
334 unsigned flatFlags = unpack_v68(&paint, buffer.readUInt(), safe);
335
336 if (!(flatFlags & kHasEffects_FlatFlag)) {
337 // This is a simple SkPaint without any effects, so clear all the effect-related fields.
338 paint.setPathEffect(nullptr);
339 paint.setShader(nullptr);
340 paint.setMaskFilter(nullptr);
341 paint.setColorFilter(nullptr);
342 paint.setImageFilter(nullptr);
343 } else if (buffer.isVersionLT(SkPicturePriv::kSkBlenderInSkPaint)) {
344 // This paint predates the introduction of user blend functions (via SkBlender).
345 paint.setPathEffect(buffer.readPathEffect());
346 paint.setShader(buffer.readShader());
347 paint.setMaskFilter(buffer.readMaskFilter());
348 paint.setColorFilter(buffer.readColorFilter());
349 (void)buffer.read32(); // was drawLooper (now deprecated)
350 paint.setImageFilter(buffer.readImageFilter());
351 } else {
352 paint.setPathEffect(buffer.readPathEffect());
353 paint.setShader(buffer.readShader());
354 paint.setMaskFilter(buffer.readMaskFilter());
355 paint.setColorFilter(buffer.readColorFilter());
356 paint.setImageFilter(buffer.readImageFilter());
357 paint.setBlender(buffer.readBlender());
358 }
359
360 if (!buffer.validate(safe.ok())) {
361 paint.reset();
362 }
363 return paint;
364 }
365
366 ///////////////////////////////////////////////////////////////////////////////
367
getFillPath(const SkPath & src,SkPath * dst,const SkRect * cullRect,SkScalar resScale) const368 bool SkPaint::getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect,
369 SkScalar resScale) const {
370 return this->getFillPath(src, dst, cullRect, SkMatrix::Scale(resScale, resScale));
371 }
372
getFillPath(const SkPath & src,SkPath * dst,const SkRect * cullRect,const SkMatrix & ctm) const373 bool SkPaint::getFillPath(const SkPath& src, SkPath* dst, const SkRect* cullRect,
374 const SkMatrix& ctm) const {
375 if (!src.isFinite()) {
376 dst->reset();
377 return false;
378 }
379
380 const SkScalar resScale = SkPaintPriv::ComputeResScaleForStroking(ctm);
381 SkStrokeRec rec(*this, resScale);
382
383 #if defined(SK_BUILD_FOR_FUZZER)
384 // Prevent lines with small widths from timing out.
385 if (rec.getStyle() == SkStrokeRec::Style::kStroke_Style && rec.getWidth() < 0.001) {
386 return false;
387 }
388 #endif
389
390 const SkPath* srcPtr = &src;
391 SkPath tmpPath;
392
393 if (fPathEffect && fPathEffect->filterPath(&tmpPath, src, &rec, cullRect, ctm)) {
394 srcPtr = &tmpPath;
395 }
396
397 if (!rec.applyToPath(dst, *srcPtr)) {
398 if (srcPtr == &tmpPath) {
399 // If path's were copy-on-write, this trick would not be needed.
400 // As it is, we want to save making a deep-copy from tmpPath -> dst
401 // since we know we're just going to delete tmpPath when we return,
402 // so the swap saves that copy.
403 dst->swap(tmpPath);
404 } else {
405 *dst = *srcPtr;
406 }
407 }
408
409 if (!dst->isFinite()) {
410 dst->reset();
411 return false;
412 }
413 return !rec.isHairlineStyle();
414 }
415
canComputeFastBounds() const416 bool SkPaint::canComputeFastBounds() const {
417 if (this->getImageFilter() && !this->getImageFilter()->canComputeFastBounds()) {
418 return false;
419 }
420 // Pass nullptr for the bounds to determine if they can be computed
421 if (this->getPathEffect() &&
422 !as_PEB(this->getPathEffect())->computeFastBounds(nullptr)) {
423 return false;
424 }
425 return true;
426 }
427
doComputeFastBounds(const SkRect & origSrc,SkRect * storage,Style style) const428 const SkRect& SkPaint::doComputeFastBounds(const SkRect& origSrc,
429 SkRect* storage,
430 Style style) const {
431 SkASSERT(storage);
432
433 const SkRect* src = &origSrc;
434
435 SkRect tmpSrc;
436 if (this->getPathEffect()) {
437 tmpSrc = origSrc;
438 SkAssertResult(as_PEB(this->getPathEffect())->computeFastBounds(&tmpSrc));
439 src = &tmpSrc;
440 }
441
442 SkScalar radius = SkStrokeRec::GetInflationRadius(*this, style);
443 *storage = src->makeOutset(radius, radius);
444
445 if (this->getMaskFilter()) {
446 as_MFB(this->getMaskFilter())->computeFastBounds(*storage, storage);
447 }
448
449 if (this->getImageFilter()) {
450 *storage = this->getImageFilter()->computeFastBounds(*storage);
451 }
452
453 return *storage;
454 }
455
456 ///////////////////////////////////////////////////////////////////////////////
457
458 // return true if the filter exists, and may affect alpha
affects_alpha(const SkColorFilter * cf)459 static bool affects_alpha(const SkColorFilter* cf) {
460 return cf && !as_CFB(cf)->isAlphaUnchanged();
461 }
462
463 // return true if the filter exists, and may affect alpha
affects_alpha(const SkImageFilter * imf)464 static bool affects_alpha(const SkImageFilter* imf) {
465 // TODO: check if we should allow imagefilters to broadcast that they don't affect alpha
466 // ala colorfilters
467 return imf != nullptr;
468 }
469
nothingToDraw() const470 bool SkPaint::nothingToDraw() const {
471 auto bm = this->asBlendMode();
472 if (!bm) {
473 return false;
474 }
475 switch (bm.value()) {
476 case SkBlendMode::kSrcOver:
477 case SkBlendMode::kSrcATop:
478 case SkBlendMode::kDstOut:
479 case SkBlendMode::kDstOver:
480 case SkBlendMode::kPlus:
481 if (0 == this->getAlpha()) {
482 return !affects_alpha(fColorFilter.get()) && !affects_alpha(fImageFilter.get());
483 }
484 break;
485 case SkBlendMode::kDst:
486 return true;
487 default:
488 break;
489 }
490 return false;
491 }
492