BlurTest.cpp 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746
  1. /*
  2. * Copyright 2011 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. #include "include/core/SkBitmap.h"
  8. #include "include/core/SkBlendMode.h"
  9. #include "include/core/SkBlurTypes.h"
  10. #include "include/core/SkCanvas.h"
  11. #include "include/core/SkColor.h"
  12. #include "include/core/SkColorPriv.h"
  13. #include "include/core/SkDrawLooper.h"
  14. #include "include/core/SkImageInfo.h"
  15. #include "include/core/SkMaskFilter.h"
  16. #include "include/core/SkMath.h"
  17. #include "include/core/SkPaint.h"
  18. #include "include/core/SkPath.h"
  19. #include "include/core/SkPixmap.h"
  20. #include "include/core/SkPoint.h"
  21. #include "include/core/SkRRect.h"
  22. #include "include/core/SkRect.h"
  23. #include "include/core/SkRefCnt.h"
  24. #include "include/core/SkScalar.h"
  25. #include "include/core/SkShader.h"
  26. #include "include/core/SkSize.h"
  27. #include "include/core/SkSurface.h"
  28. #include "include/core/SkTypes.h"
  29. #include "include/effects/SkBlurDrawLooper.h"
  30. #include "include/effects/SkLayerDrawLooper.h"
  31. #include "include/effects/SkPerlinNoiseShader.h"
  32. #include "include/private/SkFloatBits.h"
  33. #include "src/core/SkBlurMask.h"
  34. #include "src/core/SkBlurPriv.h"
  35. #include "src/core/SkMask.h"
  36. #include "src/core/SkMaskFilterBase.h"
  37. #include "src/core/SkMathPriv.h"
  38. #include "src/effects/SkEmbossMaskFilter.h"
  39. #include "tests/Test.h"
  40. #include "tools/ToolUtils.h"
  41. #include "tools/gpu/GrContextFactory.h"
  42. #include <math.h>
  43. #include <string.h>
  44. #include <initializer_list>
  45. #include <utility>
  46. class GrContext;
  47. #define WRITE_CSV 0
  48. ///////////////////////////////////////////////////////////////////////////////
  49. #define ILLEGAL_MODE ((SkXfermode::Mode)-1)
  50. static const int outset = 100;
  51. static const SkColor bgColor = SK_ColorWHITE;
  52. static const int strokeWidth = 4;
  53. static void create(SkBitmap* bm, const SkIRect& bound) {
  54. bm->allocN32Pixels(bound.width(), bound.height());
  55. }
  56. static void drawBG(SkCanvas* canvas) {
  57. canvas->drawColor(bgColor);
  58. }
  59. struct BlurTest {
  60. void (*addPath)(SkPath*);
  61. int viewLen;
  62. SkIRect views[9];
  63. };
  64. //Path Draw Procs
  65. //Beware that paths themselves my draw differently depending on the clip.
  66. static void draw50x50Rect(SkPath* path) {
  67. path->addRect(0, 0, SkIntToScalar(50), SkIntToScalar(50));
  68. }
  69. //Tests
  70. static BlurTest tests[] = {
  71. { draw50x50Rect, 3, {
  72. //inner half of blur
  73. { 0, 0, 50, 50 },
  74. //blur, but no path.
  75. { 50 + strokeWidth/2, 50 + strokeWidth/2, 100, 100 },
  76. //just an edge
  77. { 40, strokeWidth, 60, 50 - strokeWidth },
  78. }},
  79. };
  80. /** Assumes that the ref draw was completely inside ref canvas --
  81. implies that everything outside is "bgColor".
  82. Checks that all overlap is the same and that all non-overlap on the
  83. ref is "bgColor".
  84. */
  85. static bool compare(const SkBitmap& ref, const SkIRect& iref,
  86. const SkBitmap& test, const SkIRect& itest)
  87. {
  88. const int xOff = itest.fLeft - iref.fLeft;
  89. const int yOff = itest.fTop - iref.fTop;
  90. for (int y = 0; y < test.height(); ++y) {
  91. for (int x = 0; x < test.width(); ++x) {
  92. SkColor testColor = test.getColor(x, y);
  93. int refX = x + xOff;
  94. int refY = y + yOff;
  95. SkColor refColor;
  96. if (refX >= 0 && refX < ref.width() &&
  97. refY >= 0 && refY < ref.height())
  98. {
  99. refColor = ref.getColor(refX, refY);
  100. } else {
  101. refColor = bgColor;
  102. }
  103. if (refColor != testColor) {
  104. return false;
  105. }
  106. }
  107. }
  108. return true;
  109. }
  110. DEF_TEST(BlurDrawing, reporter) {
  111. SkPaint paint;
  112. paint.setColor(SK_ColorGRAY);
  113. paint.setStyle(SkPaint::kStroke_Style);
  114. paint.setStrokeWidth(SkIntToScalar(strokeWidth));
  115. SkScalar sigma = SkBlurMask::ConvertRadiusToSigma(SkIntToScalar(5));
  116. for (int style = 0; style <= kLastEnum_SkBlurStyle; ++style) {
  117. SkBlurStyle blurStyle = static_cast<SkBlurStyle>(style);
  118. for (bool respectCTM : { false, true }) {
  119. paint.setMaskFilter(SkMaskFilter::MakeBlur(blurStyle, sigma, respectCTM));
  120. for (size_t test = 0; test < SK_ARRAY_COUNT(tests); ++test) {
  121. SkPath path;
  122. tests[test].addPath(&path);
  123. SkPath strokedPath;
  124. paint.getFillPath(path, &strokedPath);
  125. SkRect refBound = strokedPath.getBounds();
  126. SkIRect iref;
  127. refBound.roundOut(&iref);
  128. iref.inset(-outset, -outset);
  129. SkBitmap refBitmap;
  130. create(&refBitmap, iref);
  131. SkCanvas refCanvas(refBitmap);
  132. refCanvas.translate(SkIntToScalar(-iref.fLeft),
  133. SkIntToScalar(-iref.fTop));
  134. drawBG(&refCanvas);
  135. refCanvas.drawPath(path, paint);
  136. for (int view = 0; view < tests[test].viewLen; ++view) {
  137. SkIRect itest = tests[test].views[view];
  138. SkBitmap testBitmap;
  139. create(&testBitmap, itest);
  140. SkCanvas testCanvas(testBitmap);
  141. testCanvas.translate(SkIntToScalar(-itest.fLeft),
  142. SkIntToScalar(-itest.fTop));
  143. drawBG(&testCanvas);
  144. testCanvas.drawPath(path, paint);
  145. REPORTER_ASSERT(reporter,
  146. compare(refBitmap, iref, testBitmap, itest));
  147. }
  148. }
  149. }
  150. }
  151. }
  152. ///////////////////////////////////////////////////////////////////////////////
  153. // Use SkBlurMask::BlurGroundTruth to blur a 'width' x 'height' solid
  154. // white rect. Return the right half of the middle row in 'result'.
  155. static void ground_truth_2d(int width, int height,
  156. SkScalar sigma,
  157. int* result, int resultCount) {
  158. SkMask src, dst;
  159. src.fBounds.set(0, 0, width, height);
  160. src.fFormat = SkMask::kA8_Format;
  161. src.fRowBytes = src.fBounds.width();
  162. src.fImage = SkMask::AllocImage(src.computeTotalImageSize());
  163. memset(src.fImage, 0xff, src.computeTotalImageSize());
  164. if (!SkBlurMask::BlurGroundTruth(sigma, &dst, src, kNormal_SkBlurStyle)) {
  165. return;
  166. }
  167. int midX = dst.fBounds.x() + dst.fBounds.width()/2;
  168. int midY = dst.fBounds.y() + dst.fBounds.height()/2;
  169. uint8_t* bytes = dst.getAddr8(midX, midY);
  170. int i;
  171. for (i = 0; i < dst.fBounds.width()-(midX-dst.fBounds.fLeft); ++i) {
  172. if (i < resultCount) {
  173. result[i] = bytes[i];
  174. }
  175. }
  176. for ( ; i < resultCount; ++i) {
  177. result[i] = 0;
  178. }
  179. SkMask::FreeImage(src.fImage);
  180. SkMask::FreeImage(dst.fImage);
  181. }
  182. // Implement a step function that is 255 between min and max; 0 elsewhere.
  183. static int step(int x, SkScalar min, SkScalar max) {
  184. if (min < x && x < max) {
  185. return 255;
  186. }
  187. return 0;
  188. }
  189. // Implement a Gaussian function with 0 mean and std.dev. of 'sigma'.
  190. static float gaussian(int x, SkScalar sigma) {
  191. float k = SK_Scalar1/(sigma * sqrtf(2.0f*SK_ScalarPI));
  192. float exponent = -(x * x) / (2 * sigma * sigma);
  193. return k * expf(exponent);
  194. }
  195. // Perform a brute force convolution of a step function with a Gaussian.
  196. // Return the right half in 'result'
  197. static void brute_force_1d(SkScalar stepMin, SkScalar stepMax,
  198. SkScalar gaussianSigma,
  199. int* result, int resultCount) {
  200. int gaussianRange = SkScalarCeilToInt(10 * gaussianSigma);
  201. for (int i = 0; i < resultCount; ++i) {
  202. SkScalar sum = 0.0f;
  203. for (int j = -gaussianRange; j < gaussianRange; ++j) {
  204. sum += gaussian(j, gaussianSigma) * step(i-j, stepMin, stepMax);
  205. }
  206. result[i] = SkClampMax(SkClampPos(int(sum + 0.5f)), 255);
  207. }
  208. }
  209. static void blur_path(SkCanvas* canvas, const SkPath& path,
  210. SkScalar gaussianSigma) {
  211. SkScalar midX = path.getBounds().centerX();
  212. SkScalar midY = path.getBounds().centerY();
  213. canvas->translate(-midX, -midY);
  214. SkPaint blurPaint;
  215. blurPaint.setColor(SK_ColorWHITE);
  216. blurPaint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, gaussianSigma));
  217. canvas->drawColor(SK_ColorBLACK);
  218. canvas->drawPath(path, blurPaint);
  219. }
  220. // Readback the blurred draw results from the canvas
  221. static void readback(const SkBitmap& src, int* result, int resultCount) {
  222. SkBitmap readback;
  223. readback.allocN32Pixels(resultCount, 30);
  224. SkPixmap pm;
  225. readback.peekPixels(&pm);
  226. src.readPixels(pm, 0, 0);
  227. const SkPMColor* pixels = pm.addr32(0, 15);
  228. for (int i = 0; i < resultCount; ++i) {
  229. result[i] = SkColorGetR(pixels[i]);
  230. }
  231. }
  232. // Draw a blurred version of the provided path.
  233. // Return the right half of the middle row in 'result'.
  234. static void cpu_blur_path(const SkPath& path, SkScalar gaussianSigma,
  235. int* result, int resultCount) {
  236. SkBitmap bitmap;
  237. bitmap.allocN32Pixels(resultCount, 30);
  238. SkCanvas canvas(bitmap);
  239. blur_path(&canvas, path, gaussianSigma);
  240. readback(bitmap, result, resultCount);
  241. }
  242. #if WRITE_CSV
  243. static void write_as_csv(const char* label, SkScalar scale, int* data, int count) {
  244. SkDebugf("%s_%.2f,", label, scale);
  245. for (int i = 0; i < count-1; ++i) {
  246. SkDebugf("%d,", data[i]);
  247. }
  248. SkDebugf("%d\n", data[count-1]);
  249. }
  250. #endif
  251. static bool match(int* first, int* second, int count, int tol) {
  252. int delta;
  253. for (int i = 0; i < count; ++i) {
  254. delta = first[i] - second[i];
  255. if (delta > tol || delta < -tol) {
  256. return false;
  257. }
  258. }
  259. return true;
  260. }
  261. // Test out the normal blur style with a wide range of sigmas
  262. DEF_TEST(BlurSigmaRange, reporter) {
  263. static const int kSize = 100;
  264. // The geometry is offset a smidge to trigger:
  265. // https://code.google.com/p/chromium/issues/detail?id=282418
  266. SkPath rectPath;
  267. rectPath.addRect(0.3f, 0.3f, 100.3f, 100.3f);
  268. SkPoint polyPts[] = {
  269. { 0.3f, 0.3f },
  270. { 100.3f, 0.3f },
  271. { 100.3f, 100.3f },
  272. { 0.3f, 100.3f },
  273. { 2.3f, 50.3f } // a little divet to throw off the rect special case
  274. };
  275. SkPath polyPath;
  276. polyPath.addPoly(polyPts, SK_ARRAY_COUNT(polyPts), true);
  277. int rectSpecialCaseResult[kSize];
  278. int generalCaseResult[kSize];
  279. int groundTruthResult[kSize];
  280. int bruteForce1DResult[kSize];
  281. SkScalar sigma = 10.0f;
  282. for (int i = 0; i < 4; ++i, sigma /= 10) {
  283. cpu_blur_path(rectPath, sigma, rectSpecialCaseResult, kSize);
  284. cpu_blur_path(polyPath, sigma, generalCaseResult, kSize);
  285. ground_truth_2d(100, 100, sigma, groundTruthResult, kSize);
  286. brute_force_1d(-50.0f, 50.0f, sigma, bruteForce1DResult, kSize);
  287. REPORTER_ASSERT(reporter, match(rectSpecialCaseResult, bruteForce1DResult, kSize, 5));
  288. REPORTER_ASSERT(reporter, match(generalCaseResult, bruteForce1DResult, kSize, 15));
  289. REPORTER_ASSERT(reporter, match(groundTruthResult, bruteForce1DResult, kSize, 1));
  290. #if WRITE_CSV
  291. write_as_csv("RectSpecialCase", sigma, rectSpecialCaseResult, kSize);
  292. write_as_csv("GeneralCase", sigma, generalCaseResult, kSize);
  293. write_as_csv("GPU", sigma, gpuResult, kSize);
  294. write_as_csv("GroundTruth2D", sigma, groundTruthResult, kSize);
  295. write_as_csv("BruteForce1D", sigma, bruteForce1DResult, kSize);
  296. #endif
  297. }
  298. }
  299. ///////////////////////////////////////////////////////////////////////////////////////////
  300. static void test_blurDrawLooper(skiatest::Reporter* reporter, SkScalar sigma, SkBlurStyle style) {
  301. if (kNormal_SkBlurStyle != style) {
  302. return; // blurdrawlooper only supports normal
  303. }
  304. const SkColor color = 0xFF335577;
  305. const SkScalar dx = 10;
  306. const SkScalar dy = -5;
  307. sk_sp<SkDrawLooper> lp(SkBlurDrawLooper::Make(color, sigma, dx, dy));
  308. const bool expectSuccess = sigma > 0;
  309. if (nullptr == lp) {
  310. REPORTER_ASSERT(reporter, sigma <= 0);
  311. } else {
  312. SkDrawLooper::BlurShadowRec rec;
  313. bool success = lp->asABlurShadow(&rec);
  314. REPORTER_ASSERT(reporter, success == expectSuccess);
  315. if (success) {
  316. REPORTER_ASSERT(reporter, rec.fSigma == sigma);
  317. REPORTER_ASSERT(reporter, rec.fOffset.x() == dx);
  318. REPORTER_ASSERT(reporter, rec.fOffset.y() == dy);
  319. REPORTER_ASSERT(reporter, rec.fColor == color);
  320. REPORTER_ASSERT(reporter, rec.fStyle == style);
  321. }
  322. }
  323. }
  324. static void test_looper(skiatest::Reporter* reporter, sk_sp<SkDrawLooper> lp, SkScalar sigma,
  325. SkBlurStyle style, bool expectSuccess) {
  326. SkDrawLooper::BlurShadowRec rec;
  327. bool success = lp->asABlurShadow(&rec);
  328. REPORTER_ASSERT(reporter, success == expectSuccess);
  329. if (success != expectSuccess) {
  330. lp->asABlurShadow(&rec);
  331. }
  332. if (success) {
  333. REPORTER_ASSERT(reporter, rec.fSigma == sigma);
  334. REPORTER_ASSERT(reporter, rec.fStyle == style);
  335. }
  336. }
  337. static void make_noop_layer(SkLayerDrawLooper::Builder* builder) {
  338. SkLayerDrawLooper::LayerInfo info;
  339. info.fPaintBits = 0;
  340. info.fColorMode = SkBlendMode::kDst;
  341. builder->addLayer(info);
  342. }
  343. static void make_blur_layer(SkLayerDrawLooper::Builder* builder, sk_sp<SkMaskFilter> mf) {
  344. SkLayerDrawLooper::LayerInfo info;
  345. info.fPaintBits = SkLayerDrawLooper::kMaskFilter_Bit;
  346. info.fColorMode = SkBlendMode::kSrc;
  347. SkPaint* paint = builder->addLayer(info);
  348. paint->setMaskFilter(std::move(mf));
  349. }
  350. static void test_layerDrawLooper(skiatest::Reporter* reporter, sk_sp<SkMaskFilter> mf,
  351. SkScalar sigma, SkBlurStyle style, bool expectSuccess) {
  352. SkLayerDrawLooper::LayerInfo info;
  353. SkLayerDrawLooper::Builder builder;
  354. // 1 layer is too few
  355. make_noop_layer(&builder);
  356. test_looper(reporter, builder.detach(), sigma, style, false);
  357. // 2 layers is good, but need blur
  358. make_noop_layer(&builder);
  359. make_noop_layer(&builder);
  360. test_looper(reporter, builder.detach(), sigma, style, false);
  361. // 2 layers is just right
  362. make_noop_layer(&builder);
  363. make_blur_layer(&builder, mf);
  364. test_looper(reporter, builder.detach(), sigma, style, expectSuccess);
  365. // 3 layers is too many
  366. make_noop_layer(&builder);
  367. make_blur_layer(&builder, mf);
  368. make_noop_layer(&builder);
  369. test_looper(reporter, builder.detach(), sigma, style, false);
  370. }
  371. DEF_TEST(BlurAsABlur, reporter) {
  372. const SkBlurStyle styles[] = {
  373. kNormal_SkBlurStyle, kSolid_SkBlurStyle, kOuter_SkBlurStyle, kInner_SkBlurStyle
  374. };
  375. const SkScalar sigmas[] = {
  376. // values <= 0 should not success for a blur
  377. -1, 0, 0.5f, 2
  378. };
  379. // Test asABlur for SkBlurMaskFilter
  380. //
  381. for (size_t i = 0; i < SK_ARRAY_COUNT(styles); ++i) {
  382. const SkBlurStyle style = styles[i];
  383. for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
  384. const SkScalar sigma = sigmas[j];
  385. for (bool respectCTM : { false, true }) {
  386. sk_sp<SkMaskFilter> mf(SkMaskFilter::MakeBlur(style, sigma, respectCTM));
  387. if (nullptr == mf.get()) {
  388. REPORTER_ASSERT(reporter, sigma <= 0);
  389. } else {
  390. REPORTER_ASSERT(reporter, sigma > 0);
  391. SkMaskFilterBase::BlurRec rec;
  392. bool success = as_MFB(mf)->asABlur(&rec);
  393. if (respectCTM) {
  394. REPORTER_ASSERT(reporter, success);
  395. REPORTER_ASSERT(reporter, rec.fSigma == sigma);
  396. REPORTER_ASSERT(reporter, rec.fStyle == style);
  397. } else {
  398. REPORTER_ASSERT(reporter, !success);
  399. }
  400. test_layerDrawLooper(reporter, std::move(mf), sigma, style, success);
  401. }
  402. test_blurDrawLooper(reporter, sigma, style);
  403. }
  404. }
  405. }
  406. // Test asABlur for SkEmbossMaskFilter -- should never succeed
  407. //
  408. {
  409. SkEmbossMaskFilter::Light light = {
  410. { 1, 1, 1 }, 0, 127, 127
  411. };
  412. for (size_t j = 0; j < SK_ARRAY_COUNT(sigmas); ++j) {
  413. const SkScalar sigma = sigmas[j];
  414. auto mf(SkEmbossMaskFilter::Make(sigma, light));
  415. if (mf) {
  416. SkMaskFilterBase::BlurRec rec;
  417. bool success = as_MFB(mf)->asABlur(&rec);
  418. REPORTER_ASSERT(reporter, !success);
  419. }
  420. }
  421. }
  422. }
  423. // This exercises the problem discovered in crbug.com/570232. The return value from
  424. // SkBlurMask::BoxBlur wasn't being checked in SkBlurMaskFilter.cpp::GrRRectBlurEffect::Create
  425. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctxInfo) {
  426. SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
  427. auto surface(SkSurface::MakeRenderTarget(ctxInfo.grContext(), SkBudgeted::kNo, info));
  428. SkCanvas* canvas = surface->getCanvas();
  429. SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
  430. SkRRect rr = SkRRect::MakeRectXY(r, 10, 10);
  431. SkPaint p;
  432. p.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 0.01f));
  433. canvas->drawRRect(rr, p);
  434. }
  435. DEF_TEST(BlurredRRectNinePatchComputation, reporter) {
  436. const SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
  437. static const SkScalar kBlurRad = 3.0f;
  438. bool ninePatchable;
  439. SkRRect rrectToDraw;
  440. SkISize size;
  441. SkScalar rectXs[kSkBlurRRectMaxDivisions],
  442. rectYs[kSkBlurRRectMaxDivisions];
  443. SkScalar texXs[kSkBlurRRectMaxDivisions],
  444. texYs[kSkBlurRRectMaxDivisions];
  445. int numX, numY;
  446. uint32_t skipMask;
  447. // not nine-patchable
  448. {
  449. SkVector radii[4] = { { 100, 100 }, { 0, 0 }, { 100, 100 }, { 0, 0 } };
  450. SkRRect rr;
  451. rr.setRectRadii(r, radii);
  452. ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
  453. kBlurRad, kBlurRad,
  454. &rrectToDraw, &size,
  455. rectXs, rectYs, texXs, texYs,
  456. &numX, &numY, &skipMask);
  457. REPORTER_ASSERT(reporter, !ninePatchable);
  458. }
  459. // simple circular
  460. {
  461. static const SkScalar kCornerRad = 10.0f;
  462. SkRRect rr;
  463. rr.setRectXY(r, kCornerRad, kCornerRad);
  464. ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
  465. kBlurRad, kBlurRad,
  466. &rrectToDraw, &size,
  467. rectXs, rectYs, texXs, texYs,
  468. &numX, &numY, &skipMask);
  469. static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f;
  470. REPORTER_ASSERT(reporter, ninePatchable);
  471. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns));
  472. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns));
  473. REPORTER_ASSERT(reporter, 4 == numX && 4 == numY);
  474. REPORTER_ASSERT(reporter, !skipMask);
  475. }
  476. // simple elliptical
  477. {
  478. static const SkScalar kXCornerRad = 2.0f;
  479. static const SkScalar kYCornerRad = 10.0f;
  480. SkRRect rr;
  481. rr.setRectXY(r, kXCornerRad, kYCornerRad);
  482. ninePatchable = SkComputeBlurredRRectParams(rr, rr, SkRect::MakeEmpty(),
  483. kBlurRad, kBlurRad,
  484. &rrectToDraw, &size,
  485. rectXs, rectYs, texXs, texYs,
  486. &numX, &numY, &skipMask);
  487. static const SkScalar kXAns = 12.0f * kBlurRad + 2.0f * kXCornerRad + 1.0f;
  488. static const SkScalar kYAns = 12.0f * kBlurRad + 2.0f * kYCornerRad + 1.0f;
  489. REPORTER_ASSERT(reporter, ninePatchable);
  490. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kXAns));
  491. REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kYAns));
  492. REPORTER_ASSERT(reporter, 4 == numX && 4 == numY);
  493. REPORTER_ASSERT(reporter, !skipMask);
  494. }
  495. // test-out occlusion
  496. {
  497. static const SkScalar kCornerRad = 10.0f;
  498. SkRRect rr;
  499. rr.setRectXY(r, kCornerRad, kCornerRad);
  500. // The rectXs & rectYs should be { 1, 29, 91, 119 }. Add two more points around each.
  501. SkScalar testLocs[] = {
  502. -18.0f, -9.0f,
  503. 1.0f,
  504. 9.0f, 18.0f,
  505. 29.0f,
  506. 39.0f, 49.0f,
  507. 91.0f,
  508. 109.0f, 118.0f,
  509. 119.0f,
  510. 139.0f, 149.0f
  511. };
  512. for (int minY = 0; minY < (int)SK_ARRAY_COUNT(testLocs); ++minY) {
  513. for (int maxY = minY+1; maxY < (int)SK_ARRAY_COUNT(testLocs); ++maxY) {
  514. for (int minX = 0; minX < (int)SK_ARRAY_COUNT(testLocs); ++minX) {
  515. for (int maxX = minX+1; maxX < (int)SK_ARRAY_COUNT(testLocs); ++maxX) {
  516. SkRect occluder = SkRect::MakeLTRB(testLocs[minX], testLocs[minY],
  517. testLocs[maxX], testLocs[maxY]);
  518. if (occluder.isEmpty()) {
  519. continue;
  520. }
  521. ninePatchable = SkComputeBlurredRRectParams(rr, rr, occluder,
  522. kBlurRad, kBlurRad,
  523. &rrectToDraw, &size,
  524. rectXs, rectYs, texXs, texYs,
  525. &numX, &numY, &skipMask);
  526. static const SkScalar kAns = 12.0f * kBlurRad + 2.0f * kCornerRad + 1.0f;
  527. REPORTER_ASSERT(reporter, ninePatchable);
  528. REPORTER_ASSERT(reporter,
  529. SkScalarNearlyEqual(SkIntToScalar(size.fWidth), kAns));
  530. REPORTER_ASSERT(reporter,
  531. SkScalarNearlyEqual(SkIntToScalar(size.fHeight), kAns));
  532. int checkBit = 0x1;
  533. for (int y = 0; y < numY-1; ++y) {
  534. for (int x = 0; x < numX-1; ++x) {
  535. SkRect cell = SkRect::MakeLTRB(rectXs[x], rectYs[y],
  536. rectXs[x+1], rectYs[y+1]);
  537. REPORTER_ASSERT(reporter,
  538. SkToBool(skipMask & checkBit) ==
  539. (cell.isEmpty() || occluder.contains(cell)));
  540. REPORTER_ASSERT(reporter, texXs[x] >= 0 &&
  541. texXs[x] <= size.fWidth);
  542. REPORTER_ASSERT(reporter, texYs[y] >= 0 &&
  543. texXs[y] <= size.fHeight);
  544. checkBit <<= 1;
  545. }
  546. }
  547. }
  548. }
  549. }
  550. }
  551. }
  552. }
  553. // https://crbugs.com/787712
  554. DEF_TEST(EmbossPerlinCrash, reporter) {
  555. SkPaint p;
  556. static constexpr SkEmbossMaskFilter::Light light = {
  557. { 1, 1, 1 }, 0, 127, 127
  558. };
  559. p.setMaskFilter(SkEmbossMaskFilter::Make(1, light));
  560. p.setShader(SkPerlinNoiseShader::MakeFractalNoise(1.0f, 1.0f, 2, 0.0f));
  561. sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(100, 100);
  562. surface->getCanvas()->drawPaint(p);
  563. }
  564. ///////////////////////////////////////////////////////////////////////////////////////////
  565. DEF_TEST(BlurZeroSigma, reporter) {
  566. auto surf = SkSurface::MakeRasterN32Premul(20, 20);
  567. SkPaint paint;
  568. paint.setAntiAlias(true);
  569. const SkIRect ir = { 5, 5, 15, 15 };
  570. const SkRect r = SkRect::Make(ir);
  571. const SkScalar sigmas[] = { 0, SkBits2Float(1) };
  572. // if sigma is zero (or nearly so), we need to draw correctly (unblurred) and not crash
  573. // or assert.
  574. for (auto sigma : sigmas) {
  575. paint.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, sigma));
  576. surf->getCanvas()->drawRect(r, paint);
  577. ToolUtils::PixelIter iter(surf.get());
  578. SkIPoint loc;
  579. while (const SkPMColor* p = (const SkPMColor*)iter.next(&loc)) {
  580. if (ir.contains(loc.fX, loc.fY)) {
  581. // inside the rect we draw (opaque black)
  582. REPORTER_ASSERT(reporter, *p == SkPackARGB32(0xFF, 0, 0, 0));
  583. } else {
  584. // outside the rect we didn't draw at all, no blurred edges
  585. REPORTER_ASSERT(reporter, *p == 0);
  586. }
  587. }
  588. }
  589. }
  590. ///////////////////////////////////////////////////////////////////////////////////////////
  591. DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BlurMaskBiggerThanDest, reporter, ctxInfo) {
  592. GrContext* context = ctxInfo.grContext();
  593. SkImageInfo ii = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
  594. sk_sp<SkSurface> dst(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, ii));
  595. if (!dst) {
  596. ERRORF(reporter, "Could not create surface for test.");
  597. return;
  598. }
  599. SkPaint p;
  600. p.setColor(SK_ColorRED);
  601. p.setMaskFilter(SkMaskFilter::MakeBlur(kNormal_SkBlurStyle, 3));
  602. SkCanvas* canvas = dst->getCanvas();
  603. canvas->clear(SK_ColorBLACK);
  604. canvas->drawCircle(SkPoint::Make(16, 16), 8, p);
  605. SkBitmap readback;
  606. SkAssertResult(readback.tryAllocPixels(ii));
  607. canvas->readPixels(readback, 0, 0);
  608. REPORTER_ASSERT(reporter, SkColorGetR(readback.getColor(15, 15)) > 128);
  609. REPORTER_ASSERT(reporter, SkColorGetG(readback.getColor(15, 15)) == 0);
  610. REPORTER_ASSERT(reporter, SkColorGetB(readback.getColor(15, 15)) == 0);
  611. REPORTER_ASSERT(reporter, readback.getColor(31, 31) == SK_ColorBLACK);
  612. }
  613. DEF_TEST(zero_blur, reporter) {
  614. SkBitmap alpha, bitmap;
  615. SkPaint paint;
  616. paint.setMaskFilter(SkMaskFilter::MakeBlur(kOuter_SkBlurStyle, 3));
  617. SkIPoint offset;
  618. bitmap.extractAlpha(&alpha, &paint, nullptr, &offset);
  619. }