Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018 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/SkColor.h" |
| 10 | #include "include/core/SkColorSpace.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 11 | #include "include/core/SkFont.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 12 | #include "include/core/SkImageInfo.h" |
| 13 | #include "include/core/SkMatrix.h" |
| 14 | #include "include/core/SkPaint.h" |
| 15 | #include "include/core/SkPoint.h" |
| 16 | #include "include/core/SkRefCnt.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 17 | #include "include/core/SkSize.h" |
| 18 | #include "include/core/SkTypes.h" |
| 19 | #include "include/gpu/GrBackendSurface.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "include/gpu/GrContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 21 | #include "include/private/GrTypesPriv.h" |
| 22 | #include "src/core/SkIPoint16.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 23 | #include "src/gpu/GrCaps.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 24 | #include "src/gpu/GrContextPriv.h" |
| 25 | #include "src/gpu/GrDeferredUpload.h" |
| 26 | #include "src/gpu/GrDrawOpAtlas.h" |
| 27 | #include "src/gpu/GrDrawingManager.h" |
| 28 | #include "src/gpu/GrMemoryPool.h" |
| 29 | #include "src/gpu/GrOnFlushResourceProvider.h" |
| 30 | #include "src/gpu/GrOpFlushState.h" |
| 31 | #include "src/gpu/GrRenderTargetContext.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 32 | #include "src/gpu/GrTextureProxy.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 33 | #include "src/gpu/GrXferProcessor.h" |
| 34 | #include "src/gpu/ops/GrDrawOp.h" |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 35 | #include "src/gpu/ops/GrOp.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 36 | #include "src/gpu/text/GrAtlasManager.h" |
| 37 | #include "src/gpu/text/GrTextContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 38 | #include "tests/Test.h" |
| 39 | #include "tools/gpu/GrContextFactory.h" |
Ben Wagner | d90cd3b | 2018-05-22 10:48:08 -0400 | [diff] [blame] | 40 | |
| 41 | #include <memory> |
Ben Wagner | 9707a7e | 2019-05-06 17:17:19 -0400 | [diff] [blame] | 42 | #include <utility> |
Ben Wagner | d90cd3b | 2018-05-22 10:48:08 -0400 | [diff] [blame] | 43 | |
| 44 | class GrResourceProvider; |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 45 | |
| 46 | static const int kNumPlots = 2; |
| 47 | static const int kPlotSize = 32; |
| 48 | static const int kAtlasSize = kNumPlots * kPlotSize; |
| 49 | |
| 50 | int GrDrawOpAtlas::numAllocated_TestingOnly() const { |
| 51 | int count = 0; |
| 52 | for (uint32_t i = 0; i < this->maxPages(); ++i) { |
Brian Salomon | fd98c2c | 2018-07-31 17:25:29 -0400 | [diff] [blame] | 53 | if (fProxies[i]->isInstantiated()) { |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 54 | ++count; |
| 55 | } |
| 56 | } |
| 57 | |
| 58 | return count; |
| 59 | } |
| 60 | |
Kevin Lubick | b5502b2 | 2018-03-12 10:17:06 -0400 | [diff] [blame] | 61 | void GrAtlasManager::setMaxPages_TestingOnly(uint32_t maxPages) { |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 62 | for (int i = 0; i < kMaskFormatCount; i++) { |
| 63 | if (fAtlases[i]) { |
Kevin Lubick | b5502b2 | 2018-03-12 10:17:06 -0400 | [diff] [blame] | 64 | fAtlases[i]->setMaxPages_TestingOnly(maxPages); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 65 | } |
| 66 | } |
| 67 | } |
| 68 | |
| 69 | void GrDrawOpAtlas::setMaxPages_TestingOnly(uint32_t maxPages) { |
| 70 | SkASSERT(!fNumActivePages); |
| 71 | |
| 72 | fMaxPages = maxPages; |
| 73 | } |
| 74 | |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 75 | void EvictionFunc(GrDrawOpAtlas::AtlasID atlasID, void*) { |
| 76 | SkASSERT(0); // The unit test shouldn't exercise this code path |
| 77 | } |
| 78 | |
| 79 | static void check(skiatest::Reporter* r, GrDrawOpAtlas* atlas, |
| 80 | uint32_t expectedActive, uint32_t expectedMax, int expectedAlloced) { |
| 81 | REPORTER_ASSERT(r, expectedActive == atlas->numActivePages()); |
| 82 | REPORTER_ASSERT(r, expectedMax == atlas->maxPages()); |
| 83 | REPORTER_ASSERT(r, expectedAlloced == atlas->numAllocated_TestingOnly()); |
| 84 | } |
| 85 | |
| 86 | class TestingUploadTarget : public GrDeferredUploadTarget { |
| 87 | public: |
| 88 | TestingUploadTarget() { } |
| 89 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 90 | const GrTokenTracker* tokenTracker() final { return &fTokenTracker; } |
| 91 | GrTokenTracker* writeableTokenTracker() { return &fTokenTracker; } |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 92 | |
| 93 | GrDeferredUploadToken addInlineUpload(GrDeferredTextureUploadFn&&) final { |
| 94 | SkASSERT(0); // this test shouldn't invoke this code path |
| 95 | return fTokenTracker.nextDrawToken(); |
| 96 | } |
| 97 | |
| 98 | virtual GrDeferredUploadToken addASAPUpload(GrDeferredTextureUploadFn&& upload) final { |
| 99 | return fTokenTracker.nextTokenToFlush(); |
| 100 | } |
| 101 | |
| 102 | void issueDrawToken() { fTokenTracker.issueDrawToken(); } |
| 103 | void flushToken() { fTokenTracker.flushToken(); } |
| 104 | |
| 105 | private: |
| 106 | GrTokenTracker fTokenTracker; |
| 107 | |
| 108 | typedef GrDeferredUploadTarget INHERITED; |
| 109 | }; |
| 110 | |
| 111 | static bool fill_plot(GrDrawOpAtlas* atlas, |
| 112 | GrResourceProvider* resourceProvider, |
| 113 | GrDeferredUploadTarget* target, |
| 114 | GrDrawOpAtlas::AtlasID* atlasID, |
| 115 | int alpha) { |
| 116 | SkImageInfo ii = SkImageInfo::MakeA8(kPlotSize, kPlotSize); |
| 117 | |
| 118 | SkBitmap data; |
| 119 | data.allocPixels(ii); |
| 120 | data.eraseARGB(alpha, 0, 0, 0); |
| 121 | |
| 122 | SkIPoint16 loc; |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 123 | GrDrawOpAtlas::ErrorCode code; |
| 124 | code = atlas->addToAtlas(resourceProvider, atlasID, target, kPlotSize, kPlotSize, |
| 125 | data.getAddr(0, 0), &loc); |
| 126 | return GrDrawOpAtlas::ErrorCode::kSucceeded == code; |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 127 | } |
| 128 | |
| 129 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 130 | // This is a basic DrawOpAtlas test. It simply verifies that multitexture atlases correctly |
| 131 | // add and remove pages. Note that this is simulating flush-time behavior. |
| 132 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BasicDrawOpAtlas, reporter, ctxInfo) { |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 133 | auto context = ctxInfo.grContext(); |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 134 | auto proxyProvider = context->priv().proxyProvider(); |
| 135 | auto resourceProvider = context->priv().resourceProvider(); |
| 136 | auto drawingManager = context->priv().drawingManager(); |
Robert Phillips | 0a15cc6 | 2019-07-30 12:49:10 -0400 | [diff] [blame] | 137 | const GrCaps* caps = context->priv().caps(); |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 138 | |
| 139 | GrOnFlushResourceProvider onFlushResourceProvider(drawingManager); |
| 140 | TestingUploadTarget uploadTarget; |
| 141 | |
Robert Phillips | 0a15cc6 | 2019-07-30 12:49:10 -0400 | [diff] [blame] | 142 | GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kAlpha_8, |
| 143 | GrRenderable::kNo); |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 144 | |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 145 | std::unique_ptr<GrDrawOpAtlas> atlas = GrDrawOpAtlas::Make( |
| 146 | proxyProvider, |
Greg Daniel | 4065d45 | 2018-11-16 15:43:41 -0500 | [diff] [blame] | 147 | format, |
Robert Phillips | 42dda08 | 2019-05-14 13:29:45 -0400 | [diff] [blame] | 148 | GrColorType::kAlpha_8, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 149 | kAtlasSize, kAtlasSize, |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 150 | kAtlasSize/kNumPlots, kAtlasSize/kNumPlots, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 151 | GrDrawOpAtlas::AllowMultitexturing::kYes, |
| 152 | EvictionFunc, nullptr); |
| 153 | check(reporter, atlas.get(), 0, 4, 0); |
| 154 | |
| 155 | // Fill up the first level |
| 156 | GrDrawOpAtlas::AtlasID atlasIDs[kNumPlots * kNumPlots]; |
| 157 | for (int i = 0; i < kNumPlots * kNumPlots; ++i) { |
| 158 | bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasIDs[i], i*32); |
| 159 | REPORTER_ASSERT(reporter, result); |
| 160 | check(reporter, atlas.get(), 1, 4, 1); |
| 161 | } |
| 162 | |
| 163 | atlas->instantiate(&onFlushResourceProvider); |
| 164 | check(reporter, atlas.get(), 1, 4, 1); |
| 165 | |
| 166 | // Force allocation of a second level |
| 167 | GrDrawOpAtlas::AtlasID atlasID; |
| 168 | bool result = fill_plot(atlas.get(), resourceProvider, &uploadTarget, &atlasID, 4*32); |
| 169 | REPORTER_ASSERT(reporter, result); |
| 170 | check(reporter, atlas.get(), 2, 4, 2); |
| 171 | |
| 172 | // Simulate a lot of draws using only the first plot. The last texture should be compacted. |
| 173 | for (int i = 0; i < 512; ++i) { |
| 174 | atlas->setLastUseToken(atlasIDs[0], uploadTarget.tokenTracker()->nextDrawToken()); |
| 175 | uploadTarget.issueDrawToken(); |
| 176 | uploadTarget.flushToken(); |
| 177 | atlas->compact(uploadTarget.tokenTracker()->nextTokenToFlush()); |
| 178 | } |
| 179 | |
| 180 | check(reporter, atlas.get(), 1, 4, 1); |
| 181 | } |
| 182 | |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 183 | // This test verifies that the GrAtlasTextOp::onPrepare method correctly handles a failure |
| 184 | // when allocating an atlas page. |
| 185 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrAtlasTextOpPreparation, reporter, ctxInfo) { |
| 186 | |
| 187 | auto context = ctxInfo.grContext(); |
| 188 | |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 189 | auto gpu = context->priv().getGpu(); |
| 190 | auto resourceProvider = context->priv().resourceProvider(); |
| 191 | auto drawingManager = context->priv().drawingManager(); |
Herb Derby | 26cbe51 | 2018-05-24 14:39:01 -0400 | [diff] [blame] | 192 | auto textContext = drawingManager->getTextContext(); |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 193 | auto opMemoryPool = context->priv().opMemoryPool(); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 194 | |
Brian Salomon | 27ae52c | 2019-07-03 11:27:44 -0400 | [diff] [blame] | 195 | auto rtc = context->priv().makeDeferredRenderTargetContext(SkBackingFit::kApprox, 32, 32, |
Brian Salomon | d628747 | 2019-06-24 15:50:07 -0400 | [diff] [blame] | 196 | GrColorType::kRGBA_8888, nullptr); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 197 | |
| 198 | SkPaint paint; |
| 199 | paint.setColor(SK_ColorRED); |
Mike Reed | 191e64b | 2019-01-02 15:35:29 -0500 | [diff] [blame] | 200 | |
| 201 | SkFont font; |
| 202 | font.setEdging(SkFont::Edging::kAlias); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 203 | |
| 204 | const char* text = "a"; |
| 205 | |
Herb Derby | bc6f9c9 | 2018-08-08 13:58:45 -0400 | [diff] [blame] | 206 | std::unique_ptr<GrDrawOp> op = textContext->createOp_TestingOnly( |
Mike Reed | 191e64b | 2019-01-02 15:35:29 -0500 | [diff] [blame] | 207 | context, textContext, rtc.get(), paint, font, SkMatrix::I(), text, 16, 16); |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 208 | bool hasMixedSampledCoverage = false; |
| 209 | op->finalize(*context->priv().caps(), nullptr, hasMixedSampledCoverage, GrClampType::kAuto); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 210 | |
| 211 | TestingUploadTarget uploadTarget; |
| 212 | |
Robert Phillips | e5f7328 | 2019-06-18 17:15:04 -0400 | [diff] [blame] | 213 | GrOpFlushState flushState(gpu, resourceProvider, uploadTarget.writeableTokenTracker()); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 214 | GrOpFlushState::OpArgs opArgs = { |
| 215 | op.get(), |
| 216 | rtc->asRenderTargetProxy(), |
| 217 | nullptr, |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame] | 218 | rtc->asRenderTargetProxy()->outputSwizzle(), |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 219 | GrXferProcessor::DstProxy(nullptr, SkIPoint::Make(0, 0)) |
| 220 | }; |
| 221 | |
| 222 | // Cripple the atlas manager so it can't allocate any pages. This will force a failure |
| 223 | // in the preparation of the text op |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 224 | auto atlasManager = context->priv().getAtlasManager(); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 225 | unsigned int numProxies; |
| 226 | atlasManager->getProxies(kA8_GrMaskFormat, &numProxies); |
| 227 | atlasManager->setMaxPages_TestingOnly(0); |
| 228 | |
| 229 | flushState.setOpArgs(&opArgs); |
| 230 | op->prepare(&flushState); |
| 231 | flushState.setOpArgs(nullptr); |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame] | 232 | opMemoryPool->release(std::move(op)); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 233 | } |
Herb Derby | 15d9ef2 | 2018-10-18 13:41:32 -0400 | [diff] [blame] | 234 | |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 235 | void test_atlas_config(skiatest::Reporter* reporter, int maxTextureSize, size_t maxBytes, |
| 236 | GrMaskFormat maskFormat, SkISize expectedDimensions, |
| 237 | SkISize expectedPlotDimensions) { |
| 238 | GrDrawOpAtlasConfig config(maxTextureSize, maxBytes); |
| 239 | REPORTER_ASSERT(reporter, config.atlasDimensions(maskFormat) == expectedDimensions); |
| 240 | REPORTER_ASSERT(reporter, config.plotDimensions(maskFormat) == expectedPlotDimensions); |
| 241 | } |
| 242 | |
Herb Derby | 15d9ef2 | 2018-10-18 13:41:32 -0400 | [diff] [blame] | 243 | DEF_GPUTEST(GrDrawOpAtlasConfig_Basic, reporter, options) { |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 244 | // 1/4 MB |
| 245 | test_atlas_config(reporter, 65536, 256 * 1024, kARGB_GrMaskFormat, |
| 246 | { 256, 256 }, { 256, 256 }); |
| 247 | test_atlas_config(reporter, 65536, 256 * 1024, kA8_GrMaskFormat, |
| 248 | { 512, 512 }, { 256, 256 }); |
| 249 | // 1/2 MB |
| 250 | test_atlas_config(reporter, 65536, 512 * 1024, kARGB_GrMaskFormat, |
| 251 | { 512, 256 }, { 256, 256 }); |
| 252 | test_atlas_config(reporter, 65536, 512 * 1024, kA8_GrMaskFormat, |
| 253 | { 1024, 512 }, { 256, 256 }); |
| 254 | // 1 MB |
| 255 | test_atlas_config(reporter, 65536, 1024 * 1024, kARGB_GrMaskFormat, |
| 256 | { 512, 512 }, { 256, 256 }); |
| 257 | test_atlas_config(reporter, 65536, 1024 * 1024, kA8_GrMaskFormat, |
| 258 | { 1024, 1024 }, { 256, 256 }); |
| 259 | // 2 MB |
| 260 | test_atlas_config(reporter, 65536, 2 * 1024 * 1024, kARGB_GrMaskFormat, |
| 261 | { 1024, 512 }, { 256, 256 }); |
| 262 | test_atlas_config(reporter, 65536, 2 * 1024 * 1024, kA8_GrMaskFormat, |
| 263 | { 2048, 1024 }, { 512, 256 }); |
| 264 | // 4 MB |
| 265 | test_atlas_config(reporter, 65536, 4 * 1024 * 1024, kARGB_GrMaskFormat, |
| 266 | { 1024, 1024 }, { 256, 256 }); |
| 267 | test_atlas_config(reporter, 65536, 4 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 268 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 269 | // 8 MB |
| 270 | test_atlas_config(reporter, 65536, 8 * 1024 * 1024, kARGB_GrMaskFormat, |
| 271 | { 2048, 1024 }, { 256, 256 }); |
| 272 | test_atlas_config(reporter, 65536, 8 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 273 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 274 | // 16 MB (should be same as 8 MB) |
| 275 | test_atlas_config(reporter, 65536, 16 * 1024 * 1024, kARGB_GrMaskFormat, |
| 276 | { 2048, 1024 }, { 256, 256 }); |
| 277 | test_atlas_config(reporter, 65536, 16 * 1024 * 1024, kA8_GrMaskFormat, |
Jim Van Verth | 578b089 | 2018-12-20 20:48:55 +0000 | [diff] [blame] | 278 | { 2048, 2048 }, { 512, 512 }); |
Jim Van Verth | f6206f9 | 2018-12-14 08:22:24 -0500 | [diff] [blame] | 279 | |
| 280 | // 4MB, restricted texture size |
| 281 | test_atlas_config(reporter, 1024, 8 * 1024 * 1024, kARGB_GrMaskFormat, |
| 282 | { 1024, 1024 }, { 256, 256 }); |
| 283 | test_atlas_config(reporter, 1024, 8 * 1024 * 1024, kA8_GrMaskFormat, |
| 284 | { 1024, 1024 }, { 256, 256 }); |
| 285 | |
| 286 | // 3 MB (should be same as 2 MB) |
| 287 | test_atlas_config(reporter, 65536, 3 * 1024 * 1024, kARGB_GrMaskFormat, |
| 288 | { 1024, 512 }, { 256, 256 }); |
| 289 | test_atlas_config(reporter, 65536, 3 * 1024 * 1024, kA8_GrMaskFormat, |
| 290 | { 2048, 1024 }, { 512, 256 }); |
| 291 | |
| 292 | // minimum size |
| 293 | test_atlas_config(reporter, 65536, 0, kARGB_GrMaskFormat, |
| 294 | { 256, 256 }, { 256, 256 }); |
| 295 | test_atlas_config(reporter, 65536, 0, kA8_GrMaskFormat, |
| 296 | { 512, 512 }, { 256, 256 }); |
Brian Salomon | 58f153c | 2018-10-18 21:51:15 -0400 | [diff] [blame] | 297 | } |