OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2006 The Android Open Source Project | 3 * Copyright 2006 The Android Open Source Project |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 #include "SkBlurMaskFilter.h" | 9 #include "SkBlurMaskFilter.h" |
10 #include "SkBlurMask.h" | 10 #include "SkBlurMask.h" |
11 #include "SkGpuBlurUtils.h" | 11 #include "SkGpuBlurUtils.h" |
12 #include "SkFlattenableBuffers.h" | 12 #include "SkFlattenableBuffers.h" |
13 #include "SkMaskFilter.h" | 13 #include "SkMaskFilter.h" |
14 #include "SkRTConf.h" | 14 #include "SkRTConf.h" |
15 #include "SkStringUtils.h" | 15 #include "SkStringUtils.h" |
16 #include "SkStrokeRec.h" | 16 #include "SkStrokeRec.h" |
17 | 17 |
18 #if SK_SUPPORT_GPU | 18 #if SK_SUPPORT_GPU |
19 #include "GrContext.h" | 19 #include "GrContext.h" |
20 #include "GrTexture.h" | 20 #include "GrTexture.h" |
21 #include "effects/GrSimpleTextureEffect.h" | 21 #include "effects/GrSimpleTextureEffect.h" |
22 #include "SkGrPixelRef.h" | 22 #include "SkGrPixelRef.h" |
23 #endif | 23 #endif |
24 | 24 |
| 25 #ifndef CLEAN_UP_WHEN_SKPS_ARE_CAPTURED_IN_V13 |
| 26 #include "SkPicture.h" |
| 27 #endif |
| 28 |
25 class SkBlurMaskFilterImpl : public SkMaskFilter { | 29 class SkBlurMaskFilterImpl : public SkMaskFilter { |
26 public: | 30 public: |
27 SkBlurMaskFilterImpl(SkScalar radius, SkBlurMaskFilter::BlurStyle, | 31 SkBlurMaskFilterImpl(SkScalar sigma, SkBlurMaskFilter::BlurStyle, uint32_t f
lags); |
28 uint32_t flags); | |
29 | 32 |
30 // overrides from SkMaskFilter | 33 // overrides from SkMaskFilter |
31 virtual SkMask::Format getFormat() const SK_OVERRIDE; | 34 virtual SkMask::Format getFormat() const SK_OVERRIDE; |
32 virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, | 35 virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&, |
33 SkIPoint* margin) const SK_OVERRIDE; | 36 SkIPoint* margin) const SK_OVERRIDE; |
34 | 37 |
35 #if SK_SUPPORT_GPU | 38 #if SK_SUPPORT_GPU |
36 virtual bool canFilterMaskGPU(const SkRect& devBounds, | 39 virtual bool canFilterMaskGPU(const SkRect& devBounds, |
37 const SkIRect& clipBounds, | 40 const SkIRect& clipBounds, |
38 const SkMatrix& ctm, | 41 const SkMatrix& ctm, |
(...skipping 14 matching lines...) Expand all Loading... |
53 const SkIRect& clipBounds, | 56 const SkIRect& clipBounds, |
54 NinePatch*) const SK_OVERRIDE; | 57 NinePatch*) const SK_OVERRIDE; |
55 | 58 |
56 bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix, | 59 bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix, |
57 SkIPoint* margin, SkMask::CreateMode createMode) const; | 60 SkIPoint* margin, SkMask::CreateMode createMode) const; |
58 | 61 |
59 private: | 62 private: |
60 // To avoid unseemly allocation requests (esp. for finite platforms like | 63 // To avoid unseemly allocation requests (esp. for finite platforms like |
61 // handset) we limit the radius so something manageable. (as opposed to | 64 // handset) we limit the radius so something manageable. (as opposed to |
62 // a request like 10,000) | 65 // a request like 10,000) |
63 static const SkScalar kMAX_BLUR_RADIUS; | 66 static const SkScalar kMAX_BLUR_SIGMA; |
64 // This constant approximates the scaling done in the software path's | |
65 // "high quality" mode, in SkBlurMask::Blur() (1 / sqrt(3)). | |
66 // IMHO, it actually should be 1: we blur "less" than we should do | |
67 // according to the CSS and canvas specs, simply because Safari does the sam
e. | |
68 // Firefox used to do the same too, until 4.0 where they fixed it. So at so
me | |
69 // point we should probably get rid of these scaling constants and rebaselin
e | |
70 // all the blur tests. | |
71 static const SkScalar kBLUR_SIGMA_SCALE; | |
72 | 67 |
73 SkScalar fRadius; | 68 SkScalar fSigma; |
74 SkBlurMaskFilter::BlurStyle fBlurStyle; | 69 SkBlurMaskFilter::BlurStyle fBlurStyle; |
75 uint32_t fBlurFlags; | 70 uint32_t fBlurFlags; |
76 | 71 |
77 SkBlurMaskFilterImpl(SkFlattenableReadBuffer&); | 72 SkBlurMaskFilterImpl(SkFlattenableReadBuffer&); |
78 virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; | 73 virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE; |
79 #if SK_SUPPORT_GPU | 74 |
80 SkScalar computeXformedRadius(const SkMatrix& ctm) const { | 75 SkScalar computeXformedSigma(const SkMatrix& ctm) const { |
81 bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTr
ansform_BlurFlag); | 76 bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTr
ansform_BlurFlag); |
82 | 77 |
83 SkScalar xformedRadius = ignoreTransform ? fRadius | 78 SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma)
; |
84 : ctm.mapRadius(fRadius); | 79 return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA); |
85 return SkMinScalar(xformedRadius, kMAX_BLUR_RADIUS); | |
86 } | 80 } |
87 #endif | |
88 | 81 |
89 typedef SkMaskFilter INHERITED; | 82 typedef SkMaskFilter INHERITED; |
90 }; | 83 }; |
91 | 84 |
92 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_RADIUS = SkIntToScalar(128); | 85 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128); |
93 const SkScalar SkBlurMaskFilterImpl::kBLUR_SIGMA_SCALE = SkFloatToScalar(0.6f); | |
94 | 86 |
95 SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius, | 87 SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius, |
96 SkBlurMaskFilter::BlurStyle style, | 88 SkBlurMaskFilter::BlurStyle style, |
97 uint32_t flags) { | 89 uint32_t flags) { |
98 // use !(radius > 0) instead of radius <= 0 to reject NaN values | 90 // use !(radius > 0) instead of radius <= 0 to reject NaN values |
99 if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount | 91 if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount |
100 || flags > SkBlurMaskFilter::kAll_BlurFlag) { | 92 || flags > SkBlurMaskFilter::kAll_BlurFlag) { |
101 return NULL; | 93 return NULL; |
102 } | 94 } |
103 | 95 |
104 return SkNEW_ARGS(SkBlurMaskFilterImpl, (radius, style, flags)); | 96 SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius); |
| 97 |
| 98 return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags)); |
| 99 } |
| 100 |
| 101 SkMaskFilter* SkBlurMaskFilter::Create(SkScalar sigma, |
| 102 SkBlurMaskFilter::BlurStyle style, |
| 103 uint32_t flags, |
| 104 bool unused) { |
| 105 // use !(sigma > 0) instead of sigma <= 0 to reject NaN values |
| 106 if (!(sigma > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount |
| 107 || flags > SkBlurMaskFilter::kAll_BlurFlag) { |
| 108 return NULL; |
| 109 } |
| 110 |
| 111 return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags)); |
105 } | 112 } |
106 | 113 |
107 /////////////////////////////////////////////////////////////////////////////// | 114 /////////////////////////////////////////////////////////////////////////////// |
108 | 115 |
109 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar radius, | 116 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, |
110 SkBlurMaskFilter::BlurStyle style, | 117 SkBlurMaskFilter::BlurStyle style, |
111 uint32_t flags) | 118 uint32_t flags) |
112 : fRadius(radius), fBlurStyle(style), fBlurFlags(flags) { | 119 : fSigma(sigma), fBlurStyle(style), fBlurFlags(flags) { |
113 #if 0 | 120 #if 0 |
114 fGamma = NULL; | 121 fGamma = NULL; |
115 if (gammaScale) { | 122 if (gammaScale) { |
116 fGamma = new U8[256]; | 123 fGamma = new U8[256]; |
117 if (gammaScale > 0) | 124 if (gammaScale > 0) |
118 SkBlurMask::BuildSqrGamma(fGamma, gammaScale); | 125 SkBlurMask::BuildSqrGamma(fGamma, gammaScale); |
119 else | 126 else |
120 SkBlurMask::BuildSqrtGamma(fGamma, -gammaScale); | 127 SkBlurMask::BuildSqrtGamma(fGamma, -gammaScale); |
121 } | 128 } |
122 #endif | 129 #endif |
123 SkASSERT(radius >= 0); | 130 SkASSERT(fSigma >= 0); |
124 SkASSERT((unsigned)style < SkBlurMaskFilter::kBlurStyleCount); | 131 SkASSERT((unsigned)style < SkBlurMaskFilter::kBlurStyleCount); |
125 SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); | 132 SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); |
126 } | 133 } |
127 | 134 |
128 SkMask::Format SkBlurMaskFilterImpl::getFormat() const { | 135 SkMask::Format SkBlurMaskFilterImpl::getFormat() const { |
129 return SkMask::kA8_Format; | 136 return SkMask::kA8_Format; |
130 } | 137 } |
131 | 138 |
132 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src, | 139 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src, |
133 const SkMatrix& matrix, | 140 const SkMatrix& matrix, |
134 SkIPoint* margin) const{ | 141 SkIPoint* margin) const{ |
135 SkScalar radius; | 142 SkScalar sigma = this->computeXformedSigma(matrix); |
136 if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { | |
137 radius = fRadius; | |
138 } else { | |
139 radius = matrix.mapRadius(fRadius); | |
140 } | |
141 | 143 |
142 radius = SkMinScalar(radius, kMAX_BLUR_RADIUS); | |
143 SkBlurMask::Quality blurQuality = | 144 SkBlurMask::Quality blurQuality = |
144 (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? | 145 (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? |
145 SkBlurMask::kHigh_Quality : SkBlurMask::kLow_Quality; | 146 SkBlurMask::kHigh_Quality : SkBlurMask::kLow_Quality; |
146 | 147 |
147 return SkBlurMask::Blur(dst, src, radius, (SkBlurMask::Style)fBlurStyle, | 148 return SkBlurMask::BoxBlur(dst, src, sigma, (SkBlurMask::Style)fBlurStyle, |
148 blurQuality, margin); | 149 blurQuality, margin, true); |
149 } | 150 } |
150 | 151 |
151 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r, | 152 bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r, |
152 const SkMatrix& matrix, | 153 const SkMatrix& matrix, |
153 SkIPoint* margin, SkMask::CreateMode c
reateMode) const{ | 154 SkIPoint* margin, SkMask::CreateMode c
reateMode) const{ |
154 SkScalar radius; | 155 SkScalar sigma = computeXformedSigma(matrix); |
155 if (fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag) { | |
156 radius = fRadius; | |
157 } else { | |
158 radius = matrix.mapRadius(fRadius); | |
159 } | |
160 | 156 |
161 radius = SkMinScalar(radius, kMAX_BLUR_RADIUS); | 157 return SkBlurMask::BlurRect(dst, r, sigma, (SkBlurMask::Style)fBlurStyle, |
162 | 158 margin, createMode, true); |
163 return SkBlurMask::BlurRect(dst, r, radius, (SkBlurMask::Style)fBlurStyle, | |
164 margin, createMode); | |
165 } | 159 } |
166 | 160 |
167 #include "SkCanvas.h" | 161 #include "SkCanvas.h" |
168 | 162 |
169 static bool drawRectsIntoMask(const SkRect rects[], int count, SkMask* mask) { | 163 static bool drawRectsIntoMask(const SkRect rects[], int count, SkMask* mask) { |
170 rects[0].roundOut(&mask->fBounds); | 164 rects[0].roundOut(&mask->fBounds); |
171 mask->fRowBytes = SkAlign4(mask->fBounds.width()); | 165 mask->fRowBytes = SkAlign4(mask->fBounds.width()); |
172 mask->fFormat = SkMask::kA8_Format; | 166 mask->fFormat = SkMask::kA8_Format; |
173 size_t size = mask->computeImageSize(); | 167 size_t size = mask->computeImageSize(); |
174 mask->fImage = SkMask::AllocImage(size); | 168 mask->fImage = SkMask::AllocImage(size); |
(...skipping 152 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 } | 321 } |
328 } | 322 } |
329 patch->fMask.fBounds.offsetTo(0, 0); | 323 patch->fMask.fBounds.offsetTo(0, 0); |
330 patch->fOuterRect = dstM.fBounds; | 324 patch->fOuterRect = dstM.fBounds; |
331 patch->fCenter = center; | 325 patch->fCenter = center; |
332 return kTrue_FilterReturn; | 326 return kTrue_FilterReturn; |
333 } | 327 } |
334 | 328 |
335 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src, | 329 void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src, |
336 SkRect* dst) const { | 330 SkRect* dst) const { |
337 SkScalar gpuPad, rasterPad; | 331 SkScalar pad = 3.0f * fSigma; |
338 | |
339 { | |
340 // GPU path | |
341 SkScalar sigma = SkScalarMul(fRadius, kBLUR_SIGMA_SCALE); | |
342 gpuPad = sigma * 3.0f; | |
343 } | |
344 | |
345 { | |
346 // raster path | |
347 SkScalar radius = SkScalarMul(fRadius, SkBlurMask::kBlurRadiusFudgeFacto
r); | |
348 | |
349 radius = (radius + .5f) * 2.f; | |
350 | |
351 rasterPad = SkIntToScalar(SkScalarRoundToInt(radius * 3)/2); | |
352 } | |
353 | |
354 SkScalar pad = SkMaxScalar(gpuPad, rasterPad); | |
355 | 332 |
356 dst->set(src.fLeft - pad, src.fTop - pad, | 333 dst->set(src.fLeft - pad, src.fTop - pad, |
357 src.fRight + pad, src.fBottom + pad); | 334 src.fRight + pad, src.fBottom + pad); |
358 } | 335 } |
359 | 336 |
360 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkFlattenableReadBuffer& buffer) | 337 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkFlattenableReadBuffer& buffer) |
361 : SkMaskFilter(buffer) { | 338 : SkMaskFilter(buffer) { |
362 fRadius = buffer.readScalar(); | 339 #ifndef CLEAN_UP_WHEN_SKPS_ARE_CAPTURED_IN_V13 |
| 340 if (SkPicture::PICTURE_VERSION < 13) { |
| 341 fSigma = SkBlurMask::ConvertRadiusToSigma(buffer.readScalar()); |
| 342 } else { |
| 343 #endif |
| 344 fSigma = buffer.readScalar(); |
| 345 #ifndef CLEAN_UP_WHEN_SKPS_ARE_CAPTURED_IN_V13 |
| 346 } |
| 347 #endif |
363 fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt(); | 348 fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt(); |
364 fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag; | 349 fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag; |
365 SkASSERT(fRadius >= 0); | 350 SkASSERT(fSigma >= 0); |
366 SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount); | 351 SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount); |
367 } | 352 } |
368 | 353 |
369 void SkBlurMaskFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) const { | 354 void SkBlurMaskFilterImpl::flatten(SkFlattenableWriteBuffer& buffer) const { |
370 this->INHERITED::flatten(buffer); | 355 this->INHERITED::flatten(buffer); |
371 buffer.writeScalar(fRadius); | 356 buffer.writeScalar(fSigma); |
372 buffer.writeInt(fBlurStyle); | 357 buffer.writeInt(fBlurStyle); |
373 buffer.writeUInt(fBlurFlags); | 358 buffer.writeUInt(fBlurFlags); |
374 } | 359 } |
375 | 360 |
376 #if SK_SUPPORT_GPU | 361 #if SK_SUPPORT_GPU |
377 | 362 |
378 bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRect& srcBounds, | 363 bool SkBlurMaskFilterImpl::canFilterMaskGPU(const SkRect& srcBounds, |
379 const SkIRect& clipBounds, | 364 const SkIRect& clipBounds, |
380 const SkMatrix& ctm, | 365 const SkMatrix& ctm, |
381 SkRect* maskRect) const { | 366 SkRect* maskRect) const { |
382 SkScalar xformedRadius = this->computeXformedRadius(ctm); | 367 SkScalar xformedSigma = this->computeXformedSigma(ctm); |
383 if (xformedRadius <= 0) { | 368 if (xformedSigma <= 0) { |
384 return false; | 369 return false; |
385 } | 370 } |
386 | 371 |
387 static const SkScalar kMIN_GPU_BLUR_SIZE = SkIntToScalar(64); | 372 static const SkScalar kMIN_GPU_BLUR_SIZE = SkIntToScalar(64); |
388 static const SkScalar kMIN_GPU_BLUR_RADIUS = SkIntToScalar(32); | 373 static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32); |
389 | 374 |
390 if (srcBounds.width() <= kMIN_GPU_BLUR_SIZE && | 375 if (srcBounds.width() <= kMIN_GPU_BLUR_SIZE && |
391 srcBounds.height() <= kMIN_GPU_BLUR_SIZE && | 376 srcBounds.height() <= kMIN_GPU_BLUR_SIZE && |
392 xformedRadius <= kMIN_GPU_BLUR_RADIUS) { | 377 xformedSigma <= kMIN_GPU_BLUR_SIGMA) { |
393 // We prefer to blur small rect with small radius via CPU. | 378 // We prefer to blur small rect with small radius via CPU. |
394 return false; | 379 return false; |
395 } | 380 } |
396 | 381 |
397 if (NULL == maskRect) { | 382 if (NULL == maskRect) { |
398 // don't need to compute maskRect | 383 // don't need to compute maskRect |
399 return true; | 384 return true; |
400 } | 385 } |
401 | 386 |
402 float sigma3 = 3 * SkScalarToFloat(xformedRadius) * kBLUR_SIGMA_SCALE; | 387 float sigma3 = 3 * SkScalarToFloat(xformedSigma); |
403 | 388 |
404 SkRect clipRect = SkRect::MakeFromIRect(clipBounds); | 389 SkRect clipRect = SkRect::MakeFromIRect(clipBounds); |
405 SkRect srcRect(srcBounds); | 390 SkRect srcRect(srcBounds); |
406 | 391 |
407 // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area. | 392 // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area. |
408 srcRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3)); | 393 srcRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3)); |
409 clipRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3)); | 394 clipRect.outset(SkFloatToScalar(sigma3), SkFloatToScalar(sigma3)); |
410 srcRect.intersect(clipRect); | 395 srcRect.intersect(clipRect); |
411 *maskRect = srcRect; | 396 *maskRect = srcRect; |
412 return true; | 397 return true; |
413 } | 398 } |
414 | 399 |
415 bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src, | 400 bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src, |
416 const SkRect& maskRect, | 401 const SkRect& maskRect, |
417 GrTexture** result, | 402 GrTexture** result, |
418 bool canOverwriteSrc) const { | 403 bool canOverwriteSrc) const { |
419 SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height()); | 404 SkRect clipRect = SkRect::MakeWH(maskRect.width(), maskRect.height()); |
420 | 405 |
421 GrContext* context = src->getContext(); | 406 GrContext* context = src->getContext(); |
422 | 407 |
423 GrContext::AutoWideOpenIdentityDraw awo(context, NULL); | 408 GrContext::AutoWideOpenIdentityDraw awo(context, NULL); |
424 | 409 |
425 SkScalar xformedRadius = this->computeXformedRadius(context->getMatrix()); | 410 SkScalar xformedSigma = this->computeXformedSigma(context->getMatrix()); |
426 SkASSERT(xformedRadius > 0); | 411 SkASSERT(xformedSigma > 0); |
427 | |
428 float sigma = SkScalarToFloat(xformedRadius) * kBLUR_SIGMA_SCALE; | |
429 | 412 |
430 // If we're doing a normal blur, we can clobber the pathTexture in the | 413 // If we're doing a normal blur, we can clobber the pathTexture in the |
431 // gaussianBlur. Otherwise, we need to save it for later compositing. | 414 // gaussianBlur. Otherwise, we need to save it for later compositing. |
432 bool isNormalBlur = (SkBlurMaskFilter::kNormal_BlurStyle == fBlurStyle); | 415 bool isNormalBlur = (SkBlurMaskFilter::kNormal_BlurStyle == fBlurStyle); |
433 *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOver
writeSrc, | 416 *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOver
writeSrc, |
434 clipRect, false, sigma, sigma); | 417 clipRect, false, xformedSigma, xforme
dSigma); |
435 if (NULL == *result) { | 418 if (NULL == *result) { |
436 return false; | 419 return false; |
437 } | 420 } |
438 | 421 |
439 if (!isNormalBlur) { | 422 if (!isNormalBlur) { |
440 context->setIdentityMatrix(); | 423 context->setIdentityMatrix(); |
441 GrPaint paint; | 424 GrPaint paint; |
442 SkMatrix matrix; | 425 SkMatrix matrix; |
443 matrix.setIDiv(src->width(), src->height()); | 426 matrix.setIDiv(src->width(), src->height()); |
444 // Blend pathTexture over blurTexture. | 427 // Blend pathTexture over blurTexture. |
(...skipping 17 matching lines...) Expand all Loading... |
462 return true; | 445 return true; |
463 } | 446 } |
464 | 447 |
465 #endif // SK_SUPPORT_GPU | 448 #endif // SK_SUPPORT_GPU |
466 | 449 |
467 | 450 |
468 #ifdef SK_DEVELOPER | 451 #ifdef SK_DEVELOPER |
469 void SkBlurMaskFilterImpl::toString(SkString* str) const { | 452 void SkBlurMaskFilterImpl::toString(SkString* str) const { |
470 str->append("SkBlurMaskFilterImpl: ("); | 453 str->append("SkBlurMaskFilterImpl: ("); |
471 | 454 |
472 str->append("radius: "); | 455 str->append("sigma: "); |
473 str->appendScalar(fRadius); | 456 str->appendScalar(fSigma); |
474 str->append(" "); | 457 str->append(" "); |
475 | 458 |
476 static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = { | 459 static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = { |
477 "normal", "solid", "outer", "inner" | 460 "normal", "solid", "outer", "inner" |
478 }; | 461 }; |
479 | 462 |
480 str->appendf("style: %s ", gStyleName[fBlurStyle]); | 463 str->appendf("style: %s ", gStyleName[fBlurStyle]); |
481 str->append("flags: ("); | 464 str->append("flags: ("); |
482 if (fBlurFlags) { | 465 if (fBlurFlags) { |
483 bool needSeparator = false; | 466 bool needSeparator = false; |
484 SkAddFlagToString(str, | 467 SkAddFlagToString(str, |
485 SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransfo
rm_BlurFlag), | 468 SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransfo
rm_BlurFlag), |
486 "IgnoreXform", &needSeparator); | 469 "IgnoreXform", &needSeparator); |
487 SkAddFlagToString(str, | 470 SkAddFlagToString(str, |
488 SkToBool(fBlurFlags & SkBlurMaskFilter::kHighQuality_B
lurFlag), | 471 SkToBool(fBlurFlags & SkBlurMaskFilter::kHighQuality_B
lurFlag), |
489 "HighQuality", &needSeparator); | 472 "HighQuality", &needSeparator); |
490 } else { | 473 } else { |
491 str->append("None"); | 474 str->append("None"); |
492 } | 475 } |
493 str->append("))"); | 476 str->append("))"); |
494 } | 477 } |
495 #endif | 478 #endif |
496 | 479 |
497 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter) | 480 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter) |
498 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl) | 481 SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl) |
499 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END | 482 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END |
OLD | NEW |