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
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"
20 #include "include/gpu/GrBackendSurface.h"
21 #include "include/gpu/GrContext.h"
22 #include "include/gpu/GrTexture.h"
23 #include "include/gpu/GrTypes.h"
24 #include "include/private/GrTypesPriv.h"
25 #include "src/gpu/GrContextPriv.h"
26 #include "src/gpu/GrResourceProvider.h"
27 #include "tests/Test.h"
28 #include "tools/gpu/GrContextFactory.h"
29
30 #include <initializer_list>
31 #include <vector>
32
33 struct Results { int diffs, diffs_0x00, diffs_0xff, diffs_by_1; };
34
acceptable(const Results & r)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
43 }
44
45 template <typename Fn>
test(Fn && multiply)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++; }
57 }
58 }}
59 return r;
60 }
61
DEF_TEST(Blend_byte_multiply,r)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))); }
70
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); }
87 }
88
89 namespace {
create_gpu_surface_backend_texture_as_render_target(GrContext * context,int sampleCnt,SkISize dimensions,SkColorType colorType,GrSurfaceOrigin origin,sk_sp<GrTexture> * backingSurface)90 static sk_sp<SkSurface> create_gpu_surface_backend_texture_as_render_target(
91 GrContext* context, int sampleCnt, SkISize dimensions, SkColorType colorType,
92 GrSurfaceOrigin origin, sk_sp<GrTexture>* backingSurface) {
93 auto ct = SkColorTypeToGrColorType(colorType);
94 auto format = context->priv().caps()->getDefaultBackendFormat(ct, GrRenderable::kYes);
95
96 auto resourceProvider = context->priv().resourceProvider();
97
98 *backingSurface =
99 resourceProvider->createTexture(dimensions, format, GrRenderable::kYes, sampleCnt,
100 GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
101 if (!(*backingSurface)) {
102 return nullptr;
103 }
104
105 GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
106
107 sk_sp<SkSurface> surface =
108 SkSurface::MakeFromBackendTextureAsRenderTarget(context, backendTex, origin,
109 sampleCnt, colorType, nullptr, nullptr);
110
111 return surface;
112 }
113 }
114
115 // Tests blending to a surface with no texture available.
DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture,reporter,ctxInfo)116 DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(ES2BlendWithNoTexture, reporter, ctxInfo) {
117 GrContext* context = ctxInfo.grContext();
118 static constexpr SkISize kDimensions{10, 10};
119 const SkColorType kColorType = kRGBA_8888_SkColorType;
120
121 // Build our test cases:
122 struct RectAndSamplePoint {
123 SkRect rect;
124 SkIPoint outPoint;
125 SkIPoint inPoint;
126 } allRectsAndPoints[3] = {
127 {SkRect::MakeXYWH(0, 0, 5, 5), SkIPoint::Make(7, 7), SkIPoint::Make(2, 2)},
128 {SkRect::MakeXYWH(2, 2, 5, 5), SkIPoint::Make(1, 1), SkIPoint::Make(4, 4)},
129 {SkRect::MakeXYWH(5, 5, 5, 5), SkIPoint::Make(2, 2), SkIPoint::Make(7, 7)},
130 };
131
132 struct TestCase {
133 RectAndSamplePoint fRectAndPoints;
134 SkRect fClip;
135 int fSampleCnt;
136 GrSurfaceOrigin fOrigin;
137 };
138 std::vector<TestCase> testCases;
139
140 for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
141 for (int sampleCnt : {1, 4}) {
142 for (auto rectAndPoints : allRectsAndPoints) {
143 for (auto clip : {SkRect::MakeXYWH(0, 0, 10, 10), SkRect::MakeXYWH(1, 1, 8, 8)}) {
144 testCases.push_back({rectAndPoints, clip, sampleCnt, origin});
145 }
146 }
147 }
148 }
149
150 // Run each test case:
151 for (auto testCase : testCases) {
152 int sampleCnt = testCase.fSampleCnt;
153 SkRect paintRect = testCase.fRectAndPoints.rect;
154 SkIPoint outPoint = testCase.fRectAndPoints.outPoint;
155 SkIPoint inPoint = testCase.fRectAndPoints.inPoint;
156 GrSurfaceOrigin origin = testCase.fOrigin;
157
158 sk_sp<GrTexture> backingSurface;
159 // BGRA forces a framebuffer blit on ES2.
160 sk_sp<SkSurface> surface = create_gpu_surface_backend_texture_as_render_target(
161 context, sampleCnt, kDimensions, kColorType, origin, &backingSurface);
162
163 if (!surface && sampleCnt > 1) {
164 // Some platforms don't support MSAA.
165 continue;
166 }
167 REPORTER_ASSERT(reporter, !!surface);
168
169 // Fill our canvas with 0xFFFF80
170 SkCanvas* canvas = surface->getCanvas();
171 canvas->clipRect(testCase.fClip, false);
172 SkPaint black_paint;
173 black_paint.setColor(SkColorSetRGB(0xFF, 0xFF, 0x80));
174 canvas->drawRect(SkRect::Make(kDimensions), black_paint);
175
176 // Blend 2x2 pixels at 5,5 with 0x80FFFF. Use multiply blend mode as this will trigger
177 // a copy of the destination.
178 SkPaint white_paint;
179 white_paint.setColor(SkColorSetRGB(0x80, 0xFF, 0xFF));
180 white_paint.setBlendMode(SkBlendMode::kMultiply);
181 canvas->drawRect(paintRect, white_paint);
182
183 // Read the result into a bitmap.
184 SkBitmap bitmap;
185 REPORTER_ASSERT(reporter, bitmap.tryAllocPixels(SkImageInfo::Make(kDimensions, kColorType,
186 kPremul_SkAlphaType)));
187 REPORTER_ASSERT(
188 reporter,
189 surface->readPixels(bitmap.info(), bitmap.getPixels(), bitmap.rowBytes(), 0, 0));
190
191 // Check the in/out pixels.
192 REPORTER_ASSERT(reporter, bitmap.getColor(outPoint.x(), outPoint.y()) ==
193 SkColorSetRGB(0xFF, 0xFF, 0x80));
194 REPORTER_ASSERT(reporter, bitmap.getColor(inPoint.x(), inPoint.y()) ==
195 SkColorSetRGB(0x80, 0xFF, 0x80));
196
197 // Clean up - surface depends on backingSurface and must be released first.
198 surface.reset();
199 backingSurface.reset();
200 }
201 }
202