blob: 75d2178ac27a948a94177ba9744963de81bdd05e [file] [log] [blame]
Robert Phillips0c6daf02019-05-16 12:43:11 -04001/*
2 * Copyright 2019 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
Robert Phillipse19babf2020-04-06 13:57:30 -04008#include "include/core/SkCanvas.h"
Mike Kleinfe0aeb32019-05-20 10:55:11 -05009#include "include/core/SkSurface.h"
Robert Phillips02dc0302019-07-02 17:58:27 -040010#include "include/core/SkSurfaceCharacterization.h"
Robert Phillips6d344c32020-07-06 10:56:46 -040011#include "include/gpu/GrDirectContext.h"
Robert Phillips459b2952019-05-23 09:38:27 -040012#include "src/core/SkAutoPixmapStorage.h"
Adlai Hollera0693042020-10-14 11:23:11 -040013#include "src/gpu/GrDirectContextPriv.h"
Robert Phillipsefb9f142019-05-17 14:19:44 -040014#include "src/image/SkImage_Base.h"
Robert Phillips0c6daf02019-05-16 12:43:11 -040015#include "tests/Test.h"
Robert Phillipse3b6fe42019-09-11 11:26:46 -040016#include "tests/TestUtils.h"
17#include "tools/ToolUtils.h"
Robert Phillips0c6daf02019-05-16 12:43:11 -040018
Robert Phillips27eb5252019-06-03 12:59:40 -040019#ifdef SK_GL
Robert Phillipsee946932019-12-18 11:16:17 -050020#include "src/gpu/gl/GrGLCaps.h"
21#include "src/gpu/gl/GrGLDefines.h"
Robert Phillips27eb5252019-06-03 12:59:40 -040022#include "src/gpu/gl/GrGLGpu.h"
23#include "src/gpu/gl/GrGLUtil.h"
24#endif
25
Robert Phillips7f367982019-09-26 14:01:36 -040026#ifdef SK_METAL
27#include "include/gpu/mtl/GrMtlTypes.h"
28#include "src/gpu/mtl/GrMtlCppUtil.h"
29#endif
30
Robert Phillipsfe4b4812020-07-17 14:15:51 -040031static void wait_on_backend_work_to_finish(GrDirectContext* dContext, bool* finishedCreate) {
32 dContext->submit();
Greg Danielc1ad77c2020-05-06 11:40:03 -040033 while (finishedCreate && !(*finishedCreate)) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -040034 dContext->checkAsyncWorkCompletion();
Greg Danielc1ad77c2020-05-06 11:40:03 -040035 }
36 if (finishedCreate) {
37 // The same boolean (pointed to by finishedCreate) is often used multiply and sequentially
38 // throughout our tests to create different backend textures.
39 // Reset it here so that it can be use to signal a future backend texture's creation
40 *finishedCreate = false;
41 }
Greg Danielb2365d82020-05-13 15:32:04 -040042}
43
Robert Phillipsfe4b4812020-07-17 14:15:51 -040044static void delete_backend_texture(GrDirectContext* dContext,
45 const GrBackendTexture& backendTexture,
Greg Danielb2365d82020-05-13 15:32:04 -040046 bool* finishedCreate) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -040047 wait_on_backend_work_to_finish(dContext, finishedCreate);
48 dContext->deleteBackendTexture(backendTexture);
Greg Danielc1ad77c2020-05-06 11:40:03 -040049}
50
Greg Danielb2365d82020-05-13 15:32:04 -040051static void mark_signaled(void* context) {
52 *(bool*)context = true;
53}
54
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -040055// Test wrapping of GrBackendObjects in SkSurfaces and SkImages (non-static since used in Mtl test)
Robert Phillipsfe4b4812020-07-17 14:15:51 -040056void test_wrapping(GrDirectContext* dContext,
57 skiatest::Reporter* reporter,
58 std::function<GrBackendTexture (GrDirectContext*,
Brian Salomon7e67dca2020-07-21 09:27:25 -040059 GrMipmapped,
Robert Phillipsb04b6942019-05-21 17:24:31 -040060 GrRenderable)> create,
Robert Phillipsfe4b4812020-07-17 14:15:51 -040061 GrColorType grColorType,
Brian Salomon7e67dca2020-07-21 09:27:25 -040062 GrMipmapped mipMapped,
Robert Phillipsfe4b4812020-07-17 14:15:51 -040063 GrRenderable renderable,
Greg Danielc1ad77c2020-05-06 11:40:03 -040064 bool* finishedBECreate) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -040065 GrResourceCache* cache = dContext->priv().getResourceCache();
Robert Phillips0c6daf02019-05-16 12:43:11 -040066
67 const int initialCount = cache->getResourceCount();
68
Robert Phillipsfe4b4812020-07-17 14:15:51 -040069 GrBackendTexture backendTex = create(dContext, mipMapped, renderable);
Robert Phillipsefb9f142019-05-17 14:19:44 -040070 if (!backendTex.isValid()) {
Robert Phillipsb7f95d12019-07-26 11:13:19 -040071 ERRORF(reporter, "Couldn't create backendTexture for grColorType %d renderable %s\n",
72 grColorType,
Robert Phillips0c6daf02019-05-16 12:43:11 -040073 GrRenderable::kYes == renderable ? "yes" : "no");
74 return;
75 }
Robert Phillipsb04b6942019-05-21 17:24:31 -040076
Robert Phillips0c6daf02019-05-16 12:43:11 -040077 // Skia proper should know nothing about the new backend object
78 REPORTER_ASSERT(reporter, initialCount == cache->getResourceCount());
79
Robert Phillipsb7f95d12019-07-26 11:13:19 -040080 SkColorType skColorType = GrColorTypeToSkColorType(grColorType);
81
82 // Wrapping a backendTexture in an image requires an SkColorType
83 if (kUnknown_SkColorType == skColorType) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -040084 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillipsb04b6942019-05-21 17:24:31 -040085 return;
86 }
87
Robert Phillipsfe4b4812020-07-17 14:15:51 -040088 if (GrRenderable::kYes == renderable && dContext->colorTypeSupportedAsSurface(skColorType)) {
89 sk_sp<SkSurface> surf = SkSurface::MakeFromBackendTexture(dContext,
Robert Phillips459b2952019-05-23 09:38:27 -040090 backendTex,
91 kTopLeft_GrSurfaceOrigin,
92 0,
Robert Phillipsb7f95d12019-07-26 11:13:19 -040093 skColorType,
Robert Phillips459b2952019-05-23 09:38:27 -040094 nullptr, nullptr);
Robert Phillipsb04b6942019-05-21 17:24:31 -040095 if (!surf) {
Robert Phillips9a30ee02020-04-29 08:58:39 -040096 ERRORF(reporter, "Couldn't make surface from backendTexture for %s\n",
97 ToolUtils::colortype_name(skColorType));
Robert Phillipsb04b6942019-05-21 17:24:31 -040098 } else {
99 REPORTER_ASSERT(reporter, initialCount+1 == cache->getResourceCount());
Robert Phillips0c6daf02019-05-16 12:43:11 -0400100 }
Robert Phillipsb04b6942019-05-21 17:24:31 -0400101 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400102
Robert Phillipsb04b6942019-05-21 17:24:31 -0400103 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400104 sk_sp<SkImage> img = SkImage::MakeFromTexture(dContext,
Robert Phillips459b2952019-05-23 09:38:27 -0400105 backendTex,
106 kTopLeft_GrSurfaceOrigin,
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400107 skColorType,
Robert Phillips459b2952019-05-23 09:38:27 -0400108 kPremul_SkAlphaType,
109 nullptr);
Robert Phillipsb04b6942019-05-21 17:24:31 -0400110 if (!img) {
Robert Phillips9a30ee02020-04-29 08:58:39 -0400111 ERRORF(reporter, "Couldn't make image from backendTexture for %s\n",
112 ToolUtils::colortype_name(skColorType));
Robert Phillipsb04b6942019-05-21 17:24:31 -0400113 } else {
114 SkImage_Base* ib = as_IB(img);
Robert Phillipsefb9f142019-05-17 14:19:44 -0400115
Robert Phillipsb04b6942019-05-21 17:24:31 -0400116 GrTextureProxy* proxy = ib->peekProxy();
117 REPORTER_ASSERT(reporter, proxy);
Robert Phillipsefb9f142019-05-17 14:19:44 -0400118
Brian Salomon8c82a872020-07-21 12:09:58 -0400119 REPORTER_ASSERT(reporter, mipMapped == proxy->proxyMipmapped());
Robert Phillipsb04b6942019-05-21 17:24:31 -0400120 REPORTER_ASSERT(reporter, proxy->isInstantiated());
Brian Salomon8c82a872020-07-21 12:09:58 -0400121 REPORTER_ASSERT(reporter, mipMapped == proxy->mipmapped());
Robert Phillipsefb9f142019-05-17 14:19:44 -0400122
Robert Phillipsb04b6942019-05-21 17:24:31 -0400123 REPORTER_ASSERT(reporter, initialCount+1 == cache->getResourceCount());
Robert Phillips0c6daf02019-05-16 12:43:11 -0400124 }
125 }
126
127 REPORTER_ASSERT(reporter, initialCount == cache->getResourceCount());
128
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400129 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillips0c6daf02019-05-16 12:43:11 -0400130}
131
Robert Phillips9a30ee02020-04-29 08:58:39 -0400132static bool isBGRA8(const GrBackendFormat& format) {
Robert Phillips7f367982019-09-26 14:01:36 -0400133 switch (format.backend()) {
Robert Phillips7f367982019-09-26 14:01:36 -0400134 case GrBackendApi::kOpenGL:
135#ifdef SK_GL
136 return format.asGLFormat() == GrGLFormat::kBGRA8;
137#else
138 return false;
139#endif
140 case GrBackendApi::kVulkan: {
141#ifdef SK_VULKAN
142 VkFormat vkFormat;
143 format.asVkFormat(&vkFormat);
144 return vkFormat == VK_FORMAT_B8G8R8A8_UNORM;
145#else
146 return false;
147#endif
148 }
Jim Van Verthb01e12b2020-02-18 14:34:38 -0500149 case GrBackendApi::kMetal:
150#ifdef SK_METAL
Robert Phillips9a30ee02020-04-29 08:58:39 -0400151 return GrMtlFormatIsBGRA8(format.asMtlFormat());
Jim Van Verthb01e12b2020-02-18 14:34:38 -0500152#else
153 return false;
154#endif
155 case GrBackendApi::kDirect3D:
156#ifdef SK_DIRECT3D
157 return false; // TODO
158#else
159 return false;
160#endif
161 case GrBackendApi::kDawn:
Stephen White36248742020-06-10 22:24:57 -0400162#ifdef SK_DAWN
163 wgpu::TextureFormat dawnFormat;
164 format.asDawnFormat(&dawnFormat);
165 return dawnFormat == wgpu::TextureFormat::BGRA8Unorm;
166#else
Jim Van Verthb01e12b2020-02-18 14:34:38 -0500167 return false;
Stephen White36248742020-06-10 22:24:57 -0400168#endif
Robert Phillipsa27d6252019-12-10 14:48:36 -0500169 case GrBackendApi::kMock: {
170 SkImage::CompressionType compression = format.asMockCompressionType();
171 if (compression != SkImage::CompressionType::kNone) {
172 return false; // No compressed formats are BGRA
173 }
174
Robert Phillips7f367982019-09-26 14:01:36 -0400175 return format.asMockColorType() == GrColorType::kBGRA_8888;
Robert Phillipsa27d6252019-12-10 14:48:36 -0500176 }
Robert Phillips7f367982019-09-26 14:01:36 -0400177 }
178 SkUNREACHABLE;
179}
180
181static bool isRGB(const GrBackendFormat& format) {
182 switch (format.backend()) {
Robert Phillips7f367982019-09-26 14:01:36 -0400183 case GrBackendApi::kOpenGL:
184#ifdef SK_GL
185 return format.asGLFormat() == GrGLFormat::kRGB8;
186#else
187 return false;
188#endif
189 case GrBackendApi::kVulkan: {
190#ifdef SK_VULKAN
191 VkFormat vkFormat;
192 format.asVkFormat(&vkFormat);
193 return vkFormat == VK_FORMAT_R8G8B8_UNORM;
194#else
195 return false;
196#endif
197 }
Jim Van Verthb01e12b2020-02-18 14:34:38 -0500198 case GrBackendApi::kMetal:
199 return false; // Metal doesn't even pretend to support this
200 case GrBackendApi::kDirect3D:
201 return false; // Not supported in Direct3D 12
202 case GrBackendApi::kDawn:
203 return false;
Robert Phillips7f367982019-09-26 14:01:36 -0400204 case GrBackendApi::kMock:
205 return false; // No GrColorType::kRGB_888
206 }
207 SkUNREACHABLE;
208}
209
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400210static void check_solid_pixmap(skiatest::Reporter* reporter,
211 const SkColor4f& expected, const SkPixmap& actual,
Robert Phillips7f367982019-09-26 14:01:36 -0400212 SkColorType ct, const char* label1, const char* label2) {
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400213 // we need 0.001f across the board just for noise
214 // we need 0.01f across the board for 1010102
Robert Phillips7f367982019-09-26 14:01:36 -0400215 const float tols[4] = { 0.01f, 0.01f, 0.01f, 0.01f };
Robert Phillips27eb5252019-06-03 12:59:40 -0400216
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400217 auto error = std::function<ComparePixmapsErrorReporter>(
Robert Phillips7f367982019-09-26 14:01:36 -0400218 [reporter, ct, label1, label2](int x, int y, const float diffs[4]) {
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400219 SkASSERT(x >= 0 && y >= 0);
Robert Phillips7f367982019-09-26 14:01:36 -0400220 ERRORF(reporter, "%s %s %s - mismatch at %d, %d (%f, %f, %f %f)",
221 ToolUtils::colortype_name(ct), label1, label2, x, y,
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400222 diffs[0], diffs[1], diffs[2], diffs[3]);
223 });
224
Brian Salomon28a8f282019-10-24 20:07:39 -0400225 CheckSolidPixels(expected, actual, tols, error);
Robert Phillips27eb5252019-06-03 12:59:40 -0400226}
227
Robert Phillips7f367982019-09-26 14:01:36 -0400228// What would raster do?
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400229static SkColor4f get_expected_color(SkColor4f orig, SkColorType ct) {
Robert Phillips7f367982019-09-26 14:01:36 -0400230 SkAlphaType at = SkColorTypeIsAlwaysOpaque(ct) ? kOpaque_SkAlphaType
231 : kPremul_SkAlphaType;
Robert Phillipse3b6fe42019-09-11 11:26:46 -0400232
Robert Phillips7f367982019-09-26 14:01:36 -0400233 SkImageInfo ii = SkImageInfo::Make(2, 2, ct, at);
234 SkAutoPixmapStorage pm;
235 pm.alloc(ii);
236 pm.erase(orig);
237 SkColor tmp = pm.getColor(0, 0);
238 return SkColor4f::FromColor(tmp);
Robert Phillips459b2952019-05-23 09:38:27 -0400239}
240
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400241static void check_mipmaps(GrDirectContext*, const GrBackendTexture&,
242 SkColorType, const SkColor4f expectedColors[6],
243 skiatest::Reporter*, const char* label);
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400244
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400245static void check_base_readbacks(GrDirectContext* dContext, const GrBackendTexture& backendTex,
Robert Phillips0ee10342019-09-25 09:55:16 -0400246 SkColorType skColorType, GrRenderable renderable,
Robert Phillips7f367982019-09-26 14:01:36 -0400247 const SkColor4f& color, skiatest::Reporter* reporter,
248 const char* label) {
249 if (isRGB(backendTex.getBackendFormat())) {
250 // readPixels is busted for the RGB backend format (skbug.com/8862)
251 // TODO: add a GrColorType::kRGB_888 to fix the situation
252 return;
253 }
Robert Phillips0ee10342019-09-25 09:55:16 -0400254
255 SkAlphaType at = SkColorTypeIsAlwaysOpaque(skColorType) ? kOpaque_SkAlphaType
256 : kPremul_SkAlphaType;
257
258 SkColor4f expectedColor = get_expected_color(color, skColorType);
259
260 SkAutoPixmapStorage actual;
261
262 {
263 SkImageInfo readBackII = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
Robert Phillips7f367982019-09-26 14:01:36 -0400264 kUnpremul_SkAlphaType);
Robert Phillips0ee10342019-09-25 09:55:16 -0400265
266 SkAssertResult(actual.tryAlloc(readBackII));
267 }
268
Robert Phillips0ee10342019-09-25 09:55:16 -0400269 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400270 sk_sp<SkImage> img = SkImage::MakeFromTexture(dContext,
Robert Phillips0ee10342019-09-25 09:55:16 -0400271 backendTex,
272 kTopLeft_GrSurfaceOrigin,
273 skColorType,
274 at,
275 nullptr);
276 if (img) {
277 actual.erase(SkColors::kTransparent);
Adlai Hollerbcfc5542020-08-27 12:44:07 -0400278 bool result = img->readPixels(dContext, actual, 0, 0);
Robert Phillips0ee10342019-09-25 09:55:16 -0400279 if (!result) {
280 // TODO: we need a better way to tell a priori if readPixels will work for an
281 // arbitrary colorType
282#if 0
283 ERRORF(reporter, "Couldn't readback from SkImage for colorType: %d\n", colorType);
284#endif
285 } else {
286 check_solid_pixmap(reporter, expectedColor, actual, skColorType,
Robert Phillips7f367982019-09-26 14:01:36 -0400287 label, "SkImage::readPixels");
Robert Phillips0ee10342019-09-25 09:55:16 -0400288 }
289 }
290 }
Robert Phillips7f367982019-09-26 14:01:36 -0400291
292 // This will mark any mipmaps as dirty (bc that is what we do when we wrap a renderable
293 // backend texture) so it must be done last!
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400294 if (GrRenderable::kYes == renderable && dContext->colorTypeSupportedAsSurface(skColorType)) {
295 sk_sp<SkSurface> surf = SkSurface::MakeFromBackendTexture(dContext,
Robert Phillips7f367982019-09-26 14:01:36 -0400296 backendTex,
297 kTopLeft_GrSurfaceOrigin,
298 0,
299 skColorType,
300 nullptr, nullptr);
301 if (surf) {
302 actual.erase(SkColors::kTransparent);
303 bool result = surf->readPixels(actual, 0, 0);
304 REPORTER_ASSERT(reporter, result);
305
306 check_solid_pixmap(reporter, expectedColor, actual, skColorType,
307 label, "SkSurface::readPixels");
308 }
309 }
Robert Phillips0ee10342019-09-25 09:55:16 -0400310}
311
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400312// Test initialization of GrBackendObjects to a specific color (non-static since used in Mtl test)
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400313void test_color_init(GrDirectContext* dContext,
314 skiatest::Reporter* reporter,
315 std::function<GrBackendTexture (GrDirectContext*,
Robert Phillips459b2952019-05-23 09:38:27 -0400316 const SkColor4f&,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400317 GrMipmapped,
Robert Phillips459b2952019-05-23 09:38:27 -0400318 GrRenderable)> create,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400319 GrColorType grColorType,
320 const SkColor4f& color,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400321 GrMipmapped mipMapped,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400322 GrRenderable renderable,
323 bool* finishedBECreate) {
324 GrBackendTexture backendTex = create(dContext, color, mipMapped, renderable);
Robert Phillips459b2952019-05-23 09:38:27 -0400325 if (!backendTex.isValid()) {
326 // errors here should be reported by the test_wrapping test
327 return;
328 }
329
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400330 SkColorType skColorType = GrColorTypeToSkColorType(grColorType);
331
332 // Can't wrap backend textures in images and surfaces w/o an SkColorType
333 if (kUnknown_SkColorType == skColorType) {
Robert Phillips459b2952019-05-23 09:38:27 -0400334 // TODO: burrow in and scrappily check that data was uploaded!
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400335 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillips459b2952019-05-23 09:38:27 -0400336 return;
337 }
338
Greg Danielb2365d82020-05-13 15:32:04 -0400339 auto checkBackendTexture = [&](const SkColor4f& testColor) {
Brian Salomon7e67dca2020-07-21 09:27:25 -0400340 if (mipMapped == GrMipmapped::kYes) {
Greg Danielb2365d82020-05-13 15:32:04 -0400341 SkColor4f expectedColor = get_expected_color(testColor, skColorType);
342 SkColor4f expectedColors[6] = {expectedColor, expectedColor, expectedColor,
343 expectedColor, expectedColor, expectedColor};
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400344 check_mipmaps(dContext, backendTex, skColorType, expectedColors,
345 reporter, "colorinit");
Greg Danielb2365d82020-05-13 15:32:04 -0400346 }
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400347
Greg Danielb2365d82020-05-13 15:32:04 -0400348 // The last step in this test will dirty the mipmaps so do it last
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400349 check_base_readbacks(dContext, backendTex, skColorType, renderable, testColor,
350 reporter, "colorinit");
Greg Danielb2365d82020-05-13 15:32:04 -0400351 };
352
353 checkBackendTexture(color);
354
355 // Make sure the initial create work has finished so we can test the update independently.
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400356 wait_on_backend_work_to_finish(dContext, finishedBECreate);
Greg Danielb2365d82020-05-13 15:32:04 -0400357
358 SkColor4f newColor = {color.fB , color.fR, color.fG, color.fA };
359
Greg Daniel373d7dd2020-07-21 10:41:50 -0400360 dContext->updateBackendTexture(backendTex, skColorType, newColor, mark_signaled,
361 finishedBECreate);
Greg Danielb2365d82020-05-13 15:32:04 -0400362
363 checkBackendTexture(newColor);
364
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400365 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillips459b2952019-05-23 09:38:27 -0400366}
367
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400368// Draw the backend texture (wrapped in an SkImage) into an RGBA surface, attempting to access
369// all the mipMap levels.
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400370static void check_mipmaps(GrDirectContext* dContext, const GrBackendTexture& backendTex,
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400371 SkColorType skColorType, const SkColor4f expectedColors[6],
Robert Phillips7f367982019-09-26 14:01:36 -0400372 skiatest::Reporter* reporter, const char* label) {
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400373
374#ifdef SK_GL
375 // skbug.com/9141 (RGBA_F32 mipmaps appear to be broken on some Mali devices)
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400376 if (GrBackendApi::kOpenGL == dContext->backend()) {
377 GrGLGpu* glGPU = static_cast<GrGLGpu*>(dContext->priv().getGpu());
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400378
379 if (kRGBA_F32_SkColorType == skColorType &&
380 kGLES_GrGLStandard == glGPU->ctxInfo().standard()) {
381 return;
382 }
383 }
384#endif
385
Robert Phillips7f367982019-09-26 14:01:36 -0400386 if (isRGB(backendTex.getBackendFormat())) {
387 // readPixels is busted for the RGB backend format (skbug.com/8862)
388 // TODO: add a GrColorType::kRGB_888 to fix the situation
389 return;
390 }
391
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400392 SkAlphaType at = SkColorTypeIsAlwaysOpaque(skColorType) ? kOpaque_SkAlphaType
393 : kPremul_SkAlphaType;
Robert Phillips7f367982019-09-26 14:01:36 -0400394
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400395 sk_sp<SkImage> img = SkImage::MakeFromTexture(dContext,
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400396 backendTex,
397 kTopLeft_GrSurfaceOrigin,
398 skColorType,
399 at,
400 nullptr);
401 if (!img) {
402 return;
403 }
404
Robert Phillips7f367982019-09-26 14:01:36 -0400405 SkImageInfo readbackSurfaceII = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
406 kPremul_SkAlphaType);
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400407
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400408 sk_sp<SkSurface> surf = SkSurface::MakeRenderTarget(dContext,
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400409 SkBudgeted::kNo,
Robert Phillips7f367982019-09-26 14:01:36 -0400410 readbackSurfaceII, 1,
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400411 kTopLeft_GrSurfaceOrigin,
412 nullptr);
413 if (!surf) {
414 return;
415 }
416
417 SkCanvas* canvas = surf->getCanvas();
418
419 SkPaint p;
Mike Reed8dacba32020-11-19 09:50:28 -0500420 p.setFilterQuality(kMedium_SkFilterQuality); // to force mipMapping
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400421
422 int numMipLevels = 6;
423
424 for (int i = 0, rectSize = 32; i < numMipLevels; ++i, rectSize /= 2) {
425 SkASSERT(rectSize >= 1);
426
427 SkRect r = SkRect::MakeWH(rectSize, rectSize);
428 canvas->clear(SK_ColorTRANSPARENT);
429 canvas->drawImageRect(img, r, &p);
430
431 SkImageInfo readbackII = SkImageInfo::Make(rectSize, rectSize,
432 kRGBA_8888_SkColorType,
Robert Phillips7f367982019-09-26 14:01:36 -0400433 kUnpremul_SkAlphaType);
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400434 SkAutoPixmapStorage actual2;
435 SkAssertResult(actual2.tryAlloc(readbackII));
436 actual2.erase(SkColors::kTransparent);
437
438 bool result = surf->readPixels(actual2, 0, 0);
439 REPORTER_ASSERT(reporter, result);
440
Robert Phillipsee946932019-12-18 11:16:17 -0500441 SkString str;
442 str.appendf("mip-level %d", i);
443
Robert Phillips7f367982019-09-26 14:01:36 -0400444 check_solid_pixmap(reporter, expectedColors[i], actual2, skColorType,
Robert Phillipsee946932019-12-18 11:16:17 -0500445 label, str.c_str());
Robert Phillipsc1dbb4b2019-09-24 16:32:35 -0400446 }
447}
448
Brian Salomon7e67dca2020-07-21 09:27:25 -0400449static int make_pixmaps(SkColorType skColorType, GrMipmapped mipMapped,
Robert Phillips7f367982019-09-26 14:01:36 -0400450 const SkColor4f colors[6], SkAutoPixmapStorage pixmaps[6]) {
451 int levelSize = 32;
Brian Salomon7e67dca2020-07-21 09:27:25 -0400452 int numMipLevels = mipMapped == GrMipmapped::kYes ? 6 : 1;
Robert Phillips7f367982019-09-26 14:01:36 -0400453 SkAlphaType at = SkColorTypeIsAlwaysOpaque(skColorType) ? kOpaque_SkAlphaType
454 : kPremul_SkAlphaType;
455 for (int level = 0; level < numMipLevels; ++level) {
456 SkImageInfo ii = SkImageInfo::Make(levelSize, levelSize, skColorType, at);
457 pixmaps[level].alloc(ii);
458 pixmaps[level].erase(colors[level]);
459 levelSize /= 2;
460 }
461 return numMipLevels;
462}
463
464// Test initialization of GrBackendObjects using SkPixmaps
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400465static void test_pixmap_init(GrDirectContext* dContext,
466 skiatest::Reporter* reporter,
Brian Salomonb5f880a2020-12-07 11:30:16 -0500467 std::function<GrBackendTexture(GrDirectContext*,
468 const SkPixmap srcData[],
469 int numLevels,
470 GrSurfaceOrigin,
471 GrRenderable)> create,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400472 SkColorType skColorType,
Brian Salomonb5f880a2020-12-07 11:30:16 -0500473 GrSurfaceOrigin origin,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400474 GrMipmapped mipMapped,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400475 GrRenderable renderable,
476 bool* finishedBECreate) {
Robert Phillips7f367982019-09-26 14:01:36 -0400477 SkAutoPixmapStorage pixmapMem[6];
478 SkColor4f colors[6] = {
479 { 1.0f, 0.0f, 0.0f, 1.0f }, // R
480 { 0.0f, 1.0f, 0.0f, 0.9f }, // G
481 { 0.0f, 0.0f, 1.0f, 0.7f }, // B
482 { 0.0f, 1.0f, 1.0f, 0.5f }, // C
483 { 1.0f, 0.0f, 1.0f, 0.3f }, // M
484 { 1.0f, 1.0f, 0.0f, 0.2f }, // Y
485 };
486
487 int numMipLevels = make_pixmaps(skColorType, mipMapped, colors, pixmapMem);
488 SkASSERT(numMipLevels);
489
490 // TODO: this is tedious. Should we pass in an array of SkBitmaps instead?
491 SkPixmap pixmaps[6];
492 for (int i = 0; i < numMipLevels; ++i) {
493 pixmaps[i].reset(pixmapMem[i].info(), pixmapMem[i].addr(), pixmapMem[i].rowBytes());
494 }
495
Brian Salomonb5f880a2020-12-07 11:30:16 -0500496 GrBackendTexture backendTex = create(dContext, pixmaps, numMipLevels, origin, renderable);
Robert Phillips7f367982019-09-26 14:01:36 -0400497 if (!backendTex.isValid()) {
498 // errors here should be reported by the test_wrapping test
499 return;
500 }
501
Robert Phillips9a30ee02020-04-29 08:58:39 -0400502 if (skColorType == kBGRA_8888_SkColorType && !isBGRA8(backendTex.getBackendFormat())) {
Robert Phillips7f367982019-09-26 14:01:36 -0400503 // When kBGRA is backed by an RGBA something goes wrong in the swizzling
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400504 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillips7f367982019-09-26 14:01:36 -0400505 return;
506 }
507
Greg Danielb2365d82020-05-13 15:32:04 -0400508 auto checkBackendTexture = [&](SkColor4f colors[6]) {
Brian Salomon7e67dca2020-07-21 09:27:25 -0400509 if (mipMapped == GrMipmapped::kYes) {
Greg Danielb2365d82020-05-13 15:32:04 -0400510 SkColor4f expectedColors[6] = {
511 get_expected_color(colors[0], skColorType),
512 get_expected_color(colors[1], skColorType),
513 get_expected_color(colors[2], skColorType),
514 get_expected_color(colors[3], skColorType),
515 get_expected_color(colors[4], skColorType),
516 get_expected_color(colors[5], skColorType),
517 };
Robert Phillips7f367982019-09-26 14:01:36 -0400518
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400519 check_mipmaps(dContext, backendTex, skColorType, expectedColors, reporter, "pixmap");
Greg Danielb2365d82020-05-13 15:32:04 -0400520 }
521
522 // The last step in this test will dirty the mipmaps so do it last
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400523 check_base_readbacks(dContext, backendTex, skColorType, renderable, colors[0], reporter,
Greg Danielb2365d82020-05-13 15:32:04 -0400524 "pixmap");
525 };
526
527 checkBackendTexture(colors);
528
529 // Make sure the initial create work has finished so we can test the update independently.
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400530 wait_on_backend_work_to_finish(dContext, finishedBECreate);
Greg Danielb2365d82020-05-13 15:32:04 -0400531
532 SkColor4f colorsNew[6] = {
533 {1.0f, 1.0f, 0.0f, 0.2f}, // Y
534 {1.0f, 0.0f, 0.0f, 1.0f}, // R
535 {0.0f, 1.0f, 0.0f, 0.9f}, // G
536 {0.0f, 0.0f, 1.0f, 0.7f}, // B
537 {0.0f, 1.0f, 1.0f, 0.5f}, // C
538 {1.0f, 0.0f, 1.0f, 0.3f}, // M
539 };
540 make_pixmaps(skColorType, mipMapped, colorsNew, pixmapMem);
541 for (int i = 0; i < numMipLevels; ++i) {
542 pixmaps[i].reset(pixmapMem[i].info(), pixmapMem[i].addr(), pixmapMem[i].rowBytes());
Robert Phillips7f367982019-09-26 14:01:36 -0400543 }
544
Greg Danielb2365d82020-05-13 15:32:04 -0400545 // Upload new data and make sure everything still works
Brian Salomonb5f880a2020-12-07 11:30:16 -0500546 dContext->updateBackendTexture(backendTex, pixmaps, numMipLevels, origin, mark_signaled,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400547 finishedBECreate);
Greg Danielb2365d82020-05-13 15:32:04 -0400548
549 checkBackendTexture(colorsNew);
550
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400551 delete_backend_texture(dContext, backendTex, finishedBECreate);
Robert Phillips7f367982019-09-26 14:01:36 -0400552}
553
Robert Phillips02dc0302019-07-02 17:58:27 -0400554enum class VkLayout {
555 kUndefined,
556 kReadOnlyOptimal,
Robert Phillips02dc0302019-07-02 17:58:27 -0400557};
558
559void check_vk_layout(const GrBackendTexture& backendTex, VkLayout layout) {
560#if defined(SK_VULKAN) && defined(SK_DEBUG)
561 VkImageLayout expected;
562
563 switch (layout) {
564 case VkLayout::kUndefined:
565 expected = VK_IMAGE_LAYOUT_UNDEFINED;
566 break;
567 case VkLayout::kReadOnlyOptimal:
568 expected = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
569 break;
Robert Phillips02dc0302019-07-02 17:58:27 -0400570 default:
571 SkUNREACHABLE;
572 }
573
574 GrVkImageInfo vkII;
575
576 if (backendTex.getVkImageInfo(&vkII)) {
577 SkASSERT(expected == vkII.fImageLayout);
578 SkASSERT(VK_IMAGE_TILING_OPTIMAL == vkII.fImageTiling);
579 }
580#endif
581}
582
583///////////////////////////////////////////////////////////////////////////////
Robert Phillips0c6daf02019-05-16 12:43:11 -0400584DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ColorTypeBackendAllocationTest, reporter, ctxInfo) {
Robert Phillips6d344c32020-07-06 10:56:46 -0400585 auto context = ctxInfo.directContext();
Robert Phillips0c6daf02019-05-16 12:43:11 -0400586 const GrCaps* caps = context->priv().caps();
587
Robert Phillips459b2952019-05-23 09:38:27 -0400588 constexpr SkColor4f kTransCol { 0, 0.25f, 0.75f, 0.5f };
Robert Phillipsbd1ef682019-05-31 12:48:49 -0400589 constexpr SkColor4f kGrayCol { 0.75f, 0.75f, 0.75f, 0.75f };
Robert Phillips459b2952019-05-23 09:38:27 -0400590
Robert Phillips0c6daf02019-05-16 12:43:11 -0400591 struct {
592 SkColorType fColorType;
Robert Phillips459b2952019-05-23 09:38:27 -0400593 SkColor4f fColor;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400594 } combinations[] = {
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400595 { kAlpha_8_SkColorType, kTransCol },
596 { kRGB_565_SkColorType, SkColors::kRed },
597 { kARGB_4444_SkColorType, SkColors::kGreen },
598 { kRGBA_8888_SkColorType, SkColors::kBlue },
599 { kRGB_888x_SkColorType, SkColors::kCyan },
Robert Phillips459b2952019-05-23 09:38:27 -0400600 // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400601 { kBGRA_8888_SkColorType, { 1, 0, 0, 1.0f } },
Robert Phillips9a30ee02020-04-29 08:58:39 -0400602 // TODO: readback is busted for *10A2 when alpha = 0.5f (perhaps premul vs. unpremul)
603 { kRGBA_1010102_SkColorType, { 0.25f, 0.5f, 0.75f, 1.0f }},
604 { kBGRA_1010102_SkColorType, { 0.25f, 0.5f, 0.75f, 1.0f }},
605 // RGB/BGR 101010x have no Ganesh correlate
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400606 { kRGB_101010x_SkColorType, { 0, 0.5f, 0, 0.5f } },
Mike Kleinf7eb0542020-02-11 12:19:08 -0600607 { kBGR_101010x_SkColorType, { 0, 0.5f, 0, 0.5f } },
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400608 { kGray_8_SkColorType, kGrayCol },
609 { kRGBA_F16Norm_SkColorType, SkColors::kLtGray },
610 { kRGBA_F16_SkColorType, SkColors::kYellow },
611 { kRGBA_F32_SkColorType, SkColors::kGray },
Robert Phillips7f367982019-09-26 14:01:36 -0400612 { kR8G8_unorm_SkColorType, { .25f, .75f, 0, 1 } },
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400613 { kR16G16_unorm_SkColorType, SkColors::kGreen },
614 { kA16_unorm_SkColorType, kTransCol },
615 { kA16_float_SkColorType, kTransCol },
Robert Phillips7f367982019-09-26 14:01:36 -0400616 { kR16G16_float_SkColorType, { .25f, .75f, 0, 1 } },
Robert Phillipsea1b30b2019-09-19 16:05:48 -0400617 { kR16G16B16A16_unorm_SkColorType,{ .25f, .5f, .75f, 1 } },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400618 };
619
Brian Salomon4dea72a2019-12-18 10:43:10 -0500620 static_assert(kLastEnum_SkColorType == SK_ARRAY_COUNT(combinations));
Robert Phillips0c6daf02019-05-16 12:43:11 -0400621
622 for (auto combo : combinations) {
623 SkColorType colorType = combo.fColorType;
624
Robert Phillips0c6daf02019-05-16 12:43:11 -0400625 if (GrBackendApi::kMetal == context->backend()) {
626 // skbug.com/9086 (Metal caps may not be handling RGBA32 correctly)
627 if (kRGBA_F32_SkColorType == combo.fColorType) {
628 continue;
629 }
630 }
631
Brian Salomon7e67dca2020-07-21 09:27:25 -0400632 for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
Brian Salomon69100f02020-07-21 10:49:25 -0400633 if (GrMipmapped::kYes == mipMapped && !caps->mipmapSupport()) {
Robert Phillipsefb9f142019-05-17 14:19:44 -0400634 continue;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400635 }
636
Robert Phillipsefb9f142019-05-17 14:19:44 -0400637 for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
Greg Daniel7bfc9132019-08-14 14:23:53 -0400638 if (!caps->getDefaultBackendFormat(SkColorTypeToGrColorType(colorType),
639 renderable).isValid()) {
640 continue;
641 }
Robert Phillips7f367982019-09-26 14:01:36 -0400642
Robert Phillipsefb9f142019-05-17 14:19:44 -0400643 if (GrRenderable::kYes == renderable) {
644 if (kRGB_888x_SkColorType == combo.fColorType) {
645 // Ganesh can't perform the blends correctly when rendering this format
646 continue;
647 }
Robert Phillipsefb9f142019-05-17 14:19:44 -0400648 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400649
Robert Phillipsb04b6942019-05-21 17:24:31 -0400650 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400651 auto uninitCreateMtd = [colorType](GrDirectContext* dContext,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400652 GrMipmapped mipMapped,
Robert Phillipsb04b6942019-05-21 17:24:31 -0400653 GrRenderable renderable) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400654 auto result = dContext->createBackendTexture(32, 32, colorType,
655 mipMapped, renderable,
656 GrProtected::kNo);
Robert Phillips02dc0302019-07-02 17:58:27 -0400657 check_vk_layout(result, VkLayout::kUndefined);
Robert Phillipsd5e80ca2019-07-29 14:11:35 -0400658
659#ifdef SK_DEBUG
660 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400661 GrBackendFormat format = dContext->defaultBackendFormat(colorType,
662 renderable);
Robert Phillipsd5e80ca2019-07-29 14:11:35 -0400663 SkASSERT(format == result.getBackendFormat());
664 }
665#endif
666
Robert Phillips02dc0302019-07-02 17:58:27 -0400667 return result;
Robert Phillipsb04b6942019-05-21 17:24:31 -0400668 };
Robert Phillipsefb9f142019-05-17 14:19:44 -0400669
Robert Phillipsb04b6942019-05-21 17:24:31 -0400670 test_wrapping(context, reporter, uninitCreateMtd,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400671 SkColorTypeToGrColorType(colorType), mipMapped, renderable,
672 nullptr);
Robert Phillipsb04b6942019-05-21 17:24:31 -0400673 }
Robert Phillips459b2952019-05-23 09:38:27 -0400674
Greg Danielc1ad77c2020-05-06 11:40:03 -0400675 bool finishedBackendCreation = false;
676 bool* finishedPtr = &finishedBackendCreation;
677
Robert Phillips459b2952019-05-23 09:38:27 -0400678 {
Robert Phillips459b2952019-05-23 09:38:27 -0400679
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400680 auto createWithColorMtd = [colorType, finishedPtr](GrDirectContext* dContext,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400681 const SkColor4f& color,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400682 GrMipmapped mipMapped,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400683 GrRenderable renderable) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400684 auto result = dContext->createBackendTexture(32, 32, colorType, color,
685 mipMapped, renderable,
686 GrProtected::kNo,
687 mark_signaled, finishedPtr);
Greg Danieldddf7092020-05-06 11:52:37 -0400688 check_vk_layout(result, VkLayout::kReadOnlyOptimal);
Robert Phillipsd5e80ca2019-07-29 14:11:35 -0400689
690#ifdef SK_DEBUG
691 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400692 GrBackendFormat format = dContext->defaultBackendFormat(colorType,
Robert Phillipsd5e80ca2019-07-29 14:11:35 -0400693 renderable);
694 SkASSERT(format == result.getBackendFormat());
695 }
696#endif
697
Robert Phillips02dc0302019-07-02 17:58:27 -0400698 return result;
Robert Phillips459b2952019-05-23 09:38:27 -0400699 };
Brian Salomon85c3d682019-11-04 15:04:54 -0500700 // We make our comparison color using SkPixmap::erase(color) on a pixmap of
701 // combo.fColorType and then calling SkPixmap::readPixels(). erase() will premul
702 // the color passed to it. However, createBackendTexture() that takes a
703 // SkColor4f is color type / alpha type unaware and will simply compute
704 // luminance from the r, g, b, channels.
705 SkColor4f color = combo.fColor;
706 if (colorType == kGray_8_SkColorType) {
707 color = {color.fR * color.fA,
708 color.fG * color.fA,
709 color.fB * color.fA,
710 1.f};
711 }
Robert Phillips459b2952019-05-23 09:38:27 -0400712 test_color_init(context, reporter, createWithColorMtd,
Brian Salomon85c3d682019-11-04 15:04:54 -0500713 SkColorTypeToGrColorType(colorType), color, mipMapped,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400714 renderable, finishedPtr);
Robert Phillips459b2952019-05-23 09:38:27 -0400715 }
Robert Phillips7f367982019-09-26 14:01:36 -0400716
Brian Salomonb5f880a2020-12-07 11:30:16 -0500717 for (auto origin : {kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin}) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400718 auto createWithSrcDataMtd = [finishedPtr](GrDirectContext* dContext,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400719 const SkPixmap srcData[],
720 int numLevels,
Brian Salomonb5f880a2020-12-07 11:30:16 -0500721 GrSurfaceOrigin origin,
Greg Danielc1ad77c2020-05-06 11:40:03 -0400722 GrRenderable renderable) {
Robert Phillips9a30ee02020-04-29 08:58:39 -0400723 SkASSERT(srcData && numLevels);
Brian Salomonb5f880a2020-12-07 11:30:16 -0500724 auto result = dContext->createBackendTexture(srcData,
725 numLevels,
726 origin,
727 renderable,
728 GrProtected::kNo,
729 mark_signaled,
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400730 finishedPtr);
Robert Phillips9a30ee02020-04-29 08:58:39 -0400731 check_vk_layout(result, VkLayout::kReadOnlyOptimal);
Robert Phillips7f367982019-09-26 14:01:36 -0400732#ifdef SK_DEBUG
Robert Phillips9a30ee02020-04-29 08:58:39 -0400733 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400734 auto format = dContext->defaultBackendFormat(srcData[0].colorType(),
735 renderable);
Robert Phillips9a30ee02020-04-29 08:58:39 -0400736 SkASSERT(format == result.getBackendFormat());
737 }
Robert Phillips7f367982019-09-26 14:01:36 -0400738#endif
Robert Phillips9a30ee02020-04-29 08:58:39 -0400739 return result;
740 };
Robert Phillips7f367982019-09-26 14:01:36 -0400741
Brian Salomonb5f880a2020-12-07 11:30:16 -0500742 test_pixmap_init(context,
743 reporter,
744 createWithSrcDataMtd,
745 colorType,
746 origin,
747 mipMapped,
748 renderable,
749 finishedPtr);
Robert Phillips9a30ee02020-04-29 08:58:39 -0400750 }
Robert Phillipsefb9f142019-05-17 14:19:44 -0400751 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400752 }
753 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400754}
755
Robert Phillipsefb9f142019-05-17 14:19:44 -0400756///////////////////////////////////////////////////////////////////////////////
757#ifdef SK_GL
758
Robert Phillips0c6daf02019-05-16 12:43:11 -0400759DEF_GPUTEST_FOR_ALL_GL_CONTEXTS(GLBackendAllocationTest, reporter, ctxInfo) {
760 sk_gpu_test::GLTestContext* glCtx = ctxInfo.glContext();
761 GrGLStandard standard = glCtx->gl()->fStandard;
Robert Phillips6d344c32020-07-06 10:56:46 -0400762 auto context = ctxInfo.directContext();
Robert Phillipsefb9f142019-05-17 14:19:44 -0400763 const GrGLCaps* glCaps = static_cast<const GrGLCaps*>(context->priv().caps());
Robert Phillips0c6daf02019-05-16 12:43:11 -0400764
Robert Phillips459b2952019-05-23 09:38:27 -0400765 constexpr SkColor4f kTransCol { 0, 0.25f, 0.75f, 0.5f };
Robert Phillipsbd1ef682019-05-31 12:48:49 -0400766 constexpr SkColor4f kGrayCol { 0.75f, 0.75f, 0.75f, 0.75f };
Robert Phillips459b2952019-05-23 09:38:27 -0400767
Robert Phillips0c6daf02019-05-16 12:43:11 -0400768 struct {
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400769 GrColorType fColorType;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400770 GrGLenum fFormat;
Robert Phillips459b2952019-05-23 09:38:27 -0400771 SkColor4f fColor;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400772 } combinations[] = {
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400773 { GrColorType::kRGBA_8888, GR_GL_RGBA8, SkColors::kRed },
774 { GrColorType::kRGBA_8888_SRGB, GR_GL_SRGB8_ALPHA8, SkColors::kRed },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400775
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400776 { GrColorType::kRGB_888x, GR_GL_RGBA8, SkColors::kYellow },
777 { GrColorType::kRGB_888x, GR_GL_RGB8, SkColors::kCyan },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400778
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400779 { GrColorType::kBGRA_8888, GR_GL_RGBA8, SkColors::kBlue },
780 { GrColorType::kBGRA_8888, GR_GL_BGRA8, SkColors::kBlue },
781 // TODO: readback is busted when alpha = 0.5f (perhaps premul vs. unpremul)
Robert Phillips9a30ee02020-04-29 08:58:39 -0400782 { GrColorType::kRGBA_1010102, GR_GL_RGB10_A2, { 0.25f, 0.5f, 0.75f, 1.f }},
783 { GrColorType::kBGRA_1010102, GR_GL_RGB10_A2, { 0.25f, 0.5f, 0.75f, 1.f }},
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400784 { GrColorType::kBGR_565, GR_GL_RGB565, SkColors::kRed },
785 { GrColorType::kABGR_4444, GR_GL_RGBA4, SkColors::kGreen },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400786
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400787 { GrColorType::kAlpha_8, GR_GL_ALPHA8, kTransCol },
788 { GrColorType::kAlpha_8, GR_GL_R8, kTransCol },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400789
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400790 { GrColorType::kGray_8, GR_GL_LUMINANCE8, kGrayCol },
791 { GrColorType::kGray_8, GR_GL_R8, kGrayCol },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400792
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400793 { GrColorType::kRGBA_F32, GR_GL_RGBA32F, SkColors::kRed },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400794
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400795 { GrColorType::kRGBA_F16_Clamped, GR_GL_RGBA16F, SkColors::kLtGray },
796 { GrColorType::kRGBA_F16, GR_GL_RGBA16F, SkColors::kYellow },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400797
Robert Phillipsd470e1b2019-09-04 15:05:35 -0400798 { GrColorType::kRG_88, GR_GL_RG8, { 1, 0.5f, 0, 1 } },
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400799 { GrColorType::kAlpha_F16, GR_GL_R16F, { 1.0f, 0, 0, 0.5f } },
800 { GrColorType::kAlpha_F16, GR_GL_LUMINANCE16F, kGrayCol },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400801
Robert Phillips429f0d32019-09-11 17:03:28 -0400802 { GrColorType::kAlpha_16, GR_GL_R16, kTransCol },
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400803 { GrColorType::kRG_1616, GR_GL_RG16, SkColors::kYellow },
Robert Phillips66a46032019-06-18 08:00:42 -0400804
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400805 { GrColorType::kRGBA_16161616, GR_GL_RGBA16, SkColors::kLtGray },
806 { GrColorType::kRG_F16, GR_GL_RG16F, SkColors::kYellow },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400807 };
808
809 for (auto combo : combinations) {
Brian Salomon0f396992020-06-19 19:51:21 -0400810 for (GrGLenum target : {GR_GL_TEXTURE_2D, GR_GL_TEXTURE_RECTANGLE}) {
811 GrBackendFormat format = GrBackendFormat::MakeGL(combo.fFormat, target);
Robert Phillips0c6daf02019-05-16 12:43:11 -0400812
Brian Salomon0f396992020-06-19 19:51:21 -0400813 if (!glCaps->isFormatTexturable(format)) {
Robert Phillipsefb9f142019-05-17 14:19:44 -0400814 continue;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400815 }
816
Brian Salomon0f396992020-06-19 19:51:21 -0400817 if (GrColorType::kBGRA_8888 == combo.fColorType ||
818 GrColorType::kBGRA_1010102 == combo.fColorType) {
819 // We allow using a GL_RGBA8 or GR_GL_RGB10_A2 texture as BGRA on desktop GL but not
820 // ES
821 if (kGL_GrGLStandard != standard &&
822 (GR_GL_RGBA8 == combo.fFormat || GR_GL_RGB10_A2 == combo.fFormat)) {
823 continue;
824 }
825 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400826
Brian Salomon7e67dca2020-07-21 09:27:25 -0400827 for (auto mipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
828 if (GrMipmapped::kYes == mipMapped &&
Brian Salomon69100f02020-07-21 10:49:25 -0400829 (!glCaps->mipmapSupport() || target == GR_GL_TEXTURE_RECTANGLE)) {
Brian Salomon0f396992020-06-19 19:51:21 -0400830 continue;
Robert Phillipsefb9f142019-05-17 14:19:44 -0400831 }
832
Brian Salomon0f396992020-06-19 19:51:21 -0400833 for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) {
834 if (GrRenderable::kYes == renderable) {
835 if (!glCaps->isFormatAsColorTypeRenderable(combo.fColorType, format)) {
836 continue;
837 }
Robert Phillips459b2952019-05-23 09:38:27 -0400838 }
839
Brian Salomon0f396992020-06-19 19:51:21 -0400840 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400841 auto uninitCreateMtd = [format](GrDirectContext* dContext,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400842 GrMipmapped mipMapped,
Brian Salomon0f396992020-06-19 19:51:21 -0400843 GrRenderable renderable) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400844 return dContext->createBackendTexture(32, 32, format, mipMapped,
845 renderable, GrProtected::kNo);
Brian Salomon0f396992020-06-19 19:51:21 -0400846 };
Greg Danielc1ad77c2020-05-06 11:40:03 -0400847
Brian Salomon0f396992020-06-19 19:51:21 -0400848 test_wrapping(context, reporter, uninitCreateMtd, combo.fColorType,
849 mipMapped, renderable, nullptr);
Brian Salomon85c3d682019-11-04 15:04:54 -0500850 }
Robert Phillips459b2952019-05-23 09:38:27 -0400851
Brian Salomon0f396992020-06-19 19:51:21 -0400852 {
853 // We're creating backend textures without specifying a color type "view" of
854 // them at the public API level. Therefore, Ganesh will not apply any
855 // swizzles before writing the color to the texture. However, our validation
856 // code does rely on interpreting the texture contents via a SkColorType and
857 // therefore swizzles may be applied during the read step. Ideally we'd
858 // update our validation code to use a "raw" read that doesn't impose a
859 // color type but for now we just munge the data we upload to match the
860 // expectation.
861 GrSwizzle swizzle;
862 switch (combo.fColorType) {
863 case GrColorType::kAlpha_8:
864 swizzle = GrSwizzle("aaaa");
865 break;
866 case GrColorType::kAlpha_16:
867 swizzle = GrSwizzle("aaaa");
868 break;
869 case GrColorType::kAlpha_F16:
870 swizzle = GrSwizzle("aaaa");
871 break;
872 default:
873 break;
874 }
875
876 bool finishedBackendCreation = false;
877 bool* finishedPtr = &finishedBackendCreation;
878
879 auto createWithColorMtd = [format, swizzle, finishedPtr](
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400880 GrDirectContext* dContext,
Brian Salomon0f396992020-06-19 19:51:21 -0400881 const SkColor4f& color,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400882 GrMipmapped mipMapped,
Brian Salomon0f396992020-06-19 19:51:21 -0400883 GrRenderable renderable) {
884 auto swizzledColor = swizzle.applyTo(color);
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400885 return dContext->createBackendTexture(
Brian Salomon0f396992020-06-19 19:51:21 -0400886 32, 32, format, swizzledColor, mipMapped, renderable,
887 GrProtected::kNo, mark_signaled, finishedPtr);
888 };
889 // We make our comparison color using SkPixmap::erase(color) on a pixmap of
890 // combo.fColorType and then calling SkPixmap::readPixels(). erase() will
891 // premul the color passed to it. However, createBackendTexture() that takes
892 // a SkColor4f is color type/alpha type unaware and will simply compute
893 // luminance from the r, g, b, channels.
894 SkColor4f color = combo.fColor;
895 if (combo.fColorType == GrColorType::kGray_8) {
896 color = {color.fR * color.fA,
897 color.fG * color.fA,
898 color.fB * color.fA,
899 1.f};
900 }
901
902 test_color_init(context, reporter, createWithColorMtd, combo.fColorType,
903 color, mipMapped, renderable, finishedPtr);
904 }
Robert Phillips459b2952019-05-23 09:38:27 -0400905 }
Robert Phillipsefb9f142019-05-17 14:19:44 -0400906 }
Robert Phillips0c6daf02019-05-16 12:43:11 -0400907 }
908 }
909}
910
Robert Phillipsefb9f142019-05-17 14:19:44 -0400911#endif
912
913///////////////////////////////////////////////////////////////////////////////
Robert Phillips0c6daf02019-05-16 12:43:11 -0400914
915#ifdef SK_VULKAN
916
917#include "src/gpu/vk/GrVkCaps.h"
918
919DEF_GPUTEST_FOR_VULKAN_CONTEXT(VkBackendAllocationTest, reporter, ctxInfo) {
Robert Phillips6d344c32020-07-06 10:56:46 -0400920 auto context = ctxInfo.directContext();
Robert Phillips0c6daf02019-05-16 12:43:11 -0400921 const GrVkCaps* vkCaps = static_cast<const GrVkCaps*>(context->priv().caps());
922
Robert Phillips459b2952019-05-23 09:38:27 -0400923 constexpr SkColor4f kTransCol { 0, 0.25f, 0.75f, 0.5f };
Robert Phillips7f367982019-09-26 14:01:36 -0400924 constexpr SkColor4f kGrayCol { 0.75f, 0.75f, 0.75f, 1 };
Robert Phillips459b2952019-05-23 09:38:27 -0400925
Robert Phillips0c6daf02019-05-16 12:43:11 -0400926 struct {
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400927 GrColorType fColorType;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400928 VkFormat fFormat;
Robert Phillips459b2952019-05-23 09:38:27 -0400929 SkColor4f fColor;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400930 } combinations[] = {
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400931 { GrColorType::kRGBA_8888, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kRed },
932 { GrColorType::kRGBA_8888_SRGB, VK_FORMAT_R8G8B8A8_SRGB, SkColors::kRed },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400933
Robert Phillipsbd1ef682019-05-31 12:48:49 -0400934 // In this configuration (i.e., an RGB_888x colortype with an RGBA8 backing format),
935 // there is nothing to tell Skia to make the provided color opaque. Clients will need
936 // to provide an opaque initialization color in this case.
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400937 { GrColorType::kRGB_888x, VK_FORMAT_R8G8B8A8_UNORM, SkColors::kYellow },
938 { GrColorType::kRGB_888x, VK_FORMAT_R8G8B8_UNORM, SkColors::kCyan },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400939
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400940 { GrColorType::kBGRA_8888, VK_FORMAT_B8G8R8A8_UNORM, SkColors::kBlue },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400941
Robert Phillips9a30ee02020-04-29 08:58:39 -0400942 { GrColorType::kRGBA_1010102, VK_FORMAT_A2B10G10R10_UNORM_PACK32,
943 { 0.25f, 0.5f, 0.75f, 1.0f }},
944 { GrColorType::kBGRA_1010102, VK_FORMAT_A2R10G10B10_UNORM_PACK32,
945 { 0.25f, 0.5f, 0.75f, 1.0f }},
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400946 { GrColorType::kBGR_565, VK_FORMAT_R5G6B5_UNORM_PACK16, SkColors::kRed },
Robert Phillipsefb9f142019-05-17 14:19:44 -0400947
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400948 { GrColorType::kABGR_4444, VK_FORMAT_R4G4B4A4_UNORM_PACK16, SkColors::kCyan },
949 { GrColorType::kABGR_4444, VK_FORMAT_B4G4R4A4_UNORM_PACK16, SkColors::kYellow },
Robert Phillipsefb9f142019-05-17 14:19:44 -0400950
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400951 { GrColorType::kAlpha_8, VK_FORMAT_R8_UNORM, kTransCol },
Robert Phillipsbd1ef682019-05-31 12:48:49 -0400952 // In this config (i.e., a Gray8 color type with an R8 backing format), there is nothing
953 // to tell Skia this isn't an Alpha8 color type (so it will initialize the texture with
954 // the alpha channel of the color). Clients should, in general, fill all the channels
955 // of the provided color with the same value in such cases.
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400956 { GrColorType::kGray_8, VK_FORMAT_R8_UNORM, kGrayCol },
Robert Phillipsbd1ef682019-05-31 12:48:49 -0400957
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400958 { GrColorType::kRGBA_F16_Clamped, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kLtGray },
959 { GrColorType::kRGBA_F16, VK_FORMAT_R16G16B16A16_SFLOAT, SkColors::kYellow },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400960
Robert Phillipsd470e1b2019-09-04 15:05:35 -0400961 { GrColorType::kRG_88, VK_FORMAT_R8G8_UNORM, { 1, 0.5f, 0, 1 } },
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400962 { GrColorType::kAlpha_F16, VK_FORMAT_R16_SFLOAT, { 1.0f, 0, 0, 0.5f }},
963
Robert Phillips429f0d32019-09-11 17:03:28 -0400964 { GrColorType::kAlpha_16, VK_FORMAT_R16_UNORM, kTransCol },
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400965 { GrColorType::kRG_1616, VK_FORMAT_R16G16_UNORM, SkColors::kYellow },
Robert Phillipsb7f95d12019-07-26 11:13:19 -0400966 { GrColorType::kRGBA_16161616, VK_FORMAT_R16G16B16A16_UNORM, SkColors::kLtGray },
967 { GrColorType::kRG_F16, VK_FORMAT_R16G16_SFLOAT, SkColors::kYellow },
Robert Phillips0c6daf02019-05-16 12:43:11 -0400968 };
969
970 for (auto combo : combinations) {
Greg Daniel2f2caea2019-07-08 14:24:47 -0400971 if (!vkCaps->isVkFormatTexturable(combo.fFormat)) {
Robert Phillips0c6daf02019-05-16 12:43:11 -0400972 continue;
973 }
974
975 GrBackendFormat format = GrBackendFormat::MakeVk(combo.fFormat);
976
Brian Salomon7e67dca2020-07-21 09:27:25 -0400977 for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
Brian Salomon69100f02020-07-21 10:49:25 -0400978 if (GrMipmapped::kYes == mipMapped && !vkCaps->mipmapSupport()) {
Robert Phillipsefb9f142019-05-17 14:19:44 -0400979 continue;
Robert Phillips0c6daf02019-05-16 12:43:11 -0400980 }
981
Robert Phillipsefb9f142019-05-17 14:19:44 -0400982 for (auto renderable : { GrRenderable::kNo, GrRenderable::kYes }) {
Robert Phillips0c6daf02019-05-16 12:43:11 -0400983
Robert Phillipsefb9f142019-05-17 14:19:44 -0400984 if (GrRenderable::kYes == renderable) {
Brian Salomon4eb38b72019-08-05 12:58:39 -0400985 // We must also check whether we allow rendering to the format using the
986 // color type.
Greg Daniel900583a2019-08-06 12:05:31 -0400987 if (!vkCaps->isFormatAsColorTypeRenderable(
988 combo.fColorType, GrBackendFormat::MakeVk(combo.fFormat), 1)) {
Brian Salomon4eb38b72019-08-05 12:58:39 -0400989 continue;
990 }
Robert Phillipsefb9f142019-05-17 14:19:44 -0400991 }
992
Robert Phillipsd34691b2019-09-24 13:38:43 -0400993 {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400994 auto uninitCreateMtd = [format](GrDirectContext* dContext,
Brian Salomon7e67dca2020-07-21 09:27:25 -0400995 GrMipmapped mipMapped,
Robert Phillips459b2952019-05-23 09:38:27 -0400996 GrRenderable renderable) {
Robert Phillipsfe4b4812020-07-17 14:15:51 -0400997 GrBackendTexture beTex = dContext->createBackendTexture(32, 32, format,
998 mipMapped,
999 renderable,
1000 GrProtected::kNo);
Robert Phillips02dc0302019-07-02 17:58:27 -04001001 check_vk_layout(beTex, VkLayout::kUndefined);
Robert Phillipsd1d869d2019-06-07 14:21:31 -04001002 return beTex;
Robert Phillipsb04b6942019-05-21 17:24:31 -04001003 };
Robert Phillipsefb9f142019-05-17 14:19:44 -04001004
Robert Phillipsb04b6942019-05-21 17:24:31 -04001005 test_wrapping(context, reporter, uninitCreateMtd,
Greg Danielc1ad77c2020-05-06 11:40:03 -04001006 combo.fColorType, mipMapped, renderable, nullptr);
Robert Phillipsb04b6942019-05-21 17:24:31 -04001007 }
Robert Phillips459b2952019-05-23 09:38:27 -04001008
Robert Phillips459b2952019-05-23 09:38:27 -04001009 {
Brian Salomonb450f3b2019-07-09 09:36:51 -04001010 // We're creating backend textures without specifying a color type "view" of
1011 // them at the public API level. Therefore, Ganesh will not apply any swizzles
1012 // before writing the color to the texture. However, our validation code does
1013 // rely on interpreting the texture contents via a SkColorType and therefore
1014 // swizzles may be applied during the read step.
1015 // Ideally we'd update our validation code to use a "raw" read that doesn't
1016 // impose a color type but for now we just munge the data we upload to match the
1017 // expectation.
1018 GrSwizzle swizzle;
1019 switch (combo.fColorType) {
Robert Phillipsb7f95d12019-07-26 11:13:19 -04001020 case GrColorType::kAlpha_8:
Brian Salomonb450f3b2019-07-09 09:36:51 -04001021 SkASSERT(combo.fFormat == VK_FORMAT_R8_UNORM);
1022 swizzle = GrSwizzle("aaaa");
1023 break;
Robert Phillips429f0d32019-09-11 17:03:28 -04001024 case GrColorType::kAlpha_16:
1025 SkASSERT(combo.fFormat == VK_FORMAT_R16_UNORM);
1026 swizzle = GrSwizzle("aaaa");
1027 break;
Robert Phillips17a3a0b2019-09-18 13:56:54 -04001028 case GrColorType::kAlpha_F16:
1029 SkASSERT(combo.fFormat == VK_FORMAT_R16_SFLOAT);
1030 swizzle = GrSwizzle("aaaa");
1031 break;
Robert Phillipsb7f95d12019-07-26 11:13:19 -04001032 case GrColorType::kABGR_4444:
Brian Salomonb450f3b2019-07-09 09:36:51 -04001033 if (combo.fFormat == VK_FORMAT_B4G4R4A4_UNORM_PACK16) {
1034 swizzle = GrSwizzle("bgra");
1035 }
1036 break;
1037 default:
1038 swizzle = GrSwizzle("rgba");
1039 break;
1040 }
Greg Danielc1ad77c2020-05-06 11:40:03 -04001041
1042 bool finishedBackendCreation = false;
1043 bool* finishedPtr = &finishedBackendCreation;
1044
1045 auto createWithColorMtd = [format, swizzle, finishedPtr](
Robert Phillipsfe4b4812020-07-17 14:15:51 -04001046 GrDirectContext* dContext,
1047 const SkColor4f& color,
Brian Salomon7e67dca2020-07-21 09:27:25 -04001048 GrMipmapped mipMapped,
Greg Danielc1ad77c2020-05-06 11:40:03 -04001049 GrRenderable renderable) {
Brian Salomonb450f3b2019-07-09 09:36:51 -04001050 auto swizzledColor = swizzle.applyTo(color);
Robert Phillipsfe4b4812020-07-17 14:15:51 -04001051 GrBackendTexture beTex = dContext->createBackendTexture(32, 32, format,
1052 swizzledColor,
1053 mipMapped,
1054 renderable,
1055 GrProtected::kNo,
1056 mark_signaled,
1057 finishedPtr);
Greg Danieldddf7092020-05-06 11:52:37 -04001058 check_vk_layout(beTex, VkLayout::kReadOnlyOptimal);
Robert Phillipsd1d869d2019-06-07 14:21:31 -04001059 return beTex;
Robert Phillips459b2952019-05-23 09:38:27 -04001060 };
Robert Phillips459b2952019-05-23 09:38:27 -04001061 test_color_init(context, reporter, createWithColorMtd,
Greg Danielc1ad77c2020-05-06 11:40:03 -04001062 combo.fColorType, combo.fColor, mipMapped, renderable,
1063 finishedPtr);
Robert Phillips459b2952019-05-23 09:38:27 -04001064 }
Robert Phillipsefb9f142019-05-17 14:19:44 -04001065 }
Robert Phillips0c6daf02019-05-16 12:43:11 -04001066 }
1067 }
1068}
1069
1070#endif