1/*
2 * Copyright 2018 Google Inc.
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 SkMaskFilterBase_DEFINED
9#define SkMaskFilterBase_DEFINED
10
11#include "SkBlurTypes.h"
12#include "SkFlattenable.h"
13#include "SkMask.h"
14#include "SkMaskFilter.h"
15#include "SkPaint.h"
16#include "SkStrokeRec.h"
17
18class GrClip;
19class GrContext;
20struct GrFPArgs;
21class GrRenderTargetContext;
22class GrPaint;
23class GrFragmentProcessor;
24class GrRenderTarget;
25class GrResourceProvider;
26class GrTexture;
27class GrTextureProxy;
28class SkBitmap;
29class SkBlitter;
30class SkCachedData;
31class SkMatrix;
32class SkPath;
33class SkRasterClip;
34class SkRRect;
35
36class SkMaskFilterBase : public SkMaskFilter {
37public:
38    /** Returns the format of the resulting mask that this subclass will return
39        when its filterMask() method is called.
40    */
41    virtual SkMask::Format getFormat() const = 0;
42
43    /** Create a new mask by filter the src mask.
44        If src.fImage == null, then do not allocate or create the dst image
45        but do fill out the other fields in dstMask.
46        If you do allocate a dst image, use SkMask::AllocImage()
47        If this returns false, dst mask is ignored.
48        @param  dst the result of the filter. If src.fImage == null, dst should not allocate its image
49        @param src the original image to be filtered.
50        @param matrix the CTM
51        @param margin   if not null, return the buffer dx/dy need when calculating the effect. Used when
52                        drawing a clipped object to know how much larger to allocate the src before
53                        applying the filter. If returning false, ignore this parameter.
54        @return true if the dst mask was correctly created.
55    */
56    virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
57                            SkIPoint* margin) const;
58
59#if SK_SUPPORT_GPU
60    /**
61     *  Returns a processor if the filter can be expressed a single-pass GrProcessor without
62     *  requiring an explicit input mask. Per-pixel, the effect receives the incoming mask's
63     *  coverage as the input color and outputs the filtered covereage value. This means that each
64     *  pixel's filtered coverage must only depend on the unfiltered mask value for that pixel and
65     *  not on surrounding values.
66     */
67    std::unique_ptr<GrFragmentProcessor> asFragmentProcessor(const GrFPArgs& args) const;
68
69    /**
70     *  Returns true iff asFragmentProcessor() will return a processor
71     */
72    bool hasFragmentProcessor() const;
73
74    /**
75     *  If asFragmentProcessor() fails the filter may be implemented on the GPU by a subclass
76     *  overriding filterMaskGPU (declared below). That code path requires constructing a
77     *  src mask as input. Since that is a potentially expensive operation, the subclass must also
78     *  override this function to indicate whether filterTextureMaskGPU would succeeed if the mask
79     *  were to be created.
80     *
81     *  'maskRect' returns the device space portion of the mask that the filter needs. The mask
82     *  passed into 'filterMaskGPU' should have the same extent as 'maskRect' but be
83     *  translated to the upper-left corner of the mask (i.e., (maskRect.fLeft, maskRect.fTop)
84     *  appears at (0, 0) in the mask).
85     *
86     * Logically, how this works is:
87     *    canFilterMaskGPU is called
88     *    if (it returns true)
89     *        the returned mask rect is used for quick rejecting
90     *        either directFilterMaskGPU or directFilterRRectMaskGPU is then called
91     *        if (neither of them handle the blur)
92     *            the mask rect is used to generate the mask
93     *            filterMaskGPU is called to filter the mask
94     *
95     * TODO: this should work as:
96     *    if (canFilterMaskGPU(devShape, ...)) // rect, rrect, drrect, path
97     *        filterMaskGPU(devShape, ...)
98     * this would hide the RRect special case and the mask generation
99     */
100    virtual bool canFilterMaskGPU(const SkRRect& devRRect,
101                                  const SkIRect& clipBounds,
102                                  const SkMatrix& ctm,
103                                  SkRect* maskRect) const;
104
105    /**
106     *  Try to directly render the mask filter into the target. Returns true if drawing was
107     *  successful. If false is returned then paint is unmodified.
108     */
109    virtual bool directFilterMaskGPU(GrContext*,
110                                     GrRenderTargetContext* renderTargetContext,
111                                     GrPaint&& paint,
112                                     const GrClip&,
113                                     const SkMatrix& viewMatrix,
114                                     const SkStrokeRec& strokeRec,
115                                     const SkPath& path) const;
116    /**
117     *  Try to directly render a rounded rect mask filter into the target.  Returns
118     *  true if drawing was successful.  If false is returned then paint is unmodified.
119     */
120    virtual bool directFilterRRectMaskGPU(GrContext*,
121                                          GrRenderTargetContext* renderTargetContext,
122                                          GrPaint&& paint,
123                                          const GrClip&,
124                                          const SkMatrix& viewMatrix,
125                                          const SkStrokeRec& strokeRec,
126                                          const SkRRect& rrect,
127                                          const SkRRect& devRRect) const;
128
129    /**
130     * This function is used to implement filters that require an explicit src mask. It should only
131     * be called if canFilterMaskGPU returned true and the maskRect param should be the output from
132     * that call.
133     * Implementations are free to get the GrContext from the src texture in order to create
134     * additional textures and perform multiple passes.
135     */
136    virtual sk_sp<GrTextureProxy> filterMaskGPU(GrContext*,
137                                                sk_sp<GrTextureProxy> srcProxy,
138                                                const SkMatrix& ctm,
139                                                const SkIRect& maskRect) const;
140#endif
141
142    /**
143     * The fast bounds function is used to enable the paint to be culled early
144     * in the drawing pipeline. This function accepts the current bounds of the
145     * paint as its src param and the filter adjust those bounds using its
146     * current mask and returns the result using the dest param. Callers are
147     * allowed to provide the same struct for both src and dest so each
148     * implementation must accomodate that behavior.
149     *
150     *  The default impl calls filterMask with the src mask having no image,
151     *  but subclasses may override this if they can compute the rect faster.
152     */
153    virtual void computeFastBounds(const SkRect& src, SkRect* dest) const;
154
155    struct BlurRec {
156        SkScalar        fSigma;
157        SkBlurStyle     fStyle;
158        SkBlurQuality   fQuality;
159    };
160    /**
161     *  If this filter can be represented by a BlurRec, return true and (if not null) fill in the
162     *  provided BlurRec parameter. If this effect cannot be represented as a BlurRec, return false
163     *  and ignore the BlurRec parameter.
164     */
165    virtual bool asABlur(BlurRec*) const;
166
167protected:
168    SkMaskFilterBase() {}
169
170#if SK_SUPPORT_GPU
171    virtual std::unique_ptr<GrFragmentProcessor> onAsFragmentProcessor(const GrFPArgs&) const;
172    virtual bool onHasFragmentProcessor() const;
173#endif
174
175    enum FilterReturn {
176        kFalse_FilterReturn,
177        kTrue_FilterReturn,
178        kUnimplemented_FilterReturn
179    };
180
181    class NinePatch : ::SkNoncopyable {
182    public:
183        NinePatch() : fCache(nullptr) { }
184        ~NinePatch();
185
186        SkMask      fMask;      // fBounds must have [0,0] in its top-left
187        SkIRect     fOuterRect; // width/height must be >= fMask.fBounds'
188        SkIPoint    fCenter;    // identifies center row/col for stretching
189        SkCachedData* fCache;
190    };
191
192    /**
193     *  Override if your subclass can filter a rect, and return the answer as
194     *  a ninepatch mask to be stretched over the returned outerRect. On success
195     *  return kTrue_FilterReturn. On failure (e.g. out of memory) return
196     *  kFalse_FilterReturn. If the normal filterMask() entry-point should be
197     *  called (the default) return kUnimplemented_FilterReturn.
198     *
199     *  By convention, the caller will take the center rol/col from the returned
200     *  mask as the slice it can replicate horizontally and vertically as we
201     *  stretch the mask to fit inside outerRect. It is an error for outerRect
202     *  to be smaller than the mask's bounds. This would imply that the width
203     *  and height of the mask should be odd. This is not required, just that
204     *  the caller will call mask.fBounds.centerX() and centerY() to find the
205     *  strips that will be replicated.
206     */
207    virtual FilterReturn filterRectsToNine(const SkRect[], int count,
208                                           const SkMatrix&,
209                                           const SkIRect& clipBounds,
210                                           NinePatch*) const;
211    /**
212     *  Similar to filterRectsToNine, except it performs the work on a round rect.
213     */
214    virtual FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
215                                           const SkIRect& clipBounds,
216                                           NinePatch*) const;
217
218private:
219    friend class SkDraw;
220
221    /** Helper method that, given a path in device space, will rasterize it into a kA8_Format mask
222     and then call filterMask(). If this returns true, the specified blitter will be called
223     to render that mask. Returns false if filterMask() returned false.
224     This method is not exported to java.
225     */
226    bool filterPath(const SkPath& devPath, const SkMatrix& ctm, const SkRasterClip&, SkBlitter*,
227                    SkStrokeRec::InitStyle) const;
228
229    /** Helper method that, given a roundRect in device space, will rasterize it into a kA8_Format
230     mask and then call filterMask(). If this returns true, the specified blitter will be called
231     to render that mask. Returns false if filterMask() returned false.
232     */
233    bool filterRRect(const SkRRect& devRRect, const SkMatrix& ctm, const SkRasterClip&,
234                     SkBlitter*) const;
235
236    typedef SkFlattenable INHERITED;
237};
238
239inline SkMaskFilterBase* as_MFB(SkMaskFilter* mf) {
240    return static_cast<SkMaskFilterBase*>(mf);
241}
242
243inline const SkMaskFilterBase* as_MFB(const SkMaskFilter* mf) {
244    return static_cast<const SkMaskFilterBase*>(mf);
245}
246
247inline const SkMaskFilterBase* as_MFB(const sk_sp<SkMaskFilter>& mf) {
248    return static_cast<SkMaskFilterBase*>(mf.get());
249}
250
251#endif
252