From e727d850955f095f5e3b39fe12e7dba5614dc913 Mon Sep 17 00:00:00 2001 From: "commit-bot@chromium.org" Date: Mon, 28 Apr 2014 16:25:35 +0000 Subject: move common blur types into central header BUG=skia: R=scroggo@google.com, djsollen@google.com Author: reed@google.com Review URL: https://codereview.chromium.org/253833002 git-svn-id: http://skia.googlecode.com/svn/trunk/src@14411 2bbb7eff-a529-9590-31e7-b0007b416f81 --- animator/SkDrawBlur.cpp | 7 +-- animator/SkDrawBlur.h | 2 +- effects/SkBlurDrawLooper.cpp | 4 +- effects/SkBlurMask.cpp | 48 ++++++++--------- effects/SkBlurMask.h | 28 ++-------- effects/SkBlurMaskFilter.cpp | 117 ++++++++++++++++++++--------------------- effects/SkEmbossMaskFilter.cpp | 3 +- 7 files changed, 91 insertions(+), 118 deletions(-) diff --git a/animator/SkDrawBlur.cpp b/animator/SkDrawBlur.cpp index 5f388c93..36d64528 100644 --- a/animator/SkDrawBlur.cpp +++ b/animator/SkDrawBlur.cpp @@ -22,11 +22,12 @@ DEFINE_GET_MEMBER(SkDrawBlur); SkDrawBlur::SkDrawBlur() : fSigma(-1) - , fBlurStyle(SkBlurMaskFilter::kNormal_BlurStyle) { + , fBlurStyle(kNormal_SkBlurStyle) { } SkMaskFilter* SkDrawBlur::getMaskFilter() { - if (fSigma < 0) + if (fSigma <= 0) { return NULL; - return SkBlurMaskFilter::Create((SkBlurMaskFilter::BlurStyle) fBlurStyle, fSigma); + } + return SkBlurMaskFilter::Create((SkBlurStyle)fBlurStyle, fSigma); } diff --git a/animator/SkDrawBlur.h b/animator/SkDrawBlur.h index 462a0413..75075922 100644 --- a/animator/SkDrawBlur.h +++ b/animator/SkDrawBlur.h @@ -17,7 +17,7 @@ class SkDrawBlur : public SkDrawMaskFilter { virtual SkMaskFilter* getMaskFilter() SK_OVERRIDE; protected: SkScalar fSigma; - int /*SkBlurMaskFilter::BlurStyle*/ fBlurStyle; + int /*SkBlurStyle*/ fBlurStyle; typedef SkDrawMaskFilter INHERITED; }; diff --git a/effects/SkBlurDrawLooper.cpp b/effects/SkBlurDrawLooper.cpp index 78506690..03e635be 100644 --- a/effects/SkBlurDrawLooper.cpp +++ b/effects/SkBlurDrawLooper.cpp @@ -46,9 +46,7 @@ void SkBlurDrawLooper::init(SkScalar sigma, SkScalar dx, SkScalar dy, SkBlurMaskFilter::kHighQuality_BlurFlag : SkBlurMaskFilter::kNone_BlurFlag; - fBlur = SkBlurMaskFilter::Create(SkBlurMaskFilter::kNormal_BlurStyle, - sigma, - blurFlags); + fBlur = SkBlurMaskFilter::Create(kNormal_SkBlurStyle, sigma, blurFlags); } else { fBlur = NULL; } diff --git a/effects/SkBlurMask.cpp b/effects/SkBlurMask.cpp index f33817ad..51604cd5 100644 --- a/effects/SkBlurMask.cpp +++ b/effects/SkBlurMask.cpp @@ -435,11 +435,11 @@ static void merge_src_with_blur(uint8_t dst[], int dstRB, static void clamp_with_orig(uint8_t dst[], int dstRowBytes, const uint8_t src[], int srcRowBytes, int sw, int sh, - SkBlurMask::Style style) { + SkBlurStyle style) { int x; while (--sh >= 0) { switch (style) { - case SkBlurMask::kSolid_Style: + case kSolid_SkBlurStyle: for (x = sw - 1; x >= 0; --x) { int s = *src; int d = *dst; @@ -448,7 +448,7 @@ static void clamp_with_orig(uint8_t dst[], int dstRowBytes, src += 1; } break; - case SkBlurMask::kOuter_Style: + case kOuter_SkBlurStyle: for (x = sw - 1; x >= 0; --x) { if (*src) { *dst = SkToU8(SkAlphaMul(*dst, SkAlpha255To256(255 - *src))); @@ -475,21 +475,19 @@ void SkMask_FreeImage(uint8_t* image) { SkMask::FreeImage(image); } -bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, - SkScalar sigma, Style style, Quality quality, - SkIPoint* margin, bool force_quality) { - +bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, SkScalar sigma, SkBlurStyle style, + SkBlurQuality quality, SkIPoint* margin, bool force_quality) { if (src.fFormat != SkMask::kA8_Format) { return false; } // Force high quality off for small radii (performance) if (!force_quality && sigma <= SkIntToScalar(2)) { - quality = kLow_Quality; + quality = kLow_SkBlurQuality; } SkScalar passRadius; - if (kHigh_Quality == quality) { + if (kHigh_SkBlurQuality == quality) { // For the high quality path the 3 pass box blur kernel width is // 6*rad+1 while the full Gaussian width is 6*sigma. passRadius = sigma - (1/6.0f); @@ -502,7 +500,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, // highQuality: use three box blur passes as a cheap way // to approximate a Gaussian blur - int passCount = (kHigh_Quality == quality) ? 3 : 1; + int passCount = (kHigh_SkBlurQuality == quality) ? 3 : 1; int rx = SkScalarCeilToInt(passRadius); int outerWeight = 255 - SkScalarRoundToInt((SkIntToScalar(rx) - passRadius) * 255); @@ -548,7 +546,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, if (outerWeight == 255) { int loRadius, hiRadius; get_adjusted_radii(passRadius, &loRadius, &hiRadius); - if (kHigh_Quality == quality) { + if (kHigh_SkBlurQuality == quality) { // Do three X blurs, with a transpose on the final one. w = boxBlur(sp, src.fRowBytes, tp, loRadius, hiRadius, w, h, false); w = boxBlur(tp, w, dp, hiRadius, loRadius, w, h, false); @@ -562,7 +560,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, h = boxBlur(tp, h, dp, ry, ry, h, w, true); } } else { - if (kHigh_Quality == quality) { + if (kHigh_SkBlurQuality == quality) { // Do three X blurs, with a transpose on the final one. w = boxBlurInterp(sp, src.fRowBytes, tp, rx, w, h, false, outerWeight); w = boxBlurInterp(tp, w, dp, rx, w, h, false, outerWeight); @@ -580,7 +578,7 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, dst->fImage = dp; // if need be, alloc the "real" dst (same size as src) and copy/merge // the blur into it (applying the src) - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { // now we allocate the "real" dst, mirror the size of src size_t srcSize = src.computeImageSize(); if (0 == srcSize) { @@ -592,14 +590,14 @@ bool SkBlurMask::BoxBlur(SkMask* dst, const SkMask& src, dp + passCount * (rx + ry * dst->fRowBytes), dst->fRowBytes, sw, sh); SkMask::FreeImage(dp); - } else if (style != kNormal_Style) { + } else if (style != kNormal_SkBlurStyle) { clamp_with_orig(dp + passCount * (rx + ry * dst->fRowBytes), dst->fRowBytes, sp, src.fRowBytes, sw, sh, style); } (void)autoCall.detach(); } - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { dst->fBounds = src.fBounds; // restore trimmed bounds dst->fRowBytes = src.fRowBytes; } @@ -734,7 +732,7 @@ void SkBlurMask::ComputeBlurredScanline(uint8_t *pixels, const uint8_t *profile, } bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst, - const SkRect &src, Style style, + const SkRect &src, SkBlurStyle style, SkIPoint *margin, SkMask::CreateMode createMode) { int profile_size = SkScalarCeilToInt(6*sigma); @@ -756,7 +754,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst, int sh = SkScalarFloorToInt(src.height()); if (createMode == SkMask::kJustComputeBounds_CreateMode) { - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { dst->fBounds.set(SkScalarRoundToInt(src.fLeft), SkScalarRoundToInt(src.fTop), SkScalarRoundToInt(src.fRight), @@ -797,7 +795,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst, } } - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { // now we allocate the "real" dst, mirror the size of src size_t srcSize = (size_t)(src.width() * src.height()); if (0 == srcSize) { @@ -817,12 +815,12 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst, SkScalarRoundToInt(src.fBottom)); // restore trimmed bounds dst->fRowBytes = sw; - } else if (style == kOuter_Style) { + } else if (style == kOuter_SkBlurStyle) { for (int y = pad ; y < dstHeight-pad ; y++) { uint8_t *dst_scanline = dp + y*dstWidth + pad; memset(dst_scanline, 0, sw); } - } else if (style == kSolid_Style) { + } else if (style == kSolid_SkBlurStyle) { for (int y = pad ; y < dstHeight-pad ; y++) { uint8_t *dst_scanline = dp + y*dstWidth + pad; memset(dst_scanline, 0xff, sw); @@ -835,7 +833,7 @@ bool SkBlurMask::BlurRect(SkScalar sigma, SkMask *dst, } bool SkBlurMask::BlurRRect(SkScalar sigma, SkMask *dst, - const SkRRect &src, Style style, + const SkRRect &src, SkBlurStyle style, SkIPoint *margin, SkMask::CreateMode createMode) { // Temporary for now -- always fail, should cause caller to fall back // to old path. Plumbing just to land API and parallelize effort. @@ -848,7 +846,7 @@ bool SkBlurMask::BlurRRect(SkScalar sigma, SkMask *dst, // useful for correctness comparisons. bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, - Style style, SkIPoint* margin) { + SkBlurStyle style, SkIPoint* margin) { if (src.fFormat != SkMask::kA8_Format) { return false; @@ -964,7 +962,7 @@ bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, dst->fImage = dstPixels; // if need be, alloc the "real" dst (same size as src) and copy/merge // the blur into it (applying the src) - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { // now we allocate the "real" dst, mirror the size of src size_t srcSize = src.computeImageSize(); if (0 == srcSize) { @@ -976,14 +974,14 @@ bool SkBlurMask::BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, dstPixels + pad*dst->fRowBytes + pad, dst->fRowBytes, srcWidth, srcHeight); SkMask::FreeImage(dstPixels); - } else if (style != kNormal_Style) { + } else if (style != kNormal_SkBlurStyle) { clamp_with_orig(dstPixels + pad*dst->fRowBytes + pad, dst->fRowBytes, srcPixels, src.fRowBytes, srcWidth, srcHeight, style); } (void)autoCall.detach(); } - if (style == kInner_Style) { + if (style == kInner_SkBlurStyle) { dst->fBounds = src.fBounds; // restore trimmed bounds dst->fRowBytes = src.fRowBytes; } diff --git a/effects/SkBlurMask.h b/effects/SkBlurMask.h index d4cd3d1e..16009609 100644 --- a/effects/SkBlurMask.h +++ b/effects/SkBlurMask.h @@ -1,4 +1,3 @@ - /* * Copyright 2006 The Android Open Source Project * @@ -6,37 +5,21 @@ * found in the LICENSE file. */ - #ifndef SkBlurMask_DEFINED #define SkBlurMask_DEFINED +#include "SkBlurTypes.h" #include "SkShader.h" #include "SkMask.h" #include "SkRRect.h" class SkBlurMask { public: - enum Style { - kNormal_Style, //!< fuzzy inside and outside - kSolid_Style, //!< solid inside, fuzzy outside - kOuter_Style, //!< nothing inside, fuzzy outside - kInner_Style, //!< fuzzy inside, nothing outside - - kStyleCount - }; - - enum Quality { - kLow_Quality, //!< box blur - kHigh_Quality //!< three pass box blur (similar to gaussian) - }; - - static bool BlurRect(SkScalar sigma, SkMask *dst, const SkRect &src, - Style style, + static bool BlurRect(SkScalar sigma, SkMask *dst, const SkRect &src, SkBlurStyle, SkIPoint *margin = NULL, SkMask::CreateMode createMode = SkMask::kComputeBoundsAndRenderImage_CreateMode); - static bool BlurRRect(SkScalar sigma, SkMask *dst, const SkRRect &src, - Style style, + static bool BlurRRect(SkScalar sigma, SkMask *dst, const SkRRect &src, SkBlurStyle, SkIPoint *margin = NULL, SkMask::CreateMode createMode = SkMask::kComputeBoundsAndRenderImage_CreateMode); @@ -48,13 +31,12 @@ public: // rectangle will lie. static bool BoxBlur(SkMask* dst, const SkMask& src, - SkScalar sigma, Style style, Quality quality, + SkScalar sigma, SkBlurStyle style, SkBlurQuality quality, SkIPoint* margin = NULL, bool forceQuality = false); // the "ground truth" blur does a gaussian convolution; it's slow // but useful for comparison purposes. - static bool BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, - Style style, + static bool BlurGroundTruth(SkScalar sigma, SkMask* dst, const SkMask& src, SkBlurStyle, SkIPoint* margin = NULL); static SkScalar ConvertRadiusToSigma(SkScalar radius); diff --git a/effects/SkBlurMaskFilter.cpp b/effects/SkBlurMaskFilter.cpp index 9f8935ab..c4069ca3 100644 --- a/effects/SkBlurMaskFilter.cpp +++ b/effects/SkBlurMaskFilter.cpp @@ -30,7 +30,7 @@ class SkBlurMaskFilterImpl : public SkMaskFilter { public: - SkBlurMaskFilterImpl(SkScalar sigma, SkBlurMaskFilter::BlurStyle, uint32_t flags); + SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, uint32_t flags); // overrides from SkMaskFilter virtual SkMask::Format getFormat() const SK_OVERRIDE; @@ -83,9 +83,9 @@ private: // a request like 10,000) static const SkScalar kMAX_BLUR_SIGMA; - SkScalar fSigma; - SkBlurMaskFilter::BlurStyle fBlurStyle; - uint32_t fBlurFlags; + SkScalar fSigma; + SkBlurStyle fBlurStyle; + uint32_t fBlurFlags; SkBlurMaskFilterImpl(SkReadBuffer&); virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE; @@ -102,50 +102,42 @@ private: const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128); -SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius, - SkBlurMaskFilter::BlurStyle style, - uint32_t flags) { - // use !(radius > 0) instead of radius <= 0 to reject NaN values - if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount - || flags > SkBlurMaskFilter::kAll_BlurFlag) { +SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) { + if (!SkScalarIsFinite(sigma) || sigma <= 0) { return NULL; } + if ((unsigned)style > (unsigned)kLastEnum_SkBlurStyle) { + return NULL; + } + if (flags > SkBlurMaskFilter::kAll_BlurFlag) { + return NULL; + } + return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags)); +} +#ifdef SK_SUPPORT_LEGACY_BLURMASKFILTER_STYLE +SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius, + SkBlurMaskFilter::BlurStyle style, + uint32_t flags) { SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(radius); - - return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags)); + return Create((SkBlurStyle)style, sigma, flags); } SkMaskFilter* SkBlurMaskFilter::Create(SkBlurMaskFilter::BlurStyle style, SkScalar sigma, uint32_t flags) { - // use !(sigma > 0) instead of sigma <= 0 to reject NaN values - if (!(sigma > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount - || flags > SkBlurMaskFilter::kAll_BlurFlag) { - return NULL; - } - - return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags)); + return Create((SkBlurStyle)style, sigma, flags); } +#endif /////////////////////////////////////////////////////////////////////////////// -SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, - SkBlurMaskFilter::BlurStyle style, - uint32_t flags) - : fSigma(sigma), fBlurStyle(style), fBlurFlags(flags) { -#if 0 - fGamma = NULL; - if (gammaScale) { - fGamma = new U8[256]; - if (gammaScale > 0) - SkBlurMask::BuildSqrGamma(fGamma, gammaScale); - else - SkBlurMask::BuildSqrtGamma(fGamma, -gammaScale); - } -#endif - SkASSERT(fSigma >= 0); - SkASSERT((unsigned)style < SkBlurMaskFilter::kBlurStyleCount); +SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, uint32_t flags) + : fSigma(sigma) + , fBlurStyle(style) + , fBlurFlags(flags) { + SkASSERT(fSigma > 0); + SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle); SkASSERT(flags <= SkBlurMaskFilter::kAll_BlurFlag); } @@ -158,12 +150,11 @@ bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src, SkIPoint* margin) const{ SkScalar sigma = this->computeXformedSigma(matrix); - SkBlurMask::Quality blurQuality = + SkBlurQuality blurQuality = (fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag) ? - SkBlurMask::kHigh_Quality : SkBlurMask::kLow_Quality; + kHigh_SkBlurQuality : kLow_SkBlurQuality; - return SkBlurMask::BoxBlur(dst, src, sigma, (SkBlurMask::Style)fBlurStyle, - blurQuality, margin); + return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, blurQuality, margin); } bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r, @@ -171,7 +162,7 @@ bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r, SkIPoint* margin, SkMask::CreateMode createMode) const{ SkScalar sigma = computeXformedSigma(matrix); - return SkBlurMask::BlurRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle, + return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle, margin, createMode); } @@ -180,7 +171,7 @@ bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r, SkIPoint* margin, SkMask::CreateMode createMode) const{ SkScalar sigma = computeXformedSigma(matrix); - return SkBlurMask::BlurRRect(sigma, dst, r, (SkBlurMask::Style)fBlurStyle, + return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle, margin, createMode); } @@ -298,7 +289,7 @@ SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& ma // TODO: report correct metrics for innerstyle, where we do not grow the // total bounds, but we do need an inset the size of our blur-radius - if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle) { + if (kInner_SkBlurStyle == fBlurStyle) { return kUnimplemented_FilterReturn; } @@ -410,8 +401,7 @@ SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count, // TODO: report correct metrics for innerstyle, where we do not grow the // total bounds, but we do need an inset the size of our blur-radius - if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle || - SkBlurMaskFilter::kOuter_BlurStyle == fBlurStyle) { + if (kInner_SkBlurStyle == fBlurStyle || kOuter_SkBlurStyle == fBlurStyle) { return kUnimplemented_FilterReturn; } @@ -531,10 +521,10 @@ void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src, SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkReadBuffer& buffer) : SkMaskFilter(buffer) { fSigma = buffer.readScalar(); - fBlurStyle = (SkBlurMaskFilter::BlurStyle)buffer.readInt(); + fBlurStyle = (SkBlurStyle)buffer.readInt(); fBlurFlags = buffer.readUInt() & SkBlurMaskFilter::kAll_BlurFlag; - SkASSERT(fSigma >= 0); - SkASSERT((unsigned)fBlurStyle < SkBlurMaskFilter::kBlurStyleCount); + SkASSERT(fSigma > 0); + SkASSERT((unsigned)fBlurStyle <= kLastEnum_SkBlurStyle); } void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const { @@ -785,7 +775,7 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrContext* context, GrPaint* grp, const SkStrokeRec& strokeRec, const SkPath& path) const { - if (fBlurStyle != SkBlurMaskFilter::kNormal_BlurStyle) { + if (fBlurStyle != kNormal_SkBlurStyle) { return false; } @@ -888,7 +878,8 @@ GrEffectRef* GrRRectBlurEffect::Create(GrContext* context, float sigma, const Sk texDesc.fHeight = texSide; texDesc.fConfig = kAlpha_8_GrPixelConfig; - GrTexture *blurNinePatchTexture = context->findAndRefTexture(texDesc, blurRRectNinePatchID, ¶ms); + GrTexture *blurNinePatchTexture = context->findAndRefTexture(texDesc, blurRRectNinePatchID, + ¶ms); if (NULL == blurNinePatchTexture) { SkMask mask; @@ -910,12 +901,15 @@ GrEffectRef* GrRRectBlurEffect::Create(GrContext* context, float sigma, const Sk SkPath path; path.addRRect( smallRRect ); - SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask, SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style); + SkDraw::DrawToMask(path, &mask.fBounds, NULL, NULL, &mask, + SkMask::kJustRenderImage_CreateMode, SkPaint::kFill_Style); SkMask blurred_mask; - SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, SkBlurMask::kNormal_Style, SkBlurMask::kHigh_Quality, NULL, true ); + SkBlurMask::BoxBlur(&blurred_mask, mask, sigma, kNormal_SkBlurStyle, + kHigh_SkBlurQuality, NULL, true ); - blurNinePatchTexture = context->createTexture(¶ms, texDesc, blurRRectNinePatchID, blurred_mask.fImage, 0); + blurNinePatchTexture = context->createTexture(¶ms, texDesc, blurRRectNinePatchID, + blurred_mask.fImage, 0); } if (NULL == blurNinePatchTexture) { @@ -935,9 +929,10 @@ const GrBackendEffectFactory& GrRRectBlurEffect::getFactory() const { } GrRRectBlurEffect::GrRRectBlurEffect(float sigma, const SkRRect& rrect, GrTexture *ninePatchTexture) - : fRRect(rrect), - fSigma(sigma), - fNinePatchAccess(ninePatchTexture) { + : fRRect(rrect) + , fSigma(sigma) + , fNinePatchAccess(ninePatchTexture) +{ this->addTextureAccess(&fNinePatchAccess); this->setWillReadFragmentPosition(); } @@ -1070,7 +1065,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrContext* context, GrPaint* grp, const SkStrokeRec& strokeRec, const SkRRect& rrect) const { - if (fBlurStyle != SkBlurMaskFilter::kNormal_BlurStyle) { + if (fBlurStyle != kNormal_SkBlurStyle) { return false; } @@ -1154,7 +1149,7 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src, // If we're doing a normal blur, we can clobber the pathTexture in the // gaussianBlur. Otherwise, we need to save it for later compositing. - bool isNormalBlur = (SkBlurMaskFilter::kNormal_BlurStyle == fBlurStyle); + bool isNormalBlur = (kNormal_SkBlurStyle == fBlurStyle); *result = SkGpuBlurUtils::GaussianBlur(context, src, isNormalBlur && canOverwriteSrc, clipRect, false, xformedSigma, xformedSigma); if (NULL == *result) { @@ -1169,14 +1164,14 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src, // Blend pathTexture over blurTexture. GrContext::AutoRenderTarget art(context, (*result)->asRenderTarget()); paint.addColorEffect(GrSimpleTextureEffect::Create(src, matrix))->unref(); - if (SkBlurMaskFilter::kInner_BlurStyle == fBlurStyle) { + if (kInner_SkBlurStyle == fBlurStyle) { // inner: dst = dst * src paint.setBlendFunc(kDC_GrBlendCoeff, kZero_GrBlendCoeff); - } else if (SkBlurMaskFilter::kSolid_BlurStyle == fBlurStyle) { + } else if (kSolid_SkBlurStyle == fBlurStyle) { // solid: dst = src + dst - src * dst // = (1 - dst) * src + 1 * dst paint.setBlendFunc(kIDC_GrBlendCoeff, kOne_GrBlendCoeff); - } else if (SkBlurMaskFilter::kOuter_BlurStyle == fBlurStyle) { + } else if (kOuter_SkBlurStyle == fBlurStyle) { // outer: dst = dst * (1 - src) // = 0 * src + (1 - src) * dst paint.setBlendFunc(kZero_GrBlendCoeff, kISC_GrBlendCoeff); @@ -1198,7 +1193,7 @@ void SkBlurMaskFilterImpl::toString(SkString* str) const { str->appendScalar(fSigma); str->append(" "); - static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = { + static const char* gStyleName[kLastEnum_SkBlurStyle + 1] = { "normal", "solid", "outer", "inner" }; diff --git a/effects/SkEmbossMaskFilter.cpp b/effects/SkEmbossMaskFilter.cpp index 19725f1a..9bf5025e 100644 --- a/effects/SkEmbossMaskFilter.cpp +++ b/effects/SkEmbossMaskFilter.cpp @@ -76,8 +76,7 @@ bool SkEmbossMaskFilter::filterMask(SkMask* dst, const SkMask& src, const SkMatrix& matrix, SkIPoint* margin) const { SkScalar sigma = matrix.mapRadius(fBlurSigma); - if (!SkBlurMask::BoxBlur(dst, src, sigma, SkBlurMask::kInner_Style, - SkBlurMask::kLow_Quality)) { + if (!SkBlurMask::BoxBlur(dst, src, sigma, kInner_SkBlurStyle, kLow_SkBlurQuality)) { return false; } -- cgit v1.2.3