Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(62)

Side by Side Diff: src/effects/SkBlurMaskFilter.cpp

Issue 21835004: Blur refactoring (Closed) Base URL: http://skia.googlecode.com/svn/trunk/
Patch Set: hide constant Created 7 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698