• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2006 The Android Open Source Project
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef SkBlurMask_DEFINED
9 #define SkBlurMask_DEFINED
10 
11 #include "SkBlurTypes.h"
12 #include "SkShader.h"
13 #include "SkMask.h"
14 #include "SkRRect.h"
15 
16 class SkBlurMask {
17 public:
18     static bool SK_WARN_UNUSED_RESULT BlurRect(SkScalar sigma, SkMask *dst, const SkRect &src,
19                                                SkBlurStyle, SkIPoint *margin = nullptr,
20                                                SkMask::CreateMode createMode =
21                                                   SkMask::kComputeBoundsAndRenderImage_CreateMode);
22     static bool SK_WARN_UNUSED_RESULT BlurRRect(SkScalar sigma, SkMask *dst, const SkRRect &src,
23                                                 SkBlurStyle, SkIPoint *margin = nullptr,
24                                                 SkMask::CreateMode createMode =
25                                                   SkMask::kComputeBoundsAndRenderImage_CreateMode);
26 
27     // forceQuality will prevent BoxBlur from falling back to the low quality approach when sigma
28     // is very small -- this can be used predict the margin bump ahead of time without completely
29     // replicating the internal logic.  This permits not only simpler caching of blurred results,
30     // but also being able to predict precisely at what pixels the blurred profile of e.g. a
31     // rectangle will lie.
32 
33     static bool SK_WARN_UNUSED_RESULT BoxBlur(SkMask* dst, const SkMask& src,
34                                               SkScalar sigma, SkBlurStyle style, SkBlurQuality,
35                                               SkIPoint* margin = nullptr,
36                                               bool forceQuality = false);
37 
38     // the "ground truth" blur does a gaussian convolution; it's slow
39     // but useful for comparison purposes.
40     static bool SK_WARN_UNUSED_RESULT BlurGroundTruth(SkScalar sigma, SkMask* dst,
41                                                       const SkMask& src,
42                                                       SkBlurStyle, SkIPoint* margin = nullptr);
43 
44     // If radius > 0, return the corresponding sigma, else return 0
45     static SkScalar ConvertRadiusToSigma(SkScalar radius);
46     // If sigma > 0.5, return the corresponding radius, else return 0
47     static SkScalar ConvertSigmaToRadius(SkScalar sigma);
48 
49     /* Helper functions for analytic rectangle blurs */
50 
51     /** Look up the intensity of the (one dimnensional) blurred half-plane.
52         @param profile The precomputed 1D blur profile; memory allocated by and managed by
53                        ComputeBlurProfile below.
54         @param loc the location to look up; The lookup will clamp invalid inputs, but
55                    meaningful data are available between 0 and blurred_width
56         @param blurred_width The width of the final, blurred rectangle
57         @param sharp_width The width of the original, unblurred rectangle.
58     */
59     static uint8_t ProfileLookup(const uint8_t* profile, int loc, int blurredWidth, int sharpWidth);
60 
61     /** Allocate memory for and populate the profile of a 1D blurred halfplane.  The caller
62         must free the memory.  The amount of memory allocated will be exactly 6*sigma bytes.
63         @param sigma The standard deviation of the gaussian blur kernel
64     */
65 
66     static uint8_t* ComputeBlurProfile(SkScalar sigma);
67 
68     /** Compute an entire scanline of a blurred step function.  This is a 1D helper that
69         will produce both the horizontal and vertical profiles of the blurry rectangle.
70         @param pixels Location to store the resulting pixel data; allocated and managed by caller
71         @param profile Precomputed blur profile computed by ComputeBlurProfile above.
72         @param width Size of the pixels array.
73         @param sigma Standard deviation of the gaussian blur kernel used to compute the profile;
74                      this implicitly gives the size of the pixels array.
75     */
76 
77     static void ComputeBlurredScanline(uint8_t* pixels, const uint8_t* profile,
78                                        unsigned int width, SkScalar sigma);
79 
80 
81 
82 };
83 
84 #endif
85