SkMagnifierImageFilter.cpp revision 1598899975ecc85b003a59740b588d1ddbcedb09
1/* 2 * Copyright 2012 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#include "SkBitmap.h" 9#include "SkMagnifierImageFilter.h" 10#include "SkColorPriv.h" 11#include "SkReadBuffer.h" 12#include "SkWriteBuffer.h" 13#include "SkValidationUtils.h" 14 15//////////////////////////////////////////////////////////////////////////////// 16#if SK_SUPPORT_GPU 17#include "effects/GrSingleTextureEffect.h" 18#include "gl/GrGLProcessor.h" 19#include "gl/builders/GrGLProgramBuilder.h" 20#include "gl/GrGLSL.h" 21#include "gl/GrGLTexture.h" 22#include "GrTBackendProcessorFactory.h" 23 24class GrGLMagnifierEffect; 25 26class GrMagnifierEffect : public GrSingleTextureEffect { 27 28public: 29 static GrFragmentProcessor* Create(GrTexture* texture, 30 float xOffset, 31 float yOffset, 32 float xInvZoom, 33 float yInvZoom, 34 float xInvInset, 35 float yInvInset) { 36 return SkNEW_ARGS(GrMagnifierEffect, (texture, 37 xOffset, 38 yOffset, 39 xInvZoom, 40 yInvZoom, 41 xInvInset, 42 yInvInset)); 43 } 44 45 virtual ~GrMagnifierEffect() {}; 46 47 static const char* Name() { return "Magnifier"; } 48 49 virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE; 50 float x_offset() const { return fXOffset; } 51 float y_offset() const { return fYOffset; } 52 float x_inv_zoom() const { return fXInvZoom; } 53 float y_inv_zoom() const { return fYInvZoom; } 54 float x_inv_inset() const { return fXInvInset; } 55 float y_inv_inset() const { return fYInvInset; } 56 57 typedef GrGLMagnifierEffect GLProcessor; 58 59private: 60 GrMagnifierEffect(GrTexture* texture, 61 float xOffset, 62 float yOffset, 63 float xInvZoom, 64 float yInvZoom, 65 float xInvInset, 66 float yInvInset) 67 : GrSingleTextureEffect(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture)) 68 , fXOffset(xOffset) 69 , fYOffset(yOffset) 70 , fXInvZoom(xInvZoom) 71 , fYInvZoom(yInvZoom) 72 , fXInvInset(xInvInset) 73 , fYInvInset(yInvInset) {} 74 75 virtual bool onIsEqual(const GrProcessor&) const SK_OVERRIDE; 76 77 virtual void onComputeInvariantOutput(InvariantOutput* inout) const SK_OVERRIDE; 78 79 GR_DECLARE_FRAGMENT_PROCESSOR_TEST; 80 81 float fXOffset; 82 float fYOffset; 83 float fXInvZoom; 84 float fYInvZoom; 85 float fXInvInset; 86 float fYInvInset; 87 88 typedef GrSingleTextureEffect INHERITED; 89}; 90 91// For brevity 92typedef GrGLProgramDataManager::UniformHandle UniformHandle; 93 94class GrGLMagnifierEffect : public GrGLFragmentProcessor { 95public: 96 GrGLMagnifierEffect(const GrBackendProcessorFactory&, const GrProcessor&); 97 98 virtual void emitCode(GrGLFPBuilder*, 99 const GrFragmentProcessor&, 100 const GrProcessorKey&, 101 const char* outputColor, 102 const char* inputColor, 103 const TransformedCoordsArray&, 104 const TextureSamplerArray&) SK_OVERRIDE; 105 106 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&) SK_OVERRIDE; 107 108private: 109 UniformHandle fOffsetVar; 110 UniformHandle fInvZoomVar; 111 UniformHandle fInvInsetVar; 112 113 typedef GrGLFragmentProcessor INHERITED; 114}; 115 116GrGLMagnifierEffect::GrGLMagnifierEffect(const GrBackendProcessorFactory& factory, 117 const GrProcessor&) 118 : INHERITED(factory) { 119} 120 121void GrGLMagnifierEffect::emitCode(GrGLFPBuilder* builder, 122 const GrFragmentProcessor&, 123 const GrProcessorKey& key, 124 const char* outputColor, 125 const char* inputColor, 126 const TransformedCoordsArray& coords, 127 const TextureSamplerArray& samplers) { 128 fOffsetVar = builder->addUniform( 129 GrGLProgramBuilder::kFragment_Visibility | 130 GrGLProgramBuilder::kVertex_Visibility, 131 kVec2f_GrSLType, "Offset"); 132 fInvZoomVar = builder->addUniform( 133 GrGLProgramBuilder::kFragment_Visibility | 134 GrGLProgramBuilder::kVertex_Visibility, 135 kVec2f_GrSLType, "InvZoom"); 136 fInvInsetVar = builder->addUniform( 137 GrGLProgramBuilder::kFragment_Visibility | 138 GrGLProgramBuilder::kVertex_Visibility, 139 kVec2f_GrSLType, "InvInset"); 140 141 GrGLFPFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder(); 142 SkString coords2D = fsBuilder->ensureFSCoords2D(coords, 0); 143 fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str()); 144 fsBuilder->codeAppendf("\t\tvec2 zoom_coord = %s + %s * %s;\n", 145 builder->getUniformCStr(fOffsetVar), 146 coords2D.c_str(), 147 builder->getUniformCStr(fInvZoomVar)); 148 149 fsBuilder->codeAppend("\t\tvec2 delta = min(coord, vec2(1.0, 1.0) - coord);\n"); 150 151 fsBuilder->codeAppendf("\t\tdelta = delta * %s;\n", builder->getUniformCStr(fInvInsetVar)); 152 153 fsBuilder->codeAppend("\t\tfloat weight = 0.0;\n"); 154 fsBuilder->codeAppend("\t\tif (delta.s < 2.0 && delta.t < 2.0) {\n"); 155 fsBuilder->codeAppend("\t\t\tdelta = vec2(2.0, 2.0) - delta;\n"); 156 fsBuilder->codeAppend("\t\t\tfloat dist = length(delta);\n"); 157 fsBuilder->codeAppend("\t\t\tdist = max(2.0 - dist, 0.0);\n"); 158 fsBuilder->codeAppend("\t\t\tweight = min(dist * dist, 1.0);\n"); 159 fsBuilder->codeAppend("\t\t} else {\n"); 160 fsBuilder->codeAppend("\t\t\tvec2 delta_squared = delta * delta;\n"); 161 fsBuilder->codeAppend("\t\t\tweight = min(min(delta_squared.x, delta_squared.y), 1.0);\n"); 162 fsBuilder->codeAppend("\t\t}\n"); 163 164 fsBuilder->codeAppend("\t\tvec2 mix_coord = mix(coord, zoom_coord, weight);\n"); 165 fsBuilder->codeAppend("\t\tvec4 output_color = "); 166 fsBuilder->appendTextureLookup(samplers[0], "mix_coord"); 167 fsBuilder->codeAppend(";\n"); 168 169 fsBuilder->codeAppendf("\t\t%s = output_color;", outputColor); 170 SkString modulate; 171 GrGLSLMulVarBy4f(&modulate, outputColor, inputColor); 172 fsBuilder->codeAppend(modulate.c_str()); 173} 174 175void GrGLMagnifierEffect::setData(const GrGLProgramDataManager& pdman, 176 const GrProcessor& effect) { 177 const GrMagnifierEffect& zoom = effect.cast<GrMagnifierEffect>(); 178 pdman.set2f(fOffsetVar, zoom.x_offset(), zoom.y_offset()); 179 pdman.set2f(fInvZoomVar, zoom.x_inv_zoom(), zoom.y_inv_zoom()); 180 pdman.set2f(fInvInsetVar, zoom.x_inv_inset(), zoom.y_inv_inset()); 181} 182 183///////////////////////////////////////////////////////////////////// 184 185GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrMagnifierEffect); 186 187GrFragmentProcessor* GrMagnifierEffect::TestCreate(SkRandom* random, 188 GrContext* context, 189 const GrDrawTargetCaps&, 190 GrTexture** textures) { 191 GrTexture* texture = textures[0]; 192 const int kMaxWidth = 200; 193 const int kMaxHeight = 200; 194 const int kMaxInset = 20; 195 uint32_t width = random->nextULessThan(kMaxWidth); 196 uint32_t height = random->nextULessThan(kMaxHeight); 197 uint32_t x = random->nextULessThan(kMaxWidth - width); 198 uint32_t y = random->nextULessThan(kMaxHeight - height); 199 uint32_t inset = random->nextULessThan(kMaxInset); 200 201 GrFragmentProcessor* effect = GrMagnifierEffect::Create( 202 texture, 203 (float) width / texture->width(), 204 (float) height / texture->height(), 205 texture->width() / (float) x, 206 texture->height() / (float) y, 207 (float) inset / texture->width(), 208 (float) inset / texture->height()); 209 SkASSERT(effect); 210 return effect; 211} 212 213/////////////////////////////////////////////////////////////////////////////// 214 215const GrBackendFragmentProcessorFactory& GrMagnifierEffect::getFactory() const { 216 return GrTBackendFragmentProcessorFactory<GrMagnifierEffect>::getInstance(); 217} 218 219bool GrMagnifierEffect::onIsEqual(const GrProcessor& sBase) const { 220 const GrMagnifierEffect& s = sBase.cast<GrMagnifierEffect>(); 221 return (this->texture(0) == s.texture(0) && 222 this->fXOffset == s.fXOffset && 223 this->fYOffset == s.fYOffset && 224 this->fXInvZoom == s.fXInvZoom && 225 this->fYInvZoom == s.fYInvZoom && 226 this->fXInvInset == s.fXInvInset && 227 this->fYInvInset == s.fYInvInset); 228} 229 230void GrMagnifierEffect::onComputeInvariantOutput(InvariantOutput* inout) const { 231 this->updateInvariantOutputForModulation(inout); 232 inout->fIsSingleComponent = false; 233} 234 235#endif 236 237//////////////////////////////////////////////////////////////////////////////// 238 239SkImageFilter* SkMagnifierImageFilter::Create(const SkRect& srcRect, SkScalar inset, 240 SkImageFilter* input) { 241 242 if (!SkScalarIsFinite(inset) || !SkIsValidRect(srcRect)) { 243 return NULL; 244 } 245 // Negative numbers in src rect are not supported 246 if (srcRect.fLeft < 0 || srcRect.fTop < 0) { 247 return NULL; 248 } 249 return SkNEW_ARGS(SkMagnifierImageFilter, (srcRect, inset, input)); 250} 251 252 253#ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING 254SkMagnifierImageFilter::SkMagnifierImageFilter(SkReadBuffer& buffer) 255 : INHERITED(1, buffer) { 256 float x = buffer.readScalar(); 257 float y = buffer.readScalar(); 258 float width = buffer.readScalar(); 259 float height = buffer.readScalar(); 260 fSrcRect = SkRect::MakeXYWH(x, y, width, height); 261 fInset = buffer.readScalar(); 262 263 buffer.validate(SkScalarIsFinite(fInset) && SkIsValidRect(fSrcRect) && 264 // Negative numbers in src rect are not supported 265 (fSrcRect.fLeft >= 0) && (fSrcRect.fTop >= 0)); 266} 267#endif 268 269SkMagnifierImageFilter::SkMagnifierImageFilter(const SkRect& srcRect, SkScalar inset, 270 SkImageFilter* input) 271 : INHERITED(1, &input), fSrcRect(srcRect), fInset(inset) { 272 SkASSERT(srcRect.x() >= 0 && srcRect.y() >= 0 && inset >= 0); 273} 274 275#if SK_SUPPORT_GPU 276bool SkMagnifierImageFilter::asFragmentProcessor(GrFragmentProcessor** fp, GrTexture* texture, 277 const SkMatrix&, const SkIRect&) const { 278 if (fp) { 279 SkScalar yOffset = (texture->origin() == kTopLeft_GrSurfaceOrigin) ? fSrcRect.y() : 280 (texture->height() - (fSrcRect.y() + fSrcRect.height())); 281 SkScalar invInset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1; 282 *fp = GrMagnifierEffect::Create(texture, 283 fSrcRect.x() / texture->width(), 284 yOffset / texture->height(), 285 fSrcRect.width() / texture->width(), 286 fSrcRect.height() / texture->height(), 287 texture->width() * invInset, 288 texture->height() * invInset); 289 } 290 return true; 291} 292#endif 293 294SkFlattenable* SkMagnifierImageFilter::CreateProc(SkReadBuffer& buffer) { 295 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1); 296 SkRect src; 297 buffer.readRect(&src); 298 return Create(src, buffer.readScalar(), common.getInput(0)); 299} 300 301void SkMagnifierImageFilter::flatten(SkWriteBuffer& buffer) const { 302 this->INHERITED::flatten(buffer); 303 buffer.writeRect(fSrcRect); 304 buffer.writeScalar(fInset); 305} 306 307bool SkMagnifierImageFilter::onFilterImage(Proxy*, const SkBitmap& src, 308 const Context&, SkBitmap* dst, 309 SkIPoint* offset) const { 310 SkASSERT(src.colorType() == kN32_SkColorType); 311 SkASSERT(fSrcRect.width() < src.width()); 312 SkASSERT(fSrcRect.height() < src.height()); 313 314 if ((src.colorType() != kN32_SkColorType) || 315 (fSrcRect.width() >= src.width()) || 316 (fSrcRect.height() >= src.height())) { 317 return false; 318 } 319 320 SkAutoLockPixels alp(src); 321 SkASSERT(src.getPixels()); 322 if (!src.getPixels() || src.width() <= 0 || src.height() <= 0) { 323 return false; 324 } 325 326 if (!dst->tryAllocPixels(src.info())) { 327 return false; 328 } 329 330 SkScalar inv_inset = fInset > 0 ? SkScalarInvert(fInset) : SK_Scalar1; 331 332 SkScalar inv_x_zoom = fSrcRect.width() / src.width(); 333 SkScalar inv_y_zoom = fSrcRect.height() / src.height(); 334 335 SkColor* sptr = src.getAddr32(0, 0); 336 SkColor* dptr = dst->getAddr32(0, 0); 337 int width = src.width(), height = src.height(); 338 for (int y = 0; y < height; ++y) { 339 for (int x = 0; x < width; ++x) { 340 SkScalar x_dist = SkMin32(x, width - x - 1) * inv_inset; 341 SkScalar y_dist = SkMin32(y, height - y - 1) * inv_inset; 342 SkScalar weight = 0; 343 344 static const SkScalar kScalar2 = SkScalar(2); 345 346 // To create a smooth curve at the corners, we need to work on 347 // a square twice the size of the inset. 348 if (x_dist < kScalar2 && y_dist < kScalar2) { 349 x_dist = kScalar2 - x_dist; 350 y_dist = kScalar2 - y_dist; 351 352 SkScalar dist = SkScalarSqrt(SkScalarSquare(x_dist) + 353 SkScalarSquare(y_dist)); 354 dist = SkMaxScalar(kScalar2 - dist, 0); 355 weight = SkMinScalar(SkScalarSquare(dist), SK_Scalar1); 356 } else { 357 SkScalar sqDist = SkMinScalar(SkScalarSquare(x_dist), 358 SkScalarSquare(y_dist)); 359 weight = SkMinScalar(sqDist, SK_Scalar1); 360 } 361 362 SkScalar x_interp = SkScalarMul(weight, (fSrcRect.x() + x * inv_x_zoom)) + 363 (SK_Scalar1 - weight) * x; 364 SkScalar y_interp = SkScalarMul(weight, (fSrcRect.y() + y * inv_y_zoom)) + 365 (SK_Scalar1 - weight) * y; 366 367 int x_val = SkPin32(SkScalarFloorToInt(x_interp), 0, width - 1); 368 int y_val = SkPin32(SkScalarFloorToInt(y_interp), 0, height - 1); 369 370 *dptr = sptr[y_val * width + x_val]; 371 dptr++; 372 } 373 } 374 return true; 375} 376