blob: 354bb3cebb8bc1aaa6c187dffb36707ddf9e0484 [file] [log] [blame]
mtklein767d2732015-07-16 07:01:39 -07001/*
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
Eric Karl74480882017-04-03 14:49:05 -07008#include <functional>
9#include "SkBitmap.h"
10#include "SkCanvas.h"
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000011#include "SkColor.h"
mtklein767d2732015-07-16 07:01:39 -070012#include "SkColorPriv.h"
Eric Karl74480882017-04-03 14:49:05 -070013#include "SkSurface.h"
mtklein767d2732015-07-16 07:01:39 -070014#include "SkTaskGroup.h"
Eric Karl74480882017-04-03 14:49:05 -070015#include "SkUtils.h"
16#include "Test.h"
17
18#if SK_SUPPORT_GPU
19#include "GrContext.h"
20#include "GrContextPriv.h"
21#include "GrResourceProvider.h"
22#include "GrSurfaceContext.h"
23#include "GrSurfaceProxy.h"
Greg Daniel7ef28f32017-04-20 16:41:55 +000024#include "GrTest.h"
Eric Karl74480882017-04-03 14:49:05 -070025#include "GrTexture.h"
26#endif
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000027
mtklein195fe082015-11-17 08:39:01 -080028struct Results { int diffs, diffs_0x00, diffs_0xff, diffs_by_1; };
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000029
mtklein195fe082015-11-17 08:39:01 -080030static bool acceptable(const Results& r) {
31#if 0
32 SkDebugf("%d diffs, %d at 0x00, %d at 0xff, %d off by 1, all out of 65536\n",
33 r.diffs, r.diffs_0x00, r.diffs_0xff, r.diffs_by_1);
34#endif
35 return r.diffs_by_1 == r.diffs // never off by more than 1
36 && r.diffs_0x00 == 0 // transparent must stay transparent
37 && r.diffs_0xff == 0; // opaque must stay opaque
commit-bot@chromium.org40ac5e52014-02-26 21:40:07 +000038}
39
mtklein195fe082015-11-17 08:39:01 -080040template <typename Fn>
41static Results test(Fn&& multiply) {
42 Results r = { 0,0,0,0 };
43 for (int x = 0; x < 256; x++) {
44 for (int y = 0; y < 256; y++) {
45 int p = multiply(x, y),
46 ideal = (x*y+127)/255;
47 if (p != ideal) {
48 r.diffs++;
49 if (x == 0x00 || y == 0x00) { r.diffs_0x00++; }
50 if (x == 0xff || y == 0xff) { r.diffs_0xff++; }
51 if (SkTAbs(ideal - p) == 1) { r.diffs_by_1++; }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000052 }
mtklein195fe082015-11-17 08:39:01 -080053 }}
54 return r;
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000055}
56
mtklein195fe082015-11-17 08:39:01 -080057DEF_TEST(Blend_byte_multiply, r) {
58 // These are all temptingly close but fundamentally broken.
59 int (*broken[])(int, int) = {
60 [](int x, int y) { return (x*y)>>8; },
61 [](int x, int y) { return (x*y+128)>>8; },
62 [](int x, int y) { y += y>>7; return (x*y)>>8; },
63 };
64 for (auto multiply : broken) { REPORTER_ASSERT(r, !acceptable(test(multiply))); }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000065
mtklein195fe082015-11-17 08:39:01 -080066 // These are fine to use, but not perfect.
67 int (*fine[])(int, int) = {
68 [](int x, int y) { return (x*y+x)>>8; },
69 [](int x, int y) { return (x*y+y)>>8; },
70 [](int x, int y) { return (x*y+255)>>8; },
71 [](int x, int y) { y += y>>7; return (x*y+128)>>8; },
72 };
73 for (auto multiply : fine) { REPORTER_ASSERT(r, acceptable(test(multiply))); }
74
75 // These are pefect.
76 int (*perfect[])(int, int) = {
77 [](int x, int y) { return (x*y+127)/255; }, // Duh.
78 [](int x, int y) { int p = (x*y+128); return (p+(p>>8))>>8; },
79 [](int x, int y) { return ((x*y+128)*257)>>16; },
80 };
81 for (auto multiply : perfect) { REPORTER_ASSERT(r, test(multiply).diffs == 0); }
commit-bot@chromium.org7f428a92014-02-25 21:31:03 +000082}
Eric Karl74480882017-04-03 14:49:05 -070083
84#if SK_SUPPORT_GPU
85namespace {
86static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
87 GrContext* context, int sampleCnt, int width, int height, GrPixelConfig config,
Robert Phillipsbf25d432017-04-07 10:08:53 -040088 GrSurfaceOrigin origin,
Eric Karl74480882017-04-03 14:49:05 -070089 sk_sp<GrTexture>* backingSurface) {
90 GrSurfaceDesc backingDesc;
Robert Phillips9a121cc2017-04-06 21:17:15 +000091 backingDesc.fFlags = kRenderTarget_GrSurfaceFlag;
Robert Phillipsbf25d432017-04-07 10:08:53 -040092 backingDesc.fOrigin = origin;
93 backingDesc.fWidth = width;
94 backingDesc.fHeight = height;
95 backingDesc.fConfig = config;
96 backingDesc.fSampleCnt = sampleCnt;
Eric Karl74480882017-04-03 14:49:05 -070097
Robert Phillipse78b7252017-04-06 07:59:41 -040098 *backingSurface = context->resourceProvider()->createTexture(backingDesc, SkBudgeted::kNo);
Robert Phillipsbf25d432017-04-07 10:08:53 -040099 if (!(*backingSurface)) {
100 return nullptr;
101 }
Eric Karl74480882017-04-03 14:49:05 -0700102
Greg Daniel7ef28f32017-04-20 16:41:55 +0000103 GrBackendTexture backendTex =
104 GrTest::CreateBackendTexture(context->contextPriv().getBackend(),
105 width,
106 height,
107 config,
Greg Daniel177e6952017-10-12 12:27:11 -0400108 GrMipMapped::kNo,
Greg Daniel7ef28f32017-04-20 16:41:55 +0000109 (*backingSurface)->getTextureHandle());
Eric Karl74480882017-04-03 14:49:05 -0700110 sk_sp<SkSurface> surface =
Greg Daniel7ef28f32017-04-20 16:41:55 +0000111 SkSurface::MakeFromBackendTextureAsRenderTarget(context, backendTex, origin,
112 sampleCnt, nullptr, nullptr);
113
Eric Karl74480882017-04-03 14:49:05 -0700114 return surface;
115}
116}
117
118// Tests blending to a surface with no texture available.
119DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) {
120 GrContext* context = ctxInfo.grContext();
121 const int kWidth = 10;
122 const int kHeight = 10;
123 const GrPixelConfig kConfig = kRGBA_8888_GrPixelConfig;
124 const SkColorType kColorType = kRGBA_8888_SkColorType;
125
126 // Build our test cases:
127 struct RectAndSamplePoint {
128 SkRect rect;
129 SkIPoint outPoint;
130 SkIPoint inPoint;
131 } allRectsAndPoints[3] = {
132 {SkRect::MakeXYWH(0, 0, 5, 5), SkIPoint::Make(7, 7), SkIPoint::Make(2, 2)},
Eric Karl72e551e2017-04-04 13:42:10 -0700133 {SkRect::MakeXYWH(2, 2, 5, 5), SkIPoint::Make(1, 1), SkIPoint::Make(4, 4)},
Eric Karl74480882017-04-03 14:49:05 -0700134 {SkRect::MakeXYWH(5, 5, 5, 5), SkIPoint::Make(2, 2), SkIPoint::Make(7, 7)},
135 };
136
137 struct TestCase {
Robert Phillipsbf25d432017-04-07 10:08:53 -0400138 RectAndSamplePoint fRectAndPoints;
139 SkRect fClip;
140 int fSampleCnt;
141 GrSurfaceOrigin fOrigin;
Eric Karl74480882017-04-03 14:49:05 -0700142 };
143 std::vector<TestCase> testCases;
144
Robert Phillipsbf25d432017-04-07 10:08:53 -0400145 for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
146 for (int sampleCnt : {0, 4}) {
147 for (auto rectAndPoints : allRectsAndPoints) {
148 for (auto clip : {SkRect::MakeXYWH(0, 0, 10, 10), SkRect::MakeXYWH(1, 1, 8, 8)}) {
149 testCases.push_back({rectAndPoints, clip, sampleCnt, origin});
150 }
Eric Karl72e551e2017-04-04 13:42:10 -0700151 }
Eric Karl74480882017-04-03 14:49:05 -0700152 }
153 }
154
155 // Run each test case:
156 for (auto testCase : testCases) {
Robert Phillipsbf25d432017-04-07 10:08:53 -0400157 int sampleCnt = testCase.fSampleCnt;
158 SkRect paintRect = testCase.fRectAndPoints.rect;
159 SkIPoint outPoint = testCase.fRectAndPoints.outPoint;
160 SkIPoint inPoint = testCase.fRectAndPoints.inPoint;
161 GrSurfaceOrigin origin = testCase.fOrigin;
Eric Karl74480882017-04-03 14:49:05 -0700162
163 sk_sp<GrTexture> backingSurface;
164 // BGRA forces a framebuffer blit on ES2.
165 sk_sp<SkSurface> surface = create_gpu_surface_backend_texture_as_render_target(
Robert Phillipsbf25d432017-04-07 10:08:53 -0400166 context, sampleCnt, kWidth, kHeight, kConfig, origin, &backingSurface);
Eric Karl74480882017-04-03 14:49:05 -0700167
168 if (!surface && sampleCnt > 0) {
169 // Some platforms don't support MSAA.
170 continue;
171 }
172 REPORTER_ASSERT(reporter, !!surface);
173
174 // Fill our canvas with 0xFFFF80
175 SkCanvas* canvas = surface->getCanvas();
Robert Phillipsbf25d432017-04-07 10:08:53 -0400176 canvas->clipRect(testCase.fClip, false);
Eric Karl74480882017-04-03 14:49:05 -0700177 SkPaint black_paint;
178 black_paint.setColor(SkColorSetRGB(0xFF, 0xFF, 0x80));
179 canvas->drawRect(SkRect::MakeXYWH(0, 0, kWidth, kHeight), black_paint);
180
181 // Blend 2x2 pixels at 5,5 with 0x80FFFF. Use multiply blend mode as this will trigger
182 // a copy of the destination.
183 SkPaint white_paint;
184 white_paint.setColor(SkColorSetRGB(0x80, 0xFF, 0xFF));
185 white_paint.setBlendMode(SkBlendMode::kMultiply);
186 canvas->drawRect(paintRect, white_paint);
187
188 // Read the result into a bitmap.
189 SkBitmap bitmap;
190 REPORTER_ASSERT(reporter, bitmap.tryAllocPixels(SkImageInfo::Make(
191 kWidth, kHeight, kColorType, kPremul_SkAlphaType)));
Eric Karl74480882017-04-03 14:49:05 -0700192 REPORTER_ASSERT(
193 reporter,
194 surface->readPixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), 0, 0));
195
196 // Check the in/out pixels.
197 REPORTER_ASSERT(reporter, bitmap.getColor(outPoint.x(), outPoint.y()) ==
198 SkColorSetRGB(0xFF, 0xFF, 0x80));
199 REPORTER_ASSERT(reporter, bitmap.getColor(inPoint.x(), inPoint.y()) ==
200 SkColorSetRGB(0x80, 0xFF, 0x80));
201
202 // Clean up - surface depends on backingSurface and must be released first.
Eric Karl74480882017-04-03 14:49:05 -0700203 surface.reset();
204 backingSurface.reset();
205 }
206}
207#endif