| /* |
| * Copyright 2011 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "include/core/SkBitmap.h" |
| #include "include/core/SkCanvas.h" |
| #include "include/core/SkColor.h" |
| #include "include/core/SkImage.h" // IWYU pragma: keep |
| #include "include/core/SkMatrix.h" |
| #include "include/core/SkPaint.h" |
| #include "include/core/SkPath.h" |
| #include "include/core/SkRect.h" |
| #include "include/core/SkSamplingOptions.h" |
| #include "include/core/SkScalar.h" |
| #include "include/core/SkShader.h" // IWYU pragma: keep |
| #include "include/core/SkSize.h" |
| #include "include/core/SkTileMode.h" |
| #include "include/core/SkTypes.h" |
| #include "src/base/SkRandom.h" |
| #include "src/core/SkMatrixUtils.h" |
| #include "tests/Test.h" |
| |
| #include <array> |
| #include <cstddef> |
| #include <cstdint> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| static void rand_matrix(SkMatrix* mat, SkRandom& rand, unsigned mask) { |
| mat->setIdentity(); |
| if (mask & SkMatrix::kTranslate_Mask) { |
| mat->postTranslate(rand.nextSScalar1(), rand.nextSScalar1()); |
| } |
| if (mask & SkMatrix::kScale_Mask) { |
| mat->postScale(rand.nextSScalar1(), rand.nextSScalar1()); |
| } |
| if (mask & SkMatrix::kAffine_Mask) { |
| mat->postRotate(rand.nextSScalar1() * 360); |
| } |
| if (mask & SkMatrix::kPerspective_Mask) { |
| mat->setPerspX(rand.nextSScalar1()); |
| mat->setPerspY(rand.nextSScalar1()); |
| } |
| } |
| |
| static void rand_size(SkISize* size, SkRandom& rand) { |
| size->set(rand.nextU() & 0xFFFF, rand.nextU() & 0xFFFF); |
| } |
| |
| static void test_treatAsSprite(skiatest::Reporter* reporter) { |
| |
| SkMatrix mat; |
| SkISize size; |
| SkRandom rand; |
| |
| const SkSamplingOptions sampling; |
| |
| // assert: translate-only no-aa can always be treated as sprite |
| for (int i = 0; i < 1000; ++i) { |
| rand_matrix(&mat, rand, SkMatrix::kTranslate_Mask); |
| for (int j = 0; j < 1000; ++j) { |
| rand_size(&size, rand); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, false)); |
| } |
| } |
| |
| // assert: rotate/perspect is never treated as sprite |
| for (int i = 0; i < 1000; ++i) { |
| rand_matrix(&mat, rand, SkMatrix::kAffine_Mask | SkMatrix::kPerspective_Mask); |
| for (int j = 0; j < 1000; ++j) { |
| rand_size(&size, rand); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, false)); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, true)); |
| } |
| } |
| |
| size.set(500, 600); |
| |
| const SkScalar tooMuchSubpixel = 100.1f; |
| mat.setTranslate(tooMuchSubpixel, 0); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, true)); |
| mat.setTranslate(0, tooMuchSubpixel); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, true)); |
| |
| const SkScalar tinySubPixel = 100.02f; |
| mat.setTranslate(tinySubPixel, 0); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, true)); |
| mat.setTranslate(0, tinySubPixel); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, true)); |
| |
| const SkScalar twoThirds = SK_Scalar1 * 2 / 3; |
| const SkScalar bigScale = (size.width() + twoThirds) / size.width(); |
| mat.setScale(bigScale, bigScale); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, false)); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, true)); |
| |
| const SkScalar oneThird = SK_Scalar1 / 3; |
| const SkScalar smallScale = (size.width() + oneThird) / size.width(); |
| mat.setScale(smallScale, smallScale); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, false)); |
| REPORTER_ASSERT(reporter, !SkTreatAsSprite(mat, size, sampling, true)); |
| |
| const SkScalar oneFortyth = SK_Scalar1 / 40; |
| const SkScalar tinyScale = (size.width() + oneFortyth) / size.width(); |
| mat.setScale(tinyScale, tinyScale); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, false)); |
| REPORTER_ASSERT(reporter, SkTreatAsSprite(mat, size, sampling, true)); |
| } |
| |
| static void test_wacky_bitmapshader(skiatest::Reporter* reporter, |
| int width, int height) { |
| SkBitmap dev; |
| dev.allocN32Pixels(0x56F, 0x4f6); |
| dev.eraseColor(SK_ColorTRANSPARENT); // necessary, so we know if we draw to it |
| |
| SkMatrix matrix; |
| |
| SkCanvas c(dev); |
| matrix.setAll(-119.34097f, |
| -43.436558f, |
| 93489.945f, |
| 43.436558f, |
| -119.34097f, |
| 123.98426f, |
| 0, 0, SK_Scalar1); |
| c.concat(matrix); |
| |
| SkBitmap bm; |
| if (bm.tryAllocN32Pixels(width, height)) { |
| bm.eraseColor(SK_ColorRED); |
| } else { |
| SkASSERT(false); |
| return; |
| } |
| |
| matrix.setAll(0.0078740157f, |
| 0, |
| SkIntToScalar(249), |
| 0, |
| 0.0078740157f, |
| SkIntToScalar(239), |
| 0, 0, SK_Scalar1); |
| SkPaint paint; |
| paint.setShader(bm.makeShader(SkTileMode::kRepeat, SkTileMode::kRepeat, |
| SkSamplingOptions(), matrix)); |
| |
| SkRect r = SkRect::MakeXYWH(681, 239, 695, 253); |
| c.drawRect(r, paint); |
| |
| for (int y = 0; y < dev.height(); ++y) { |
| for (int x = 0; x < dev.width(); ++x) { |
| if (SK_ColorTRANSPARENT == *dev.getAddr32(x, y)) { |
| REPORTER_ASSERT(reporter, false); |
| return; |
| } |
| } |
| } |
| } |
| |
| // ATTENTION We should always draw each of these sizes safely now. ATTENTION |
| // ATTENTION I'm leaving this next /*comment*/ for posterity. ATTENTION |
| |
| /* |
| * Original bug was asserting that the matrix-proc had generated a (Y) value |
| * that was out of range. This led (in the release build) to the sampler-proc |
| * reading memory out-of-bounds of the original bitmap. |
| * |
| * We were numerically overflowing our 16bit coordinates that we communicate |
| * between these two procs. The fixes was in two parts: |
| * |
| * 1. Just don't draw bitmaps larger than 64K-1 in width or height, since we |
| * can't represent those coordinates in our transport format (yet). |
| * 2. Perform an unsigned shift during the calculation, so we don't get |
| * sign-extension bleed when packing the two values (X,Y) into our 32bit |
| * slot. |
| * |
| * This tests exercises the original setup, plus 2 more to ensure that we can, |
| * in fact, handle bitmaps at 64K-1 (assuming we don't exceed the total |
| * memory allocation limit). |
| */ |
| static void test_giantrepeat_crbug118018(skiatest::Reporter* reporter) { |
| static const struct { |
| int fWidth; |
| int fHeight; |
| } gTests[] = { |
| { 0x1b294, 0x7f}, // crbug 118018 (width exceeds 64K)... should draw safely now. |
| { 0xFFFF, 0x7f }, // should draw, test max width |
| { 0x7f, 0xFFFF }, // should draw, test max height |
| }; |
| |
| for (size_t i = 0; i < std::size(gTests); ++i) { |
| test_wacky_bitmapshader(reporter, |
| gTests[i].fWidth, gTests[i].fHeight); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| static void test_nan_antihair() { |
| SkBitmap bm; |
| bm.allocN32Pixels(20, 20); |
| |
| SkCanvas canvas(bm); |
| |
| SkPath path; |
| path.moveTo(0, 0); |
| path.lineTo(10, SK_ScalarNaN); |
| |
| SkPaint paint; |
| paint.setAntiAlias(true); |
| paint.setStyle(SkPaint::kStroke_Style); |
| |
| // before our fix to SkScan_Antihair.cpp to check for integral NaN (0x800...) |
| // this would trigger an assert/crash. |
| // |
| // see rev. 3558 |
| canvas.drawPath(path, paint); |
| } |
| |
| static bool check_for_all_zeros(const SkBitmap& bm) { |
| size_t count = bm.width() * bm.bytesPerPixel(); |
| for (int y = 0; y < bm.height(); y++) { |
| const uint8_t* ptr = reinterpret_cast<const uint8_t*>(bm.getAddr(0, y)); |
| for (size_t i = 0; i < count; i++) { |
| if (ptr[i]) { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| static const int gWidth = 256; |
| static const int gHeight = 256; |
| |
| static void create(SkBitmap* bm, SkColor color) { |
| bm->allocN32Pixels(gWidth, gHeight); |
| bm->eraseColor(color); |
| } |
| |
| DEF_TEST(DrawBitmapRect, reporter) { |
| SkBitmap src, dst; |
| |
| create(&src, 0xFFFFFFFF); |
| create(&dst, 0); |
| |
| SkCanvas canvas(dst); |
| |
| SkRect srcR = { gWidth, 0, gWidth + 16, 16 }; |
| SkRect dstR = { 0, 0, 16, 16 }; |
| |
| canvas.drawImageRect(src.asImage(), srcR, dstR, SkSamplingOptions(), nullptr, |
| SkCanvas::kStrict_SrcRectConstraint); |
| |
| // ensure that we draw nothing if srcR does not intersect the bitmap |
| REPORTER_ASSERT(reporter, check_for_all_zeros(dst)); |
| |
| test_nan_antihair(); |
| test_giantrepeat_crbug118018(reporter); |
| |
| test_treatAsSprite(reporter); |
| } |