SkBlurMF.cpp 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935
  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. #include "include/core/SkMaskFilter.h"
  8. #include "include/core/SkRRect.h"
  9. #include "include/core/SkStrokeRec.h"
  10. #include "include/core/SkVertices.h"
  11. #include "src/core/SkBlurMask.h"
  12. #include "src/core/SkBlurPriv.h"
  13. #include "src/core/SkGpuBlurUtils.h"
  14. #include "src/core/SkMaskFilterBase.h"
  15. #include "src/core/SkRRectPriv.h"
  16. #include "src/core/SkReadBuffer.h"
  17. #include "src/core/SkStringUtils.h"
  18. #include "src/core/SkWriteBuffer.h"
  19. #if SK_SUPPORT_GPU
  20. #include "include/private/GrRecordingContext.h"
  21. #include "src/gpu/GrClip.h"
  22. #include "src/gpu/GrFragmentProcessor.h"
  23. #include "src/gpu/GrRecordingContextPriv.h"
  24. #include "src/gpu/GrRenderTargetContext.h"
  25. #include "src/gpu/GrResourceProvider.h"
  26. #include "src/gpu/GrShaderCaps.h"
  27. #include "src/gpu/GrStyle.h"
  28. #include "src/gpu/GrTextureProxy.h"
  29. #include "src/gpu/effects/GrTextureDomain.h"
  30. #include "src/gpu/effects/generated/GrCircleBlurFragmentProcessor.h"
  31. #include "src/gpu/effects/generated/GrRRectBlurEffect.h"
  32. #include "src/gpu/effects/generated/GrRectBlurEffect.h"
  33. #include "src/gpu/effects/generated/GrSimpleTextureEffect.h"
  34. #include "src/gpu/geometry/GrShape.h"
  35. #include "src/gpu/glsl/GrGLSLFragmentProcessor.h"
  36. #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
  37. #include "src/gpu/glsl/GrGLSLProgramDataManager.h"
  38. #include "src/gpu/glsl/GrGLSLUniformHandler.h"
  39. #endif
  40. class SkBlurMaskFilterImpl : public SkMaskFilterBase {
  41. public:
  42. SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle, bool respectCTM);
  43. // overrides from SkMaskFilter
  44. SkMask::Format getFormat() const override;
  45. bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
  46. SkIPoint* margin) const override;
  47. #if SK_SUPPORT_GPU
  48. bool canFilterMaskGPU(const GrShape& shape,
  49. const SkIRect& devSpaceShapeBounds,
  50. const SkIRect& clipBounds,
  51. const SkMatrix& ctm,
  52. SkIRect* maskRect) const override;
  53. bool directFilterMaskGPU(GrRecordingContext*,
  54. GrRenderTargetContext* renderTargetContext,
  55. GrPaint&&,
  56. const GrClip&,
  57. const SkMatrix& viewMatrix,
  58. const GrShape& shape) const override;
  59. sk_sp<GrTextureProxy> filterMaskGPU(GrRecordingContext*,
  60. sk_sp<GrTextureProxy> srcProxy,
  61. const SkMatrix& ctm,
  62. const SkIRect& maskRect) const override;
  63. #endif
  64. void computeFastBounds(const SkRect&, SkRect*) const override;
  65. bool asABlur(BlurRec*) const override;
  66. protected:
  67. FilterReturn filterRectsToNine(const SkRect[], int count, const SkMatrix&,
  68. const SkIRect& clipBounds,
  69. NinePatch*) const override;
  70. FilterReturn filterRRectToNine(const SkRRect&, const SkMatrix&,
  71. const SkIRect& clipBounds,
  72. NinePatch*) const override;
  73. bool filterRectMask(SkMask* dstM, const SkRect& r, const SkMatrix& matrix,
  74. SkIPoint* margin, SkMask::CreateMode createMode) const;
  75. bool filterRRectMask(SkMask* dstM, const SkRRect& r, const SkMatrix& matrix,
  76. SkIPoint* margin, SkMask::CreateMode createMode) const;
  77. bool ignoreXform() const { return !fRespectCTM; }
  78. private:
  79. SK_FLATTENABLE_HOOKS(SkBlurMaskFilterImpl)
  80. // To avoid unseemly allocation requests (esp. for finite platforms like
  81. // handset) we limit the radius so something manageable. (as opposed to
  82. // a request like 10,000)
  83. static const SkScalar kMAX_BLUR_SIGMA;
  84. SkScalar fSigma;
  85. SkBlurStyle fBlurStyle;
  86. bool fRespectCTM;
  87. SkBlurMaskFilterImpl(SkReadBuffer&);
  88. void flatten(SkWriteBuffer&) const override;
  89. SkScalar computeXformedSigma(const SkMatrix& ctm) const {
  90. SkScalar xformedSigma = this->ignoreXform() ? fSigma : ctm.mapRadius(fSigma);
  91. return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
  92. }
  93. friend class SkBlurMaskFilter;
  94. typedef SkMaskFilter INHERITED;
  95. friend void sk_register_blur_maskfilter_createproc();
  96. };
  97. const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
  98. // linearly interpolate between y1 & y3 to match x2's position between x1 & x3
  99. static SkScalar interp(SkScalar x1, SkScalar x2, SkScalar x3, SkScalar y1, SkScalar y3) {
  100. SkASSERT(x1 <= x2 && x2 <= x3);
  101. SkASSERT(y1 <= y3);
  102. SkScalar t = (x2 - x1) / (x3 - x1);
  103. return y1 + t * (y3 - y1);
  104. }
  105. // Insert 'lower' and 'higher' into 'array1' and insert a new value at each matching insertion
  106. // point in 'array2' that linearly interpolates between the existing values.
  107. // Return a bit mask which contains a copy of 'inputMask' for all the cells between the two
  108. // insertion points.
  109. static uint32_t insert_into_arrays(SkScalar* array1, SkScalar* array2,
  110. SkScalar lower, SkScalar higher,
  111. int* num, uint32_t inputMask, int maskSize) {
  112. SkASSERT(lower < higher);
  113. SkASSERT(lower >= array1[0] && higher <= array1[*num-1]);
  114. int32_t skipMask = 0x0;
  115. int i;
  116. for (i = 0; i < *num; ++i) {
  117. if (lower >= array1[i] && lower < array1[i+1]) {
  118. if (!SkScalarNearlyEqual(lower, array1[i])) {
  119. memmove(&array1[i+2], &array1[i+1], (*num-i-1)*sizeof(SkScalar));
  120. array1[i+1] = lower;
  121. memmove(&array2[i+2], &array2[i+1], (*num-i-1)*sizeof(SkScalar));
  122. array2[i+1] = interp(array1[i], lower, array1[i+2], array2[i], array2[i+2]);
  123. i++;
  124. (*num)++;
  125. }
  126. break;
  127. }
  128. }
  129. for ( ; i < *num; ++i) {
  130. skipMask |= inputMask << (i*maskSize);
  131. if (higher > array1[i] && higher <= array1[i+1]) {
  132. if (!SkScalarNearlyEqual(higher, array1[i+1])) {
  133. memmove(&array1[i+2], &array1[i+1], (*num-i-1)*sizeof(SkScalar));
  134. array1[i+1] = higher;
  135. memmove(&array2[i+2], &array2[i+1], (*num-i-1)*sizeof(SkScalar));
  136. array2[i+1] = interp(array1[i], higher, array1[i+2], array2[i], array2[i+2]);
  137. (*num)++;
  138. }
  139. break;
  140. }
  141. }
  142. return skipMask;
  143. }
  144. bool SkComputeBlurredRRectParams(const SkRRect& srcRRect, const SkRRect& devRRect,
  145. const SkRect& occluder,
  146. SkScalar sigma, SkScalar xformedSigma,
  147. SkRRect* rrectToDraw,
  148. SkISize* widthHeight,
  149. SkScalar rectXs[kSkBlurRRectMaxDivisions],
  150. SkScalar rectYs[kSkBlurRRectMaxDivisions],
  151. SkScalar texXs[kSkBlurRRectMaxDivisions],
  152. SkScalar texYs[kSkBlurRRectMaxDivisions],
  153. int* numXs, int* numYs, uint32_t* skipMask) {
  154. unsigned int devBlurRadius = 3*SkScalarCeilToInt(xformedSigma-1/6.0f);
  155. SkScalar srcBlurRadius = 3.0f * sigma;
  156. const SkRect& devOrig = devRRect.getBounds();
  157. const SkVector& devRadiiUL = devRRect.radii(SkRRect::kUpperLeft_Corner);
  158. const SkVector& devRadiiUR = devRRect.radii(SkRRect::kUpperRight_Corner);
  159. const SkVector& devRadiiLR = devRRect.radii(SkRRect::kLowerRight_Corner);
  160. const SkVector& devRadiiLL = devRRect.radii(SkRRect::kLowerLeft_Corner);
  161. const int devLeft = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUL.fX, devRadiiLL.fX));
  162. const int devTop = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUL.fY, devRadiiUR.fY));
  163. const int devRight = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiUR.fX, devRadiiLR.fX));
  164. const int devBot = SkScalarCeilToInt(SkTMax<SkScalar>(devRadiiLL.fY, devRadiiLR.fY));
  165. // This is a conservative check for nine-patchability
  166. if (devOrig.fLeft + devLeft + devBlurRadius >= devOrig.fRight - devRight - devBlurRadius ||
  167. devOrig.fTop + devTop + devBlurRadius >= devOrig.fBottom - devBot - devBlurRadius) {
  168. return false;
  169. }
  170. const SkVector& srcRadiiUL = srcRRect.radii(SkRRect::kUpperLeft_Corner);
  171. const SkVector& srcRadiiUR = srcRRect.radii(SkRRect::kUpperRight_Corner);
  172. const SkVector& srcRadiiLR = srcRRect.radii(SkRRect::kLowerRight_Corner);
  173. const SkVector& srcRadiiLL = srcRRect.radii(SkRRect::kLowerLeft_Corner);
  174. const SkScalar srcLeft = SkTMax<SkScalar>(srcRadiiUL.fX, srcRadiiLL.fX);
  175. const SkScalar srcTop = SkTMax<SkScalar>(srcRadiiUL.fY, srcRadiiUR.fY);
  176. const SkScalar srcRight = SkTMax<SkScalar>(srcRadiiUR.fX, srcRadiiLR.fX);
  177. const SkScalar srcBot = SkTMax<SkScalar>(srcRadiiLL.fY, srcRadiiLR.fY);
  178. int newRRWidth = 2*devBlurRadius + devLeft + devRight + 1;
  179. int newRRHeight = 2*devBlurRadius + devTop + devBot + 1;
  180. widthHeight->fWidth = newRRWidth + 2 * devBlurRadius;
  181. widthHeight->fHeight = newRRHeight + 2 * devBlurRadius;
  182. const SkRect srcProxyRect = srcRRect.getBounds().makeOutset(srcBlurRadius, srcBlurRadius);
  183. rectXs[0] = srcProxyRect.fLeft;
  184. rectXs[1] = srcProxyRect.fLeft + 2*srcBlurRadius + srcLeft;
  185. rectXs[2] = srcProxyRect.fRight - 2*srcBlurRadius - srcRight;
  186. rectXs[3] = srcProxyRect.fRight;
  187. rectYs[0] = srcProxyRect.fTop;
  188. rectYs[1] = srcProxyRect.fTop + 2*srcBlurRadius + srcTop;
  189. rectYs[2] = srcProxyRect.fBottom - 2*srcBlurRadius - srcBot;
  190. rectYs[3] = srcProxyRect.fBottom;
  191. texXs[0] = 0.0f;
  192. texXs[1] = 2.0f*devBlurRadius + devLeft;
  193. texXs[2] = 2.0f*devBlurRadius + devLeft + 1;
  194. texXs[3] = SkIntToScalar(widthHeight->fWidth);
  195. texYs[0] = 0.0f;
  196. texYs[1] = 2.0f*devBlurRadius + devTop;
  197. texYs[2] = 2.0f*devBlurRadius + devTop + 1;
  198. texYs[3] = SkIntToScalar(widthHeight->fHeight);
  199. SkRect temp = occluder;
  200. *numXs = 4;
  201. *numYs = 4;
  202. *skipMask = 0;
  203. if (!temp.isEmpty() && (srcProxyRect.contains(temp) || temp.intersect(srcProxyRect))) {
  204. *skipMask = insert_into_arrays(rectXs, texXs, temp.fLeft, temp.fRight, numXs, 0x1, 1);
  205. *skipMask = insert_into_arrays(rectYs, texYs, temp.fTop, temp.fBottom,
  206. numYs, *skipMask, *numXs-1);
  207. }
  208. const SkRect newRect = SkRect::MakeXYWH(SkIntToScalar(devBlurRadius),
  209. SkIntToScalar(devBlurRadius),
  210. SkIntToScalar(newRRWidth),
  211. SkIntToScalar(newRRHeight));
  212. SkVector newRadii[4];
  213. newRadii[0] = { SkScalarCeilToScalar(devRadiiUL.fX), SkScalarCeilToScalar(devRadiiUL.fY) };
  214. newRadii[1] = { SkScalarCeilToScalar(devRadiiUR.fX), SkScalarCeilToScalar(devRadiiUR.fY) };
  215. newRadii[2] = { SkScalarCeilToScalar(devRadiiLR.fX), SkScalarCeilToScalar(devRadiiLR.fY) };
  216. newRadii[3] = { SkScalarCeilToScalar(devRadiiLL.fX), SkScalarCeilToScalar(devRadiiLL.fY) };
  217. rrectToDraw->setRectRadii(newRect, newRadii);
  218. return true;
  219. }
  220. ///////////////////////////////////////////////////////////////////////////////
  221. SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma, SkBlurStyle style, bool respectCTM)
  222. : fSigma(sigma)
  223. , fBlurStyle(style)
  224. , fRespectCTM(respectCTM) {
  225. SkASSERT(fSigma > 0);
  226. SkASSERT((unsigned)style <= kLastEnum_SkBlurStyle);
  227. }
  228. SkMask::Format SkBlurMaskFilterImpl::getFormat() const {
  229. return SkMask::kA8_Format;
  230. }
  231. bool SkBlurMaskFilterImpl::asABlur(BlurRec* rec) const {
  232. if (this->ignoreXform()) {
  233. return false;
  234. }
  235. if (rec) {
  236. rec->fSigma = fSigma;
  237. rec->fStyle = fBlurStyle;
  238. }
  239. return true;
  240. }
  241. bool SkBlurMaskFilterImpl::filterMask(SkMask* dst, const SkMask& src,
  242. const SkMatrix& matrix,
  243. SkIPoint* margin) const {
  244. SkScalar sigma = this->computeXformedSigma(matrix);
  245. return SkBlurMask::BoxBlur(dst, src, sigma, fBlurStyle, margin);
  246. }
  247. bool SkBlurMaskFilterImpl::filterRectMask(SkMask* dst, const SkRect& r,
  248. const SkMatrix& matrix,
  249. SkIPoint* margin, SkMask::CreateMode createMode) const {
  250. SkScalar sigma = computeXformedSigma(matrix);
  251. return SkBlurMask::BlurRect(sigma, dst, r, fBlurStyle, margin, createMode);
  252. }
  253. bool SkBlurMaskFilterImpl::filterRRectMask(SkMask* dst, const SkRRect& r,
  254. const SkMatrix& matrix,
  255. SkIPoint* margin, SkMask::CreateMode createMode) const {
  256. SkScalar sigma = computeXformedSigma(matrix);
  257. return SkBlurMask::BlurRRect(sigma, dst, r, fBlurStyle, margin, createMode);
  258. }
  259. #include "include/core/SkCanvas.h"
  260. static bool prepare_to_draw_into_mask(const SkRect& bounds, SkMask* mask) {
  261. SkASSERT(mask != nullptr);
  262. mask->fBounds = bounds.roundOut();
  263. mask->fRowBytes = SkAlign4(mask->fBounds.width());
  264. mask->fFormat = SkMask::kA8_Format;
  265. const size_t size = mask->computeImageSize();
  266. mask->fImage = SkMask::AllocImage(size, SkMask::kZeroInit_Alloc);
  267. if (nullptr == mask->fImage) {
  268. return false;
  269. }
  270. return true;
  271. }
  272. static bool draw_rrect_into_mask(const SkRRect rrect, SkMask* mask) {
  273. if (!prepare_to_draw_into_mask(rrect.rect(), mask)) {
  274. return false;
  275. }
  276. // FIXME: This code duplicates code in draw_rects_into_mask, below. Is there a
  277. // clean way to share more code?
  278. SkBitmap bitmap;
  279. bitmap.installMaskPixels(*mask);
  280. SkCanvas canvas(bitmap);
  281. canvas.translate(-SkIntToScalar(mask->fBounds.left()),
  282. -SkIntToScalar(mask->fBounds.top()));
  283. SkPaint paint;
  284. paint.setAntiAlias(true);
  285. canvas.drawRRect(rrect, paint);
  286. return true;
  287. }
  288. static bool draw_rects_into_mask(const SkRect rects[], int count, SkMask* mask) {
  289. if (!prepare_to_draw_into_mask(rects[0], mask)) {
  290. return false;
  291. }
  292. SkBitmap bitmap;
  293. bitmap.installPixels(SkImageInfo::Make(mask->fBounds.width(),
  294. mask->fBounds.height(),
  295. kAlpha_8_SkColorType,
  296. kPremul_SkAlphaType),
  297. mask->fImage, mask->fRowBytes);
  298. SkCanvas canvas(bitmap);
  299. canvas.translate(-SkIntToScalar(mask->fBounds.left()),
  300. -SkIntToScalar(mask->fBounds.top()));
  301. SkPaint paint;
  302. paint.setAntiAlias(true);
  303. if (1 == count) {
  304. canvas.drawRect(rects[0], paint);
  305. } else {
  306. // todo: do I need a fast way to do this?
  307. SkPath path;
  308. path.addRect(rects[0]);
  309. path.addRect(rects[1]);
  310. path.setFillType(SkPath::kEvenOdd_FillType);
  311. canvas.drawPath(path, paint);
  312. }
  313. return true;
  314. }
  315. static bool rect_exceeds(const SkRect& r, SkScalar v) {
  316. return r.fLeft < -v || r.fTop < -v || r.fRight > v || r.fBottom > v ||
  317. r.width() > v || r.height() > v;
  318. }
  319. #include "src/core/SkMaskCache.h"
  320. static SkCachedData* copy_mask_to_cacheddata(SkMask* mask) {
  321. const size_t size = mask->computeTotalImageSize();
  322. SkCachedData* data = SkResourceCache::NewCachedData(size);
  323. if (data) {
  324. memcpy(data->writable_data(), mask->fImage, size);
  325. SkMask::FreeImage(mask->fImage);
  326. mask->fImage = (uint8_t*)data->data();
  327. }
  328. return data;
  329. }
  330. static SkCachedData* find_cached_rrect(SkMask* mask, SkScalar sigma, SkBlurStyle style,
  331. const SkRRect& rrect) {
  332. return SkMaskCache::FindAndRef(sigma, style, rrect, mask);
  333. }
  334. static SkCachedData* add_cached_rrect(SkMask* mask, SkScalar sigma, SkBlurStyle style,
  335. const SkRRect& rrect) {
  336. SkCachedData* cache = copy_mask_to_cacheddata(mask);
  337. if (cache) {
  338. SkMaskCache::Add(sigma, style, rrect, *mask, cache);
  339. }
  340. return cache;
  341. }
  342. static SkCachedData* find_cached_rects(SkMask* mask, SkScalar sigma, SkBlurStyle style,
  343. const SkRect rects[], int count) {
  344. return SkMaskCache::FindAndRef(sigma, style, rects, count, mask);
  345. }
  346. static SkCachedData* add_cached_rects(SkMask* mask, SkScalar sigma, SkBlurStyle style,
  347. const SkRect rects[], int count) {
  348. SkCachedData* cache = copy_mask_to_cacheddata(mask);
  349. if (cache) {
  350. SkMaskCache::Add(sigma, style, rects, count, *mask, cache);
  351. }
  352. return cache;
  353. }
  354. static const bool c_analyticBlurRRect{true};
  355. SkMaskFilterBase::FilterReturn
  356. SkBlurMaskFilterImpl::filterRRectToNine(const SkRRect& rrect, const SkMatrix& matrix,
  357. const SkIRect& clipBounds,
  358. NinePatch* patch) const {
  359. SkASSERT(patch != nullptr);
  360. switch (rrect.getType()) {
  361. case SkRRect::kEmpty_Type:
  362. // Nothing to draw.
  363. return kFalse_FilterReturn;
  364. case SkRRect::kRect_Type:
  365. // We should have caught this earlier.
  366. SkASSERT(false);
  367. // Fall through.
  368. case SkRRect::kOval_Type:
  369. // The nine patch special case does not handle ovals, and we
  370. // already have code for rectangles.
  371. return kUnimplemented_FilterReturn;
  372. // These three can take advantage of this fast path.
  373. case SkRRect::kSimple_Type:
  374. case SkRRect::kNinePatch_Type:
  375. case SkRRect::kComplex_Type:
  376. break;
  377. }
  378. // TODO: report correct metrics for innerstyle, where we do not grow the
  379. // total bounds, but we do need an inset the size of our blur-radius
  380. if (kInner_SkBlurStyle == fBlurStyle) {
  381. return kUnimplemented_FilterReturn;
  382. }
  383. // TODO: take clipBounds into account to limit our coordinates up front
  384. // for now, just skip too-large src rects (to take the old code path).
  385. if (rect_exceeds(rrect.rect(), SkIntToScalar(32767))) {
  386. return kUnimplemented_FilterReturn;
  387. }
  388. SkIPoint margin;
  389. SkMask srcM, dstM;
  390. srcM.fBounds = rrect.rect().roundOut();
  391. srcM.fFormat = SkMask::kA8_Format;
  392. srcM.fRowBytes = 0;
  393. bool filterResult = false;
  394. if (c_analyticBlurRRect) {
  395. // special case for fast round rect blur
  396. // don't actually do the blur the first time, just compute the correct size
  397. filterResult = this->filterRRectMask(&dstM, rrect, matrix, &margin,
  398. SkMask::kJustComputeBounds_CreateMode);
  399. }
  400. if (!filterResult) {
  401. filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
  402. }
  403. if (!filterResult) {
  404. return kFalse_FilterReturn;
  405. }
  406. // Now figure out the appropriate width and height of the smaller round rectangle
  407. // to stretch. It will take into account the larger radius per side as well as double
  408. // the margin, to account for inner and outer blur.
  409. const SkVector& UL = rrect.radii(SkRRect::kUpperLeft_Corner);
  410. const SkVector& UR = rrect.radii(SkRRect::kUpperRight_Corner);
  411. const SkVector& LR = rrect.radii(SkRRect::kLowerRight_Corner);
  412. const SkVector& LL = rrect.radii(SkRRect::kLowerLeft_Corner);
  413. const SkScalar leftUnstretched = SkTMax(UL.fX, LL.fX) + SkIntToScalar(2 * margin.fX);
  414. const SkScalar rightUnstretched = SkTMax(UR.fX, LR.fX) + SkIntToScalar(2 * margin.fX);
  415. // Extra space in the middle to ensure an unchanging piece for stretching. Use 3 to cover
  416. // any fractional space on either side plus 1 for the part to stretch.
  417. const SkScalar stretchSize = SkIntToScalar(3);
  418. const SkScalar totalSmallWidth = leftUnstretched + rightUnstretched + stretchSize;
  419. if (totalSmallWidth >= rrect.rect().width()) {
  420. // There is no valid piece to stretch.
  421. return kUnimplemented_FilterReturn;
  422. }
  423. const SkScalar topUnstretched = SkTMax(UL.fY, UR.fY) + SkIntToScalar(2 * margin.fY);
  424. const SkScalar bottomUnstretched = SkTMax(LL.fY, LR.fY) + SkIntToScalar(2 * margin.fY);
  425. const SkScalar totalSmallHeight = topUnstretched + bottomUnstretched + stretchSize;
  426. if (totalSmallHeight >= rrect.rect().height()) {
  427. // There is no valid piece to stretch.
  428. return kUnimplemented_FilterReturn;
  429. }
  430. SkRect smallR = SkRect::MakeWH(totalSmallWidth, totalSmallHeight);
  431. SkRRect smallRR;
  432. SkVector radii[4];
  433. radii[SkRRect::kUpperLeft_Corner] = UL;
  434. radii[SkRRect::kUpperRight_Corner] = UR;
  435. radii[SkRRect::kLowerRight_Corner] = LR;
  436. radii[SkRRect::kLowerLeft_Corner] = LL;
  437. smallRR.setRectRadii(smallR, radii);
  438. const SkScalar sigma = this->computeXformedSigma(matrix);
  439. SkCachedData* cache = find_cached_rrect(&patch->fMask, sigma, fBlurStyle, smallRR);
  440. if (!cache) {
  441. bool analyticBlurWorked = false;
  442. if (c_analyticBlurRRect) {
  443. analyticBlurWorked =
  444. this->filterRRectMask(&patch->fMask, smallRR, matrix, &margin,
  445. SkMask::kComputeBoundsAndRenderImage_CreateMode);
  446. }
  447. if (!analyticBlurWorked) {
  448. if (!draw_rrect_into_mask(smallRR, &srcM)) {
  449. return kFalse_FilterReturn;
  450. }
  451. SkAutoMaskFreeImage amf(srcM.fImage);
  452. if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
  453. return kFalse_FilterReturn;
  454. }
  455. }
  456. cache = add_cached_rrect(&patch->fMask, sigma, fBlurStyle, smallRR);
  457. }
  458. patch->fMask.fBounds.offsetTo(0, 0);
  459. patch->fOuterRect = dstM.fBounds;
  460. patch->fCenter.fX = SkScalarCeilToInt(leftUnstretched) + 1;
  461. patch->fCenter.fY = SkScalarCeilToInt(topUnstretched) + 1;
  462. SkASSERT(nullptr == patch->fCache);
  463. patch->fCache = cache; // transfer ownership to patch
  464. return kTrue_FilterReturn;
  465. }
  466. // Use the faster analytic blur approach for ninepatch rects
  467. static const bool c_analyticBlurNinepatch{true};
  468. SkMaskFilterBase::FilterReturn
  469. SkBlurMaskFilterImpl::filterRectsToNine(const SkRect rects[], int count,
  470. const SkMatrix& matrix,
  471. const SkIRect& clipBounds,
  472. NinePatch* patch) const {
  473. if (count < 1 || count > 2) {
  474. return kUnimplemented_FilterReturn;
  475. }
  476. // TODO: report correct metrics for innerstyle, where we do not grow the
  477. // total bounds, but we do need an inset the size of our blur-radius
  478. if (kInner_SkBlurStyle == fBlurStyle || kOuter_SkBlurStyle == fBlurStyle) {
  479. return kUnimplemented_FilterReturn;
  480. }
  481. // TODO: take clipBounds into account to limit our coordinates up front
  482. // for now, just skip too-large src rects (to take the old code path).
  483. if (rect_exceeds(rects[0], SkIntToScalar(32767))) {
  484. return kUnimplemented_FilterReturn;
  485. }
  486. SkIPoint margin;
  487. SkMask srcM, dstM;
  488. srcM.fBounds = rects[0].roundOut();
  489. srcM.fFormat = SkMask::kA8_Format;
  490. srcM.fRowBytes = 0;
  491. bool filterResult = false;
  492. if (count == 1 && c_analyticBlurNinepatch) {
  493. // special case for fast rect blur
  494. // don't actually do the blur the first time, just compute the correct size
  495. filterResult = this->filterRectMask(&dstM, rects[0], matrix, &margin,
  496. SkMask::kJustComputeBounds_CreateMode);
  497. } else {
  498. filterResult = this->filterMask(&dstM, srcM, matrix, &margin);
  499. }
  500. if (!filterResult) {
  501. return kFalse_FilterReturn;
  502. }
  503. /*
  504. * smallR is the smallest version of 'rect' that will still guarantee that
  505. * we get the same blur results on all edges, plus 1 center row/col that is
  506. * representative of the extendible/stretchable edges of the ninepatch.
  507. * Since our actual edge may be fractional we inset 1 more to be sure we
  508. * don't miss any interior blur.
  509. * x is an added pixel of blur, and { and } are the (fractional) edge
  510. * pixels from the original rect.
  511. *
  512. * x x { x x .... x x } x x
  513. *
  514. * Thus, in this case, we inset by a total of 5 (on each side) beginning
  515. * with our outer-rect (dstM.fBounds)
  516. */
  517. SkRect smallR[2];
  518. SkIPoint center;
  519. // +2 is from +1 for each edge (to account for possible fractional edges
  520. int smallW = dstM.fBounds.width() - srcM.fBounds.width() + 2;
  521. int smallH = dstM.fBounds.height() - srcM.fBounds.height() + 2;
  522. SkIRect innerIR;
  523. if (1 == count) {
  524. innerIR = srcM.fBounds;
  525. center.set(smallW, smallH);
  526. } else {
  527. SkASSERT(2 == count);
  528. rects[1].roundIn(&innerIR);
  529. center.set(smallW + (innerIR.left() - srcM.fBounds.left()),
  530. smallH + (innerIR.top() - srcM.fBounds.top()));
  531. }
  532. // +1 so we get a clean, stretchable, center row/col
  533. smallW += 1;
  534. smallH += 1;
  535. // we want the inset amounts to be integral, so we don't change any
  536. // fractional phase on the fRight or fBottom of our smallR.
  537. const SkScalar dx = SkIntToScalar(innerIR.width() - smallW);
  538. const SkScalar dy = SkIntToScalar(innerIR.height() - smallH);
  539. if (dx < 0 || dy < 0) {
  540. // we're too small, relative to our blur, to break into nine-patch,
  541. // so we ask to have our normal filterMask() be called.
  542. return kUnimplemented_FilterReturn;
  543. }
  544. smallR[0].set(rects[0].left(), rects[0].top(), rects[0].right() - dx, rects[0].bottom() - dy);
  545. if (smallR[0].width() < 2 || smallR[0].height() < 2) {
  546. return kUnimplemented_FilterReturn;
  547. }
  548. if (2 == count) {
  549. smallR[1].set(rects[1].left(), rects[1].top(),
  550. rects[1].right() - dx, rects[1].bottom() - dy);
  551. SkASSERT(!smallR[1].isEmpty());
  552. }
  553. const SkScalar sigma = this->computeXformedSigma(matrix);
  554. SkCachedData* cache = find_cached_rects(&patch->fMask, sigma, fBlurStyle, smallR, count);
  555. if (!cache) {
  556. if (count > 1 || !c_analyticBlurNinepatch) {
  557. if (!draw_rects_into_mask(smallR, count, &srcM)) {
  558. return kFalse_FilterReturn;
  559. }
  560. SkAutoMaskFreeImage amf(srcM.fImage);
  561. if (!this->filterMask(&patch->fMask, srcM, matrix, &margin)) {
  562. return kFalse_FilterReturn;
  563. }
  564. } else {
  565. if (!this->filterRectMask(&patch->fMask, smallR[0], matrix, &margin,
  566. SkMask::kComputeBoundsAndRenderImage_CreateMode)) {
  567. return kFalse_FilterReturn;
  568. }
  569. }
  570. cache = add_cached_rects(&patch->fMask, sigma, fBlurStyle, smallR, count);
  571. }
  572. patch->fMask.fBounds.offsetTo(0, 0);
  573. patch->fOuterRect = dstM.fBounds;
  574. patch->fCenter = center;
  575. SkASSERT(nullptr == patch->fCache);
  576. patch->fCache = cache; // transfer ownership to patch
  577. return kTrue_FilterReturn;
  578. }
  579. void SkBlurMaskFilterImpl::computeFastBounds(const SkRect& src,
  580. SkRect* dst) const {
  581. SkScalar pad = 3.0f * fSigma;
  582. dst->set(src.fLeft - pad, src.fTop - pad,
  583. src.fRight + pad, src.fBottom + pad);
  584. }
  585. sk_sp<SkFlattenable> SkBlurMaskFilterImpl::CreateProc(SkReadBuffer& buffer) {
  586. const SkScalar sigma = buffer.readScalar();
  587. SkBlurStyle style = buffer.read32LE(kLastEnum_SkBlurStyle);
  588. uint32_t flags = buffer.read32LE(0x3); // historically we only recorded 2 bits
  589. bool respectCTM = !(flags & 1); // historically we stored ignoreCTM in low bit
  590. if (buffer.isVersionLT(SkReadBuffer::kRemoveOccluderFromBlurMaskFilter)) {
  591. SkRect unused;
  592. buffer.readRect(&unused);
  593. }
  594. return SkMaskFilter::MakeBlur((SkBlurStyle)style, sigma, respectCTM);
  595. }
  596. void SkBlurMaskFilterImpl::flatten(SkWriteBuffer& buffer) const {
  597. buffer.writeScalar(fSigma);
  598. buffer.writeUInt(fBlurStyle);
  599. buffer.writeUInt(!fRespectCTM); // historically we recorded ignoreCTM
  600. }
  601. #if SK_SUPPORT_GPU
  602. bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrRecordingContext* context,
  603. GrRenderTargetContext* renderTargetContext,
  604. GrPaint&& paint,
  605. const GrClip& clip,
  606. const SkMatrix& viewMatrix,
  607. const GrShape& shape) const {
  608. SkASSERT(renderTargetContext);
  609. if (fBlurStyle != kNormal_SkBlurStyle) {
  610. return false;
  611. }
  612. if (!viewMatrix.isScaleTranslate()) {
  613. return false;
  614. }
  615. // TODO: we could handle blurred stroked circles
  616. if (!shape.style().isSimpleFill()) {
  617. return false;
  618. }
  619. SkScalar xformedSigma = this->computeXformedSigma(viewMatrix);
  620. if (xformedSigma <= 0) {
  621. return false;
  622. }
  623. SkRRect srcRRect;
  624. bool inverted;
  625. if (!shape.asRRect(&srcRRect, nullptr, nullptr, &inverted) || inverted) {
  626. return false;
  627. }
  628. SkRRect devRRect;
  629. if (!srcRRect.transform(viewMatrix, &devRRect)) {
  630. return false;
  631. }
  632. if (!SkRRectPriv::AllCornersCircular(devRRect)) {
  633. return false;
  634. }
  635. GrProxyProvider* proxyProvider = context->priv().proxyProvider();
  636. std::unique_ptr<GrFragmentProcessor> fp;
  637. if (devRRect.isRect() || SkRRectPriv::IsCircle(devRRect)) {
  638. if (devRRect.isRect()) {
  639. SkScalar pad = 3.0f * xformedSigma;
  640. const SkRect dstCoverageRect = devRRect.rect().makeOutset(pad, pad);
  641. fp = GrRectBlurEffect::Make(proxyProvider, *context->priv().caps()->shaderCaps(),
  642. dstCoverageRect, xformedSigma);
  643. } else {
  644. fp = GrCircleBlurFragmentProcessor::Make(proxyProvider, devRRect.rect(), xformedSigma);
  645. }
  646. if (!fp) {
  647. return false;
  648. }
  649. paint.addCoverageFragmentProcessor(std::move(fp));
  650. SkRect srcProxyRect = srcRRect.rect();
  651. SkScalar outsetX = 3.0f*fSigma;
  652. SkScalar outsetY = 3.0f*fSigma;
  653. if (this->ignoreXform()) {
  654. // When we're ignoring the CTM the padding added to the source rect also needs to ignore
  655. // the CTM. The matrix passed in here is guaranteed to be just scale and translate so we
  656. // can just grab the X and Y scales off the matrix and pre-undo the scale.
  657. outsetX /= SkScalarAbs(viewMatrix.getScaleX());
  658. outsetY /= SkScalarAbs(viewMatrix.getScaleY());
  659. }
  660. srcProxyRect.outset(outsetX, outsetY);
  661. renderTargetContext->drawRect(clip, std::move(paint), GrAA::kNo, viewMatrix, srcProxyRect);
  662. return true;
  663. }
  664. fp = GrRRectBlurEffect::Make(context, fSigma, xformedSigma, srcRRect, devRRect);
  665. if (!fp) {
  666. return false;
  667. }
  668. if (!this->ignoreXform()) {
  669. SkRect srcProxyRect = srcRRect.rect();
  670. srcProxyRect.outset(3.0f*fSigma, 3.0f*fSigma);
  671. SkVertices::Builder builder(SkVertices::kTriangles_VertexMode, 4, 6, 0);
  672. srcProxyRect.toQuad(builder.positions());
  673. static const uint16_t fullIndices[6] = { 0, 1, 2, 0, 2, 3 };
  674. memcpy(builder.indices(), fullIndices, sizeof(fullIndices));
  675. sk_sp<SkVertices> vertices = builder.detach();
  676. paint.addCoverageFragmentProcessor(std::move(fp));
  677. renderTargetContext->drawVertices(clip, std::move(paint), viewMatrix, std::move(vertices),
  678. nullptr, 0);
  679. } else {
  680. SkMatrix inverse;
  681. if (!viewMatrix.invert(&inverse)) {
  682. return false;
  683. }
  684. float extra=3.f*SkScalarCeilToScalar(xformedSigma-1/6.0f);
  685. SkRect proxyRect = devRRect.rect();
  686. proxyRect.outset(extra, extra);
  687. paint.addCoverageFragmentProcessor(std::move(fp));
  688. renderTargetContext->fillRectWithLocalMatrix(clip, std::move(paint), GrAA::kNo,
  689. SkMatrix::I(), proxyRect, inverse);
  690. }
  691. return true;
  692. }
  693. bool SkBlurMaskFilterImpl::canFilterMaskGPU(const GrShape& shape,
  694. const SkIRect& devSpaceShapeBounds,
  695. const SkIRect& clipBounds,
  696. const SkMatrix& ctm,
  697. SkIRect* maskRect) const {
  698. SkScalar xformedSigma = this->computeXformedSigma(ctm);
  699. if (xformedSigma <= 0) {
  700. maskRect->setEmpty();
  701. return false;
  702. }
  703. if (maskRect) {
  704. float sigma3 = 3 * SkScalarToFloat(xformedSigma);
  705. // Outset srcRect and clipRect by 3 * sigma, to compute affected blur area.
  706. SkIRect clipRect = clipBounds.makeOutset(sigma3, sigma3);
  707. SkIRect srcRect = devSpaceShapeBounds.makeOutset(sigma3, sigma3);
  708. if (!srcRect.intersect(clipRect)) {
  709. srcRect.setEmpty();
  710. }
  711. *maskRect = srcRect;
  712. }
  713. // We prefer to blur paths with small blur radii on the CPU.
  714. if (ctm.rectStaysRect()) {
  715. static const SkScalar kMIN_GPU_BLUR_SIZE = SkIntToScalar(64);
  716. static const SkScalar kMIN_GPU_BLUR_SIGMA = SkIntToScalar(32);
  717. if (devSpaceShapeBounds.width() <= kMIN_GPU_BLUR_SIZE &&
  718. devSpaceShapeBounds.height() <= kMIN_GPU_BLUR_SIZE &&
  719. xformedSigma <= kMIN_GPU_BLUR_SIGMA) {
  720. return false;
  721. }
  722. }
  723. return true;
  724. }
  725. sk_sp<GrTextureProxy> SkBlurMaskFilterImpl::filterMaskGPU(GrRecordingContext* context,
  726. sk_sp<GrTextureProxy> srcProxy,
  727. const SkMatrix& ctm,
  728. const SkIRect& maskRect) const {
  729. // 'maskRect' isn't snapped to the UL corner but the mask in 'src' is.
  730. const SkIRect clipRect = SkIRect::MakeWH(maskRect.width(), maskRect.height());
  731. SkScalar xformedSigma = this->computeXformedSigma(ctm);
  732. SkASSERT(xformedSigma > 0);
  733. // If we're doing a normal blur, we can clobber the pathTexture in the
  734. // gaussianBlur. Otherwise, we need to save it for later compositing.
  735. bool isNormalBlur = (kNormal_SkBlurStyle == fBlurStyle);
  736. sk_sp<GrRenderTargetContext> renderTargetContext(
  737. SkGpuBlurUtils::GaussianBlur(context,
  738. srcProxy,
  739. SkIPoint::Make(0, 0),
  740. nullptr,
  741. clipRect,
  742. SkIRect::EmptyIRect(),
  743. xformedSigma,
  744. xformedSigma,
  745. GrTextureDomain::kIgnore_Mode,
  746. kPremul_SkAlphaType));
  747. if (!renderTargetContext) {
  748. return nullptr;
  749. }
  750. if (!isNormalBlur) {
  751. GrPaint paint;
  752. // Blend pathTexture over blurTexture.
  753. paint.addCoverageFragmentProcessor(GrSimpleTextureEffect::Make(std::move(srcProxy),
  754. SkMatrix::I()));
  755. if (kInner_SkBlurStyle == fBlurStyle) {
  756. // inner: dst = dst * src
  757. paint.setCoverageSetOpXPFactory(SkRegion::kIntersect_Op);
  758. } else if (kSolid_SkBlurStyle == fBlurStyle) {
  759. // solid: dst = src + dst - src * dst
  760. // = src + (1 - src) * dst
  761. paint.setCoverageSetOpXPFactory(SkRegion::kUnion_Op);
  762. } else if (kOuter_SkBlurStyle == fBlurStyle) {
  763. // outer: dst = dst * (1 - src)
  764. // = 0 * src + (1 - src) * dst
  765. paint.setCoverageSetOpXPFactory(SkRegion::kDifference_Op);
  766. } else {
  767. paint.setCoverageSetOpXPFactory(SkRegion::kReplace_Op);
  768. }
  769. renderTargetContext->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(),
  770. SkRect::Make(clipRect));
  771. }
  772. return renderTargetContext->asTextureProxyRef();
  773. }
  774. #endif // SK_SUPPORT_GPU
  775. void sk_register_blur_maskfilter_createproc() { SK_REGISTER_FLATTENABLE(SkBlurMaskFilterImpl); }
  776. sk_sp<SkMaskFilter> SkMaskFilter::MakeBlur(SkBlurStyle style, SkScalar sigma, bool respectCTM) {
  777. if (SkScalarIsFinite(sigma) && sigma > 0) {
  778. return sk_sp<SkMaskFilter>(new SkBlurMaskFilterImpl(sigma, style, respectCTM));
  779. }
  780. return nullptr;
  781. }