• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2013 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 #include "SkAlphaThresholdFilter.h"
9 #include "SkBitmap.h"
10 #include "SkReadBuffer.h"
11 #include "SkWriteBuffer.h"
12 #include "SkRegion.h"
13 
14 class SK_API SkAlphaThresholdFilterImpl : public SkImageFilter {
15 public:
16     SkAlphaThresholdFilterImpl(const SkRegion& region, SkScalar innerThreshold,
17                                SkScalar outerThreshold, SkImageFilter* input);
18 
19     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkAlphaThresholdFilterImpl)
20 
21 protected:
22 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
23     explicit SkAlphaThresholdFilterImpl(SkReadBuffer& buffer);
24 #endif
25     virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
26 
27     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
28                                SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE;
29 #if SK_SUPPORT_GPU
30     virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
31                                      const SkIRect& bounds) const SK_OVERRIDE;
32 #endif
33 
34 private:
35     SkRegion fRegion;
36     SkScalar fInnerThreshold;
37     SkScalar fOuterThreshold;
38     typedef SkImageFilter INHERITED;
39 };
40 
Create(const SkRegion & region,SkScalar innerThreshold,SkScalar outerThreshold,SkImageFilter * input)41 SkImageFilter* SkAlphaThresholdFilter::Create(const SkRegion& region,
42                                               SkScalar innerThreshold,
43                                               SkScalar outerThreshold,
44                                               SkImageFilter* input) {
45     return SkNEW_ARGS(SkAlphaThresholdFilterImpl, (region, innerThreshold, outerThreshold, input));
46 }
47 
48 #if SK_SUPPORT_GPU
49 #include "GrContext.h"
50 #include "GrCoordTransform.h"
51 #include "GrProcessor.h"
52 #include "gl/GrGLProcessor.h"
53 #include "gl/builders/GrGLProgramBuilder.h"
54 #include "GrTBackendProcessorFactory.h"
55 #include "GrTextureAccess.h"
56 
57 #include "SkGr.h"
58 
59 class GrGLAlphaThresholdEffect;
60 
61 class AlphaThresholdEffect : public GrFragmentProcessor {
62 
63 public:
Create(GrTexture * texture,GrTexture * maskTexture,float innerThreshold,float outerThreshold)64     static GrFragmentProcessor* Create(GrTexture* texture,
65                                        GrTexture* maskTexture,
66                                        float innerThreshold,
67                                        float outerThreshold) {
68         return SkNEW_ARGS(AlphaThresholdEffect, (texture,
69                                                  maskTexture,
70                                                  innerThreshold,
71                                                  outerThreshold));
72     }
73 
~AlphaThresholdEffect()74     virtual ~AlphaThresholdEffect() {};
75 
Name()76     static const char* Name() { return "Alpha Threshold"; }
77 
78     virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE;
79     virtual void getConstantColorComponents(GrColor* color, uint32_t* validFlags) const SK_OVERRIDE;
80 
innerThreshold() const81     float innerThreshold() const { return fInnerThreshold; }
outerThreshold() const82     float outerThreshold() const { return fOuterThreshold; }
83 
84     typedef GrGLAlphaThresholdEffect GLProcessor;
85 
86 private:
AlphaThresholdEffect(GrTexture * texture,GrTexture * maskTexture,float innerThreshold,float outerThreshold)87     AlphaThresholdEffect(GrTexture* texture,
88                          GrTexture* maskTexture,
89                          float innerThreshold,
90                          float outerThreshold)
91         : fInnerThreshold(innerThreshold)
92         , fOuterThreshold(outerThreshold)
93         , fImageCoordTransform(kLocal_GrCoordSet,
94                                GrCoordTransform::MakeDivByTextureWHMatrix(texture), texture)
95         , fImageTextureAccess(texture)
96         , fMaskCoordTransform(kLocal_GrCoordSet,
97                               GrCoordTransform::MakeDivByTextureWHMatrix(maskTexture), maskTexture)
98         , fMaskTextureAccess(maskTexture) {
99         this->addCoordTransform(&fImageCoordTransform);
100         this->addTextureAccess(&fImageTextureAccess);
101         this->addCoordTransform(&fMaskCoordTransform);
102         this->addTextureAccess(&fMaskTextureAccess);
103     }
104 
105     virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE;
106 
107     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
108 
109     float fInnerThreshold;
110     float fOuterThreshold;
111     GrCoordTransform fImageCoordTransform;
112     GrTextureAccess  fImageTextureAccess;
113     GrCoordTransform fMaskCoordTransform;
114     GrTextureAccess  fMaskTextureAccess;
115 
116     typedef GrFragmentProcessor INHERITED;
117 };
118 
119 class GrGLAlphaThresholdEffect : public GrGLFragmentProcessor {
120 public:
121     GrGLAlphaThresholdEffect(const GrBackendProcessorFactory&, const GrProcessor&);
122 
123     virtual void emitCode(GrGLProgramBuilder*,
124                           const GrFragmentProcessor&,
125                           const GrProcessorKey&,
126                           const char* outputColor,
127                           const char* inputColor,
128                           const TransformedCoordsArray&,
129                           const TextureSamplerArray&) SK_OVERRIDE;
130 
131     virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE;
132 
133 private:
134 
135     GrGLProgramDataManager::UniformHandle fInnerThresholdVar;
136     GrGLProgramDataManager::UniformHandle fOuterThresholdVar;
137 
138     typedef GrGLFragmentProcessor INHERITED;
139 };
140 
GrGLAlphaThresholdEffect(const GrBackendProcessorFactory & factory,const GrProcessor &)141 GrGLAlphaThresholdEffect::GrGLAlphaThresholdEffect(const GrBackendProcessorFactory& factory,
142                                                    const GrProcessor&)
143     : INHERITED(factory) {
144 }
145 
emitCode(GrGLProgramBuilder * builder,const GrFragmentProcessor &,const GrProcessorKey & key,const char * outputColor,const char * inputColor,const TransformedCoordsArray & coords,const TextureSamplerArray & samplers)146 void GrGLAlphaThresholdEffect::emitCode(GrGLProgramBuilder* builder,
147                                         const GrFragmentProcessor&,
148                                         const GrProcessorKey& key,
149                                         const char* outputColor,
150                                         const char* inputColor,
151                                         const TransformedCoordsArray& coords,
152                                         const TextureSamplerArray& samplers) {
153     fInnerThresholdVar = builder->addUniform(
154         GrGLProgramBuilder::kFragment_Visibility,
155         kFloat_GrSLType, "inner_threshold");
156     fOuterThresholdVar = builder->addUniform(
157         GrGLProgramBuilder::kFragment_Visibility,
158         kFloat_GrSLType, "outer_threshold");
159 
160     GrGLFragmentShaderBuilder* fsBuilder = builder->getFragmentShaderBuilder();
161     SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0);
162     SkString maskCoords2D = fsBuilder->ensureFSCoords2D(coords, 1);
163 
164     fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str());
165     fsBuilder->codeAppendf("\t\tvec2 mask_coord = %s;\n", maskCoords2D.c_str());
166     fsBuilder->codeAppend("\t\tvec4 input_color = ");
167     fsBuilder->appendTextureLookup(samplers[0], "coord");
168     fsBuilder->codeAppend(";\n");
169     fsBuilder->codeAppend("\t\tvec4 mask_color = ");
170     fsBuilder->appendTextureLookup(samplers[1], "mask_coord");
171     fsBuilder->codeAppend(";\n");
172 
173     fsBuilder->codeAppendf("\t\tfloat inner_thresh = %s;\n",
174                            builder->getUniformCStr(fInnerThresholdVar));
175     fsBuilder->codeAppendf("\t\tfloat outer_thresh = %s;\n",
176                            builder->getUniformCStr(fOuterThresholdVar));
177     fsBuilder->codeAppend("\t\tfloat mask = mask_color.a;\n");
178 
179     fsBuilder->codeAppend("vec4 color = input_color;\n");
180     fsBuilder->codeAppend("\t\tif (mask < 0.5) {\n"
181                           "\t\t\tif (color.a > outer_thresh) {\n"
182                           "\t\t\t\tfloat scale = outer_thresh / color.a;\n"
183                           "\t\t\t\tcolor.rgb *= scale;\n"
184                           "\t\t\t\tcolor.a = outer_thresh;\n"
185                           "\t\t\t}\n"
186                           "\t\t} else if (color.a < inner_thresh) {\n"
187                           "\t\t\tfloat scale = inner_thresh / max(0.001, color.a);\n"
188                           "\t\t\tcolor.rgb *= scale;\n"
189                           "\t\t\tcolor.a = inner_thresh;\n"
190                           "\t\t}\n");
191 
192     fsBuilder->codeAppendf("%s = %s;\n", outputColor,
193                            (GrGLSLExpr4(inputColor) * GrGLSLExpr4("color")).c_str());
194 }
195 
setData(const GrGLProgramDataManager & pdman,const GrProcessor & proc)196 void GrGLAlphaThresholdEffect::setData(const GrGLProgramDataManager& pdman,
197                                        const GrProcessor& proc) {
198     const AlphaThresholdEffect& alpha_threshold = proc.cast<AlphaThresholdEffect>();
199     pdman.set1f(fInnerThresholdVar, alpha_threshold.innerThreshold());
200     pdman.set1f(fOuterThresholdVar, alpha_threshold.outerThreshold());
201 }
202 
203 /////////////////////////////////////////////////////////////////////
204 
205 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(AlphaThresholdEffect);
206 
TestCreate(SkRandom * random,GrContext * context,const GrDrawTargetCaps &,GrTexture ** textures)207 GrFragmentProcessor* AlphaThresholdEffect::TestCreate(SkRandom* random,
208                                            GrContext* context,
209                                            const GrDrawTargetCaps&,
210                                            GrTexture** textures) {
211     GrTexture* bmpTex = textures[GrProcessorUnitTest::kSkiaPMTextureIdx];
212     GrTexture* maskTex = textures[GrProcessorUnitTest::kAlphaTextureIdx];
213     float inner_thresh = random->nextUScalar1();
214     float outer_thresh = random->nextUScalar1();
215     return AlphaThresholdEffect::Create(bmpTex, maskTex, inner_thresh, outer_thresh);
216 }
217 
218 ///////////////////////////////////////////////////////////////////////////////
219 
getFactory() const220 const GrBackendFragmentProcessorFactory& AlphaThresholdEffect::getFactory() const {
221     return GrTBackendFragmentProcessorFactory<AlphaThresholdEffect>::getInstance();
222 }
223 
onIsEqual(const GrProcessor & sBase) const224 bool AlphaThresholdEffect::onIsEqual(const GrProcessor& sBase) const {
225     const AlphaThresholdEffect& s = sBase.cast<AlphaThresholdEffect>();
226     return (this->texture(0) == s.texture(0) &&
227             this->fInnerThreshold == s.fInnerThreshold &&
228             this->fOuterThreshold == s.fOuterThreshold);
229 }
230 
getConstantColorComponents(GrColor * color,uint32_t * validFlags) const231 void AlphaThresholdEffect::getConstantColorComponents(GrColor* color, uint32_t* validFlags) const {
232     if ((*validFlags & kA_GrColorComponentFlag) && 0xFF == GrColorUnpackA(*color) &&
233         GrPixelConfigIsOpaque(this->texture(0)->config())) {
234         *validFlags = kA_GrColorComponentFlag;
235     } else {
236         *validFlags = 0;
237     }
238 }
239 
240 #endif
241 
242 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
SkAlphaThresholdFilterImpl(SkReadBuffer & buffer)243 SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(SkReadBuffer& buffer)
244   : INHERITED(1, buffer) {
245     fInnerThreshold = buffer.readScalar();
246     fOuterThreshold = buffer.readScalar();
247     buffer.readRegion(&fRegion);
248 }
249 #endif
250 
CreateProc(SkReadBuffer & buffer)251 SkFlattenable* SkAlphaThresholdFilterImpl::CreateProc(SkReadBuffer& buffer) {
252     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
253     SkScalar inner = buffer.readScalar();
254     SkScalar outer = buffer.readScalar();
255     SkRegion rgn;
256     buffer.readRegion(&rgn);
257     return SkAlphaThresholdFilter::Create(rgn, inner, outer, common.getInput(0));
258 }
259 
SkAlphaThresholdFilterImpl(const SkRegion & region,SkScalar innerThreshold,SkScalar outerThreshold,SkImageFilter * input)260 SkAlphaThresholdFilterImpl::SkAlphaThresholdFilterImpl(const SkRegion& region,
261                                                        SkScalar innerThreshold,
262                                                        SkScalar outerThreshold,
263                                                        SkImageFilter* input)
264     : INHERITED(1, &input)
265     , fRegion(region)
266     , fInnerThreshold(innerThreshold)
267     , fOuterThreshold(outerThreshold) {
268 }
269 
270 #if SK_SUPPORT_GPU
asFragmentProcessor(GrFragmentProcessor ** fp,GrTexture * texture,const SkMatrix & in_matrix,const SkIRect &) const271 bool SkAlphaThresholdFilterImpl::asFragmentProcessor(GrFragmentProcessor** fp,
272                                                      GrTexture* texture,
273                                                      const SkMatrix& in_matrix,
274                                                      const SkIRect&) const {
275     if (fp) {
276         GrContext* context = texture->getContext();
277         GrTextureDesc maskDesc;
278         if (context->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
279             maskDesc.fConfig = kAlpha_8_GrPixelConfig;
280         } else {
281             maskDesc.fConfig = kRGBA_8888_GrPixelConfig;
282         }
283         maskDesc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
284         // Add one pixel of border to ensure that clamp mode will be all zeros
285         // the outside.
286         maskDesc.fWidth = texture->width();
287         maskDesc.fHeight = texture->height();
288         GrAutoScratchTexture ast(context, maskDesc, GrContext::kApprox_ScratchTexMatch);
289         GrTexture*  maskTexture = ast.texture();
290         if (NULL == maskTexture) {
291             return false;
292         }
293 
294         {
295             GrContext::AutoRenderTarget art(context, ast.texture()->asRenderTarget());
296             GrPaint grPaint;
297             grPaint.setBlendFunc(kOne_GrBlendCoeff, kZero_GrBlendCoeff);
298             SkRegion::Iterator iter(fRegion);
299             context->clear(NULL, 0x0, true);
300 
301             SkMatrix old_matrix = context->getMatrix();
302             context->setMatrix(in_matrix);
303 
304             while (!iter.done()) {
305                 SkRect rect = SkRect::Make(iter.rect());
306                 context->drawRect(grPaint, rect);
307                 iter.next();
308             }
309             context->setMatrix(old_matrix);
310         }
311 
312         *fp = AlphaThresholdEffect::Create(texture,
313                                            maskTexture,
314                                            fInnerThreshold,
315                                            fOuterThreshold);
316     }
317     return true;
318 }
319 #endif
320 
flatten(SkWriteBuffer & buffer) const321 void SkAlphaThresholdFilterImpl::flatten(SkWriteBuffer& buffer) const {
322     this->INHERITED::flatten(buffer);
323     buffer.writeScalar(fInnerThreshold);
324     buffer.writeScalar(fOuterThreshold);
325     buffer.writeRegion(fRegion);
326 }
327 
onFilterImage(Proxy *,const SkBitmap & src,const Context & ctx,SkBitmap * dst,SkIPoint * offset) const328 bool SkAlphaThresholdFilterImpl::onFilterImage(Proxy*, const SkBitmap& src,
329                                                const Context& ctx, SkBitmap* dst,
330                                                SkIPoint* offset) const {
331     SkASSERT(src.colorType() == kN32_SkColorType);
332 
333     if (src.colorType() != kN32_SkColorType) {
334         return false;
335     }
336 
337     SkMatrix localInverse;
338     if (!ctx.ctm().invert(&localInverse)) {
339         return false;
340     }
341 
342     SkAutoLockPixels alp(src);
343     SkASSERT(src.getPixels());
344     if (!src.getPixels() || src.width() <= 0 || src.height() <= 0) {
345         return false;
346     }
347 
348     if (!dst->tryAllocPixels(src.info())) {
349         return false;
350     }
351 
352     U8CPU innerThreshold = (U8CPU)(fInnerThreshold * 0xFF);
353     U8CPU outerThreshold = (U8CPU)(fOuterThreshold * 0xFF);
354     SkColor* sptr = src.getAddr32(0, 0);
355     SkColor* dptr = dst->getAddr32(0, 0);
356     int width = src.width(), height = src.height();
357     for (int y = 0; y < height; ++y) {
358         for (int x = 0; x < width; ++x) {
359             const SkColor& source = sptr[y * width + x];
360             SkColor output_color(source);
361             SkPoint position;
362             localInverse.mapXY((SkScalar)x, (SkScalar)y, &position);
363             if (fRegion.contains((int32_t)position.x(), (int32_t)position.y())) {
364                 if (SkColorGetA(source) < innerThreshold) {
365                     U8CPU alpha = SkColorGetA(source);
366                     if (alpha == 0)
367                         alpha = 1;
368                     float scale = (float)innerThreshold / alpha;
369                     output_color = SkColorSetARGB(innerThreshold,
370                                                   (U8CPU)(SkColorGetR(source) * scale),
371                                                   (U8CPU)(SkColorGetG(source) * scale),
372                                                   (U8CPU)(SkColorGetB(source) * scale));
373                 }
374             } else {
375                 if (SkColorGetA(source) > outerThreshold) {
376                     float scale = (float)outerThreshold / SkColorGetA(source);
377                     output_color = SkColorSetARGB(outerThreshold,
378                                                   (U8CPU)(SkColorGetR(source) * scale),
379                                                   (U8CPU)(SkColorGetG(source) * scale),
380                                                   (U8CPU)(SkColorGetB(source) * scale));
381                 }
382             }
383             dptr[y * dst->width() + x] = output_color;
384         }
385     }
386 
387     return true;
388 }
389