A new implementation of mask blurs, using separable X/Y passes. Disabled for now.

A new implementation of mask blurs, using separable X/Y passes.  Disabled for now.

Committed: https://code.google.com/p/skia/source/detail?r=6404

[Stephen White, 2012-11-12 16:38:14]

PTAL.  Although this doesn't show consistent wins versus the current
implementation (+20% in some cases, -10% in others), I'd like to keep the code
around for future experiments.

I needed the gypfile change to prevent linker errors on my Linux box (not sure
why the bots aren't having this).  If this is wrong it can be removed.

[bsalomon, 2012-11-12 18:31:37]

LGTM, but I'm no raster-code expert so Mike should probably have a look.

I've added Derek since he was looking into X11 linking issues in gpu.gyp

[DerekS, 2012-11-12 18:55:00]

I've made the same change in a local checkout that matches your gyp and was
going to eventually upload it for review, but you beat me to the punch. :)

[reed1, 2012-11-12 19:36:53]

Can this be formulated with just a different entry-point, so both can exist at
runtime? Would eliminate the need for a build-flag too.

[Stephen White, 2012-11-12 19:50:44]

On 2012/11/12 19:36:53, reed1 wrote:
> Can this be formulated with just a different entry-point, so both can exist at
> runtime? Would eliminate the need for a build-flag too.

Not sure what you mean. How would you switch at runtime? A new maskfilter class?

[reed1, 2012-11-12 20:06:06]

SkBlurMask is a utility class, so it can have any number of entry-points. How
about

    static bool Blur(SkMask* dst, const SkMask& src,
                     SkScalar radius, Style style, Quality quality,
                     SkIPoint* margin = NULL);

and

    static bool SeperableBlur(SkMask* dst, const SkMask& src,
                     SkScalar radius, Style style, Quality quality,
                     SkIPoint* margin = NULL);

Then SkBlurMaskFilter can decide to call which ever one it wants, based on size
heuristic or a user pref or even a build-flag, but the code in SkBlurMask.cpp
can still both exist, and both can be part of bench timings.

[Stephen White, 2012-11-13 16:48:57]

On 2012/11/12 20:06:06, reed1 wrote:
> SkBlurMask is a utility class, so it can have any number of entry-points. How
> about
> 
>     static bool Blur(SkMask* dst, const SkMask& src,
>                      SkScalar radius, Style style, Quality quality,
>                      SkIPoint* margin = NULL);
> 
> and
> 
>     static bool SeperableBlur(SkMask* dst, const SkMask& src,
>                      SkScalar radius, Style style, Quality quality,
>                      SkIPoint* margin = NULL);
> 
> Then SkBlurMaskFilter can decide to call which ever one it wants, based on
size
> heuristic or a user pref or even a build-flag, but the code in SkBlurMask.cpp
> can still both exist, and both can be part of bench timings.

Done.  PTAL.

[reed1, 2012-11-13 16:56:50]

lgtm

[reed1, 2012-11-13 16:57:52]

btw -- is there anything even faster we can do if we *know* that the src-mask is
just a filled rect?

[Stephen White, 2012-11-13 17:17:29]

On 2012/11/13 16:57:52, reed1 wrote:
> btw -- is there anything even faster we can do if we *know* that the src-mask
is
> just a filled rect?

Yes, I'm sure we could come up with something empirical, such as a per-pixel
function that's determined only by X, Y and the radius, or a LUT.