mtklein | 767d273 | 2015-07-16 07:01:39 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 8 | #include "include/core/SkBitmap.h" |
| 9 | #include "include/core/SkBlendMode.h" |
| 10 | #include "include/core/SkCanvas.h" |
| 11 | #include "include/core/SkColor.h" |
| 12 | #include "include/core/SkColorSpace.h" |
| 13 | #include "include/core/SkImageInfo.h" |
| 14 | #include "include/core/SkPaint.h" |
| 15 | #include "include/core/SkPoint.h" |
| 16 | #include "include/core/SkRect.h" |
| 17 | #include "include/core/SkRefCnt.h" |
| 18 | #include "include/core/SkSurface.h" |
| 19 | #include "include/core/SkTypes.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "include/gpu/GrBackendSurface.h" |
| 21 | #include "include/gpu/GrContext.h" |
| 22 | #include "include/gpu/GrTexture.h" |
| 23 | #include "include/gpu/GrTypes.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 24 | #include "include/private/GrTypesPriv.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 25 | #include "src/gpu/GrContextPriv.h" |
| 26 | #include "src/gpu/GrResourceProvider.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 27 | #include "tests/Test.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 28 | #include "tools/gpu/GrContextFactory.h" |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 29 | |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 30 | #include <initializer_list> |
Ben Wagner | e6b04a1 | 2018-03-09 14:41:36 -0500 | [diff] [blame] | 31 | #include <vector> |
| 32 | |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 33 | struct Results { int diffs, diffs_0x00, diffs_0xff, diffs_by_1; }; |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 34 | |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 35 | static bool acceptable(const Results& r) { |
| 36 | #if 0 |
| 37 | SkDebugf("%d diffs, %d at 0x00, %d at 0xff, %d off by 1, all out of 65536\n", |
| 38 | r.diffs, r.diffs_0x00, r.diffs_0xff, r.diffs_by_1); |
| 39 | #endif |
| 40 | return r.diffs_by_1 == r.diffs // never off by more than 1 |
| 41 | && r.diffs_0x00 == 0 // transparent must stay transparent |
| 42 | && r.diffs_0xff == 0; // opaque must stay opaque |
commit-bot@chromium.org | 40ac5e5 | 2014-02-26 21:40:07 +0000 | [diff] [blame] | 43 | } |
| 44 | |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 45 | template <typename Fn> |
| 46 | static Results test(Fn&& multiply) { |
| 47 | Results r = { 0,0,0,0 }; |
| 48 | for (int x = 0; x < 256; x++) { |
| 49 | for (int y = 0; y < 256; y++) { |
| 50 | int p = multiply(x, y), |
| 51 | ideal = (x*y+127)/255; |
| 52 | if (p != ideal) { |
| 53 | r.diffs++; |
| 54 | if (x == 0x00 || y == 0x00) { r.diffs_0x00++; } |
| 55 | if (x == 0xff || y == 0xff) { r.diffs_0xff++; } |
| 56 | if (SkTAbs(ideal - p) == 1) { r.diffs_by_1++; } |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 57 | } |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 58 | }} |
| 59 | return r; |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 60 | } |
| 61 | |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 62 | DEF_TEST(Blend_byte_multiply, r) { |
| 63 | // These are all temptingly close but fundamentally broken. |
| 64 | int (*broken[])(int, int) = { |
| 65 | [](int x, int y) { return (x*y)>>8; }, |
| 66 | [](int x, int y) { return (x*y+128)>>8; }, |
| 67 | [](int x, int y) { y += y>>7; return (x*y)>>8; }, |
| 68 | }; |
| 69 | for (auto multiply : broken) { REPORTER_ASSERT(r, !acceptable(test(multiply))); } |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 70 | |
mtklein | 195fe08 | 2015-11-17 08:39:01 -0800 | [diff] [blame] | 71 | // These are fine to use, but not perfect. |
| 72 | int (*fine[])(int, int) = { |
| 73 | [](int x, int y) { return (x*y+x)>>8; }, |
| 74 | [](int x, int y) { return (x*y+y)>>8; }, |
| 75 | [](int x, int y) { return (x*y+255)>>8; }, |
| 76 | [](int x, int y) { y += y>>7; return (x*y+128)>>8; }, |
| 77 | }; |
| 78 | for (auto multiply : fine) { REPORTER_ASSERT(r, acceptable(test(multiply))); } |
| 79 | |
| 80 | // These are pefect. |
| 81 | int (*perfect[])(int, int) = { |
| 82 | [](int x, int y) { return (x*y+127)/255; }, // Duh. |
| 83 | [](int x, int y) { int p = (x*y+128); return (p+(p>>8))>>8; }, |
| 84 | [](int x, int y) { return ((x*y+128)*257)>>16; }, |
| 85 | }; |
| 86 | for (auto multiply : perfect) { REPORTER_ASSERT(r, test(multiply).diffs == 0); } |
commit-bot@chromium.org | 7f428a9 | 2014-02-25 21:31:03 +0000 | [diff] [blame] | 87 | } |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 88 | |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 89 | namespace { |
| 90 | static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target( |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 91 | GrContext* context, int sampleCnt, int width, int height, SkColorType colorType, |
| 92 | GrPixelConfig config, GrSurfaceOrigin origin, |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 93 | sk_sp<GrTexture>* backingSurface) { |
| 94 | GrSurfaceDesc backingDesc; |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 95 | backingDesc.fWidth = width; |
| 96 | backingDesc.fHeight = height; |
| 97 | backingDesc.fConfig = config; |
| 98 | backingDesc.fSampleCnt = sampleCnt; |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 99 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 100 | auto resourceProvider = context->priv().resourceProvider(); |
Robert Phillips | 6be756b | 2018-01-16 15:07:54 -0500 | [diff] [blame] | 101 | |
Brian Salomon | f2c2ba9 | 2019-07-17 09:59:59 -0400 | [diff] [blame] | 102 | *backingSurface = |
| 103 | resourceProvider->createTexture(backingDesc, GrRenderable::kYes, SkBudgeted::kNo, |
| 104 | GrResourceProvider::Flags::kNoPendingIO); |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 105 | if (!(*backingSurface)) { |
| 106 | return nullptr; |
| 107 | } |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 108 | |
Robert Phillips | b67821d | 2017-12-13 15:00:45 -0500 | [diff] [blame] | 109 | GrBackendTexture backendTex = (*backingSurface)->getBackendTexture(); |
| 110 | |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 111 | sk_sp<SkSurface> surface = |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 112 | SkSurface::MakeFromBackendTextureAsRenderTarget(context, backendTex, origin, |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 113 | sampleCnt, colorType, nullptr, nullptr); |
Greg Daniel | 7ef28f3 | 2017-04-20 16:41:55 +0000 | [diff] [blame] | 114 | |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 115 | return surface; |
| 116 | } |
| 117 | } |
| 118 | |
| 119 | // Tests blending to a surface with no texture available. |
| 120 | DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) { |
| 121 | GrContext* context = ctxInfo.grContext(); |
| 122 | const int kWidth = 10; |
| 123 | const int kHeight = 10; |
| 124 | const GrPixelConfig kConfig = kRGBA_8888_GrPixelConfig; |
| 125 | const SkColorType kColorType = kRGBA_8888_SkColorType; |
| 126 | |
| 127 | // Build our test cases: |
| 128 | struct RectAndSamplePoint { |
| 129 | SkRect rect; |
| 130 | SkIPoint outPoint; |
| 131 | SkIPoint inPoint; |
| 132 | } allRectsAndPoints[3] = { |
| 133 | {SkRect::MakeXYWH(0, 0, 5, 5), SkIPoint::Make(7, 7), SkIPoint::Make(2, 2)}, |
Eric Karl | 72e551e | 2017-04-04 13:42:10 -0700 | [diff] [blame] | 134 | {SkRect::MakeXYWH(2, 2, 5, 5), SkIPoint::Make(1, 1), SkIPoint::Make(4, 4)}, |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 135 | {SkRect::MakeXYWH(5, 5, 5, 5), SkIPoint::Make(2, 2), SkIPoint::Make(7, 7)}, |
| 136 | }; |
| 137 | |
| 138 | struct TestCase { |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 139 | RectAndSamplePoint fRectAndPoints; |
| 140 | SkRect fClip; |
| 141 | int fSampleCnt; |
| 142 | GrSurfaceOrigin fOrigin; |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 143 | }; |
| 144 | std::vector<TestCase> testCases; |
| 145 | |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 146 | for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) { |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 147 | for (int sampleCnt : {1, 4}) { |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 148 | for (auto rectAndPoints : allRectsAndPoints) { |
| 149 | for (auto clip : {SkRect::MakeXYWH(0, 0, 10, 10), SkRect::MakeXYWH(1, 1, 8, 8)}) { |
| 150 | testCases.push_back({rectAndPoints, clip, sampleCnt, origin}); |
| 151 | } |
Eric Karl | 72e551e | 2017-04-04 13:42:10 -0700 | [diff] [blame] | 152 | } |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 153 | } |
| 154 | } |
| 155 | |
| 156 | // Run each test case: |
| 157 | for (auto testCase : testCases) { |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 158 | int sampleCnt = testCase.fSampleCnt; |
| 159 | SkRect paintRect = testCase.fRectAndPoints.rect; |
| 160 | SkIPoint outPoint = testCase.fRectAndPoints.outPoint; |
| 161 | SkIPoint inPoint = testCase.fRectAndPoints.inPoint; |
| 162 | GrSurfaceOrigin origin = testCase.fOrigin; |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 163 | |
| 164 | sk_sp<GrTexture> backingSurface; |
| 165 | // BGRA forces a framebuffer blit on ES2. |
| 166 | sk_sp<SkSurface> surface = create_gpu_surface_backend_texture_as_render_target( |
Greg Daniel | faa095e | 2017-12-19 13:15:02 -0500 | [diff] [blame] | 167 | context, sampleCnt, kWidth, kHeight, kColorType, kConfig, origin, &backingSurface); |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 168 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 169 | if (!surface && sampleCnt > 1) { |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 170 | // Some platforms don't support MSAA. |
| 171 | continue; |
| 172 | } |
| 173 | REPORTER_ASSERT(reporter, !!surface); |
| 174 | |
| 175 | // Fill our canvas with 0xFFFF80 |
| 176 | SkCanvas* canvas = surface->getCanvas(); |
Robert Phillips | bf25d43 | 2017-04-07 10:08:53 -0400 | [diff] [blame] | 177 | canvas->clipRect(testCase.fClip, false); |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 178 | SkPaint black_paint; |
| 179 | black_paint.setColor(SkColorSetRGB(0xFF, 0xFF, 0x80)); |
| 180 | canvas->drawRect(SkRect::MakeXYWH(0, 0, kWidth, kHeight), black_paint); |
| 181 | |
| 182 | // Blend 2x2 pixels at 5,5 with 0x80FFFF. Use multiply blend mode as this will trigger |
| 183 | // a copy of the destination. |
| 184 | SkPaint white_paint; |
| 185 | white_paint.setColor(SkColorSetRGB(0x80, 0xFF, 0xFF)); |
| 186 | white_paint.setBlendMode(SkBlendMode::kMultiply); |
| 187 | canvas->drawRect(paintRect, white_paint); |
| 188 | |
| 189 | // Read the result into a bitmap. |
| 190 | SkBitmap bitmap; |
| 191 | REPORTER_ASSERT(reporter, bitmap.tryAllocPixels(SkImageInfo::Make( |
| 192 | kWidth, kHeight, kColorType, kPremul_SkAlphaType))); |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 193 | REPORTER_ASSERT( |
| 194 | reporter, |
| 195 | surface->readPixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), 0, 0)); |
| 196 | |
| 197 | // Check the in/out pixels. |
| 198 | REPORTER_ASSERT(reporter, bitmap.getColor(outPoint.x(), outPoint.y()) == |
| 199 | SkColorSetRGB(0xFF, 0xFF, 0x80)); |
| 200 | REPORTER_ASSERT(reporter, bitmap.getColor(inPoint.x(), inPoint.y()) == |
| 201 | SkColorSetRGB(0x80, 0xFF, 0x80)); |
| 202 | |
| 203 | // Clean up - surface depends on backingSurface and must be released first. |
Eric Karl | 7448088 | 2017-04-03 14:49:05 -0700 | [diff] [blame] | 204 | surface.reset(); |
| 205 | backingSurface.reset(); |
| 206 | } |
| 207 | } |