move common blur types into central header

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
@@ skipping 11 matching lines @@
 #include "GrTexture.h"
 #include "GrEffect.h"
 #include "gl/GrGLEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkGrPixelRef.h"
 #endif
 
 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;
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
                                   const SkIRect& clipBounds,
                                   const SkMatrix& ctm,
@@ skipping 32 matching lines @@
                         SkIPoint* margin, SkMask::CreateMode createMode) const;
     bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix,
                         SkIPoint* margin, SkMask::CreateMode createMode) const;
 
 private:
     // To avoid unseemly allocation requests (esp. for finite platforms like
     // handset) we limit the radius so something manageable. (as opposed to
     // 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;
 
     SkScalar computeXformedSigma(const SkMatrix& ctm) const {
         bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
 
         SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma);
         return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
     }
 
     typedef SkMaskFilter INHERITED;
 };
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
+SkMaskFilter* SkBlurMaskFilter::Create(SkBlurStyle style, SkScalar sigma, uint32_t flags) {
+    if (!(sigma > 0)) {

[scroggo, 2014/04/28 15:47:45]

Can you add the comment (removed down below) about why you used ! > 0 instead of
<=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) {
-    // use !(radius > 0) instead of radius <= 0 to reject NaN values
-    if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
-        || flags > SkBlurMaskFilter::kAll_BlurFlag) {
-        return NULL;
-    }
-
     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);
 }
 
 SkMask::Format SkBlurMaskFilterImpl::getFormat() const {
     return SkMask::kA8_Format;
 }
 
 bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
                                       const SkMatrix& matrix,
                                       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,
                                           const SkMatrix& matrix,
                                           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);
 }
 
 bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
                                           const SkMatrix& matrix,
                                           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);
 }
 
 #include "SkCanvas.h"
 
 static bool prepare_to_draw_into_mask(const SkRect& bounds, SkMask* mask) {
     SkASSERT(mask != NULL);
 
     bounds.roundOut(&mask->fBounds);
     mask->fRowBytes = SkAlign4(mask->fBounds.width());
@@ skipping 97 matching lines @@
 
         // These three can take advantage of this fast path.
         case SkRRect::kSimple_Type:
         case SkRRect::kNinePatch_Type:
         case SkRRect::kComplex_Type:
             break;
     }
 
     // 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;
     }
 
     // TODO: take clipBounds into account to limit our coordinates up front
     // for now, just skip too-large src rects (to take the old code path).
     if (rect_exceeds(rrect.rect(), SkIntToScalar(32767))) {
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
@@ skipping 91 matching lines @@
 SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
                                         const SkMatrix& matrix,
                                         const SkIRect& clipBounds,
                                         NinePatch* patch) const {
     if (count < 1 || count > 2) {
         return kUnimplemented_FilterReturn;
     }
 
     // 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;
     }
 
     // TODO: take clipBounds into account to limit our coordinates up front
     // for now, just skip too-large src rects (to take the old code path).
     if (rect_exceeds(rects[0], SkIntToScalar(32767))) {
         return kUnimplemented_FilterReturn;
     }
 
     SkIPoint margin;
@@ skipping 99 matching lines @@
                                              SkRect* dst) const {
     SkScalar pad = 3.0f * fSigma;
 
     dst->set(src.fLeft  - pad, src.fTop    - pad,
              src.fRight + pad, src.fBottom + pad);
 }
 
 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 {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fSigma);
     buffer.writeInt(fBlurStyle);
     buffer.writeUInt(fBlurFlags);
 }
 
 #if SK_SUPPORT_GPU
@@ skipping 230 matching lines @@
     float width = random->nextRangeF(200,300);
     float height = random->nextRangeF(200,300);
     return GrRectBlurEffect::Create(context, SkRect::MakeWH(width, height), sigma);
 }
 
 
 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;
     }
 
     SkRect rect;
     if (!path.isRect(&rect)) {
         return false;
     }
 
     if (!strokeRec.isFillStyle()) {
         return false;
@@ skipping 74 matching lines @@
 
     GrContext* context = src->getContext();
 
     GrContext::AutoWideOpenIdentityDraw awo(context, NULL);
 
     SkScalar xformedSigma = this->computeXformedSigma(ctm);
     SkASSERT(xformedSigma > 0);
 
     // 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) {
         return false;
     }
 
     if (!isNormalBlur) {
         context->setIdentityMatrix();
         GrPaint paint;
         SkMatrix matrix;
         matrix.setIDiv(src->width(), src->height());
         // 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);
         }
         context->drawRect(paint, clipRect);
     }
 
     return true;
 }
 
 #endif // SK_SUPPORT_GPU
 
 
 #ifndef SK_IGNORE_TO_STRING
 void SkBlurMaskFilterImpl::toString(SkString* str) const {
     str->append("SkBlurMaskFilterImpl: (");
 
     str->append("sigma: ");
     str->appendScalar(fSigma);
     str->append(" ");
 
-    static const char* gStyleName[SkBlurMaskFilter::kBlurStyleCount] = {
+    static const char* gStyleName[kLastEnum_SkBlurStyle + 1] = {
         "normal", "solid", "outer", "inner"
     };
 
     str->appendf("style: %s ", gStyleName[fBlurStyle]);
     str->append("flags: (");
     if (fBlurFlags) {
         bool needSeparator = false;
         SkAddFlagToString(str,
                           SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag),
                           "IgnoreXform", &needSeparator);
         SkAddFlagToString(str,
                           SkToBool(fBlurFlags & SkBlurMaskFilter::kHighQuality_BlurFlag),
                           "HighQuality", &needSeparator);
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END