robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2012 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 "tests/Test.h" |
reed | f037e0b | 2014-10-30 11:34:15 -0700 | [diff] [blame] | 9 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "include/core/SkCanvas.h" |
| 11 | #include "include/core/SkSurface.h" |
| 12 | #include "include/gpu/GrContext.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 13 | #include "include/private/SkTo.h" |
| 14 | #include "src/gpu/GrContextPriv.h" |
Brian Salomon | f2ebdd9 | 2019-09-30 12:15:30 -0400 | [diff] [blame] | 15 | #include "src/gpu/GrImageInfo.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 16 | #include "src/gpu/GrProxyProvider.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 17 | #include "src/gpu/GrSurfaceContext.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 18 | #include "src/gpu/GrSurfaceProxy.h" |
| 19 | #include "src/gpu/GrTextureProxy.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "tools/gpu/ProxyUtils.h" |
robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 21 | |
bsalomon | f46a124 | 2015-12-15 12:37:38 -0800 | [diff] [blame] | 22 | // This was made indivisible by 4 to ensure we test setting GL_PACK_ALIGNMENT properly. |
| 23 | static const int X_SIZE = 13; |
| 24 | static const int Y_SIZE = 13; |
robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 25 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 26 | static void validate_alpha_data(skiatest::Reporter* reporter, int w, int h, const uint8_t* actual, |
Brian Osman | 10fc6fd | 2018-03-02 11:01:10 -0500 | [diff] [blame] | 27 | size_t actualRowBytes, const uint8_t* expected, SkString extraMsg, |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 28 | GrColorType colorType) { |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 29 | for (int y = 0; y < h; ++y) { |
| 30 | for (int x = 0; x < w; ++x) { |
| 31 | uint8_t a = actual[y * actualRowBytes + x]; |
| 32 | uint8_t e = expected[y * w + x]; |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 33 | if (GrColorType::kRGBA_1010102 == colorType) { |
Brian Osman | 10fc6fd | 2018-03-02 11:01:10 -0500 | [diff] [blame] | 34 | // This config only preserves two bits of alpha |
| 35 | a >>= 6; |
| 36 | e >>= 6; |
| 37 | } |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 38 | if (e != a) { |
| 39 | ERRORF(reporter, |
| 40 | "Failed alpha readback. Expected: 0x%02x, Got: 0x%02x at (%d,%d), %s", |
| 41 | e, a, x, y, extraMsg.c_str()); |
| 42 | return; |
| 43 | } |
| 44 | } |
| 45 | } |
| 46 | } |
robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 47 | |
egdaniel | ab527a5 | 2016-06-28 08:07:26 -0700 | [diff] [blame] | 48 | DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, ctxInfo) { |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 49 | GrContext* context = ctxInfo.grContext(); |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 50 | GrProxyProvider* proxyProvider = context->priv().proxyProvider(); |
Robert Phillips | 1afd4cd | 2018-01-08 13:40:32 -0500 | [diff] [blame] | 51 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 52 | unsigned char alphaData[X_SIZE * Y_SIZE]; |
robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 53 | |
robertphillips | df082c5 | 2016-04-19 08:32:40 -0700 | [diff] [blame] | 54 | static const int kClearValue = 0x2; |
| 55 | |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 56 | bool match; |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 57 | static const size_t kRowBytes[] = {0, X_SIZE, X_SIZE + 1, 2 * X_SIZE - 1}; |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 58 | { |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 59 | GrSurfaceDesc desc; |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 60 | desc.fWidth = X_SIZE; |
| 61 | desc.fHeight = Y_SIZE; |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 62 | |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 63 | // We are initializing the texture with zeros here |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 64 | memset(alphaData, 0, X_SIZE * Y_SIZE); |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 65 | |
Brian Osman | 2700abc | 2018-09-12 10:19:41 -0400 | [diff] [blame] | 66 | const SkImageInfo ii = SkImageInfo::MakeA8(X_SIZE, Y_SIZE); |
| 67 | |
| 68 | SkPixmap pixmap(ii, alphaData, ii.minRowBytes()); |
| 69 | sk_sp<SkImage> alphaImg = SkImage::MakeRasterCopy(pixmap); |
Brian Salomon | f2c2ba9 | 2019-07-17 09:59:59 -0400 | [diff] [blame] | 70 | sk_sp<GrTextureProxy> proxy = proxyProvider->createTextureProxy( |
Brian Salomon | 96b383a | 2019-08-13 16:55:41 -0400 | [diff] [blame] | 71 | alphaImg, 1, SkBudgeted::kNo, SkBackingFit::kExact); |
Robert Phillips | 2f49314 | 2017-03-02 18:18:38 -0500 | [diff] [blame] | 72 | if (!proxy) { |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 73 | ERRORF(reporter, "Could not create alpha texture."); |
| 74 | return; |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 75 | } |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 76 | |
| 77 | SkASSERT(proxy->origin() == kTopLeft_GrSurfaceOrigin); |
| 78 | GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(), |
| 79 | GrColorType::kAlpha_8); |
| 80 | GrSurfaceProxyView view(std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle); |
| 81 | auto sContext = GrSurfaceContext::Make(context, std::move(view), GrColorType::kAlpha_8, |
Greg Daniel | bfa19c4 | 2019-12-19 16:41:40 -0500 | [diff] [blame] | 82 | kPremul_SkAlphaType, nullptr); |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 83 | |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 84 | sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, ii)); |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 85 | |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 86 | // create a distinctive texture |
| 87 | for (int y = 0; y < Y_SIZE; ++y) { |
| 88 | for (int x = 0; x < X_SIZE; ++x) { |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 89 | alphaData[y * X_SIZE + x] = y*X_SIZE+x; |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 90 | } |
| 91 | } |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 92 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 93 | for (auto rowBytes : kRowBytes) { |
Robert Phillips | c949ce9 | 2017-01-19 16:59:04 -0500 | [diff] [blame] | 94 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 95 | // upload the texture (do per-rowbytes iteration because we may overwrite below). |
Brian Salomon | 1d43530 | 2019-07-01 13:05:28 -0400 | [diff] [blame] | 96 | bool result = sContext->writePixels(ii, alphaData, 0, {0, 0}); |
Brian Salomon | 1c80e99 | 2018-01-29 09:50:47 -0500 | [diff] [blame] | 97 | REPORTER_ASSERT(reporter, result, "Initial A8 writePixels failed"); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 98 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 99 | size_t nonZeroRowBytes = rowBytes ? rowBytes : X_SIZE; |
Brian Osman | 10fc6fd | 2018-03-02 11:01:10 -0500 | [diff] [blame] | 100 | size_t bufLen = nonZeroRowBytes * Y_SIZE; |
| 101 | std::unique_ptr<uint8_t[]> readback(new uint8_t[bufLen]); |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 102 | // clear readback to something non-zero so we can detect readback failures |
Brian Osman | 10fc6fd | 2018-03-02 11:01:10 -0500 | [diff] [blame] | 103 | memset(readback.get(), kClearValue, bufLen); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 104 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 105 | // read the texture back |
Brian Salomon | 1d43530 | 2019-07-01 13:05:28 -0400 | [diff] [blame] | 106 | result = sContext->readPixels(ii, readback.get(), rowBytes, {0, 0}); |
Brian Salomon | 19eaf2d | 2018-03-19 16:06:44 -0400 | [diff] [blame] | 107 | // We don't require reading from kAlpha_8 to be supported. TODO: At least make this work |
| 108 | // when kAlpha_8 is renderable. |
| 109 | if (!result) { |
| 110 | continue; |
| 111 | } |
Brian Salomon | 1c80e99 | 2018-01-29 09:50:47 -0500 | [diff] [blame] | 112 | REPORTER_ASSERT(reporter, result, "Initial A8 readPixels failed"); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 113 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 114 | // make sure the original & read back versions match |
| 115 | SkString msg; |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 116 | msg.printf("rb:%d A8", SkToU32(rowBytes)); |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 117 | validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes, |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 118 | alphaData, msg, GrColorType::kAlpha_8); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 119 | |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 120 | // Now try writing to a single channel surface (if we could create one). |
| 121 | if (surf) { |
robertphillips | 7715e06 | 2016-04-22 10:57:16 -0700 | [diff] [blame] | 122 | SkCanvas* canvas = surf->getCanvas(); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 123 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 124 | SkPaint paint; |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 125 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 126 | const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 127 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 128 | paint.setColor(SK_ColorWHITE); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 129 | |
robertphillips | 7715e06 | 2016-04-22 10:57:16 -0700 | [diff] [blame] | 130 | canvas->drawRect(rect, paint); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 131 | |
Brian Osman | 10fc6fd | 2018-03-02 11:01:10 -0500 | [diff] [blame] | 132 | // Workaround for a bug in old GCC/glibc used in our Chromecast toolchain: |
| 133 | // error: call to '__warn_memset_zero_len' declared with attribute warning: |
| 134 | // memset used with constant zero length parameter; this could be due |
| 135 | // to transposed parameters |
| 136 | // See also: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61294 |
| 137 | if (bufLen > 0) { |
| 138 | memset(readback.get(), kClearValue, bufLen); |
| 139 | } |
robertphillips | 7e92276 | 2016-07-26 11:38:17 -0700 | [diff] [blame] | 140 | result = surf->readPixels(ii, readback.get(), nonZeroRowBytes, 0, 0); |
Brian Salomon | 1c80e99 | 2018-01-29 09:50:47 -0500 | [diff] [blame] | 141 | REPORTER_ASSERT(reporter, result, "A8 readPixels after clear failed"); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 142 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 143 | match = true; |
| 144 | for (int y = 0; y < Y_SIZE && match; ++y) { |
| 145 | for (int x = 0; x < X_SIZE && match; ++x) { |
| 146 | uint8_t rbValue = readback.get()[y * nonZeroRowBytes + x]; |
| 147 | if (0xFF != rbValue) { |
| 148 | ERRORF(reporter, |
| 149 | "Failed alpha readback after clear. Expected: 0xFF, Got: 0x%02x" |
Brian Salomon | 2ea6ff7 | 2016-02-02 11:34:46 -0500 | [diff] [blame] | 150 | " at (%d,%d), rb:%d", rbValue, x, y, SkToU32(rowBytes)); |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 151 | match = false; |
| 152 | } |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 153 | } |
| 154 | } |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 155 | } |
| 156 | } |
| 157 | } |
| 158 | |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 159 | static constexpr struct { |
| 160 | GrColorType fColorType; |
Brian Salomon | e7499c7 | 2019-06-24 12:12:36 -0400 | [diff] [blame] | 161 | SkAlphaType fAlphaType; |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 162 | } kInfos[] = { |
Greg Daniel | e877dce | 2019-07-11 10:52:43 -0400 | [diff] [blame] | 163 | {GrColorType::kRGBA_8888, kPremul_SkAlphaType}, |
| 164 | {GrColorType::kBGRA_8888, kPremul_SkAlphaType}, |
| 165 | {GrColorType::kRGBA_8888_SRGB, kPremul_SkAlphaType}, |
| 166 | {GrColorType::kRGBA_1010102, kPremul_SkAlphaType}, |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 167 | }; |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 168 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 169 | for (int y = 0; y < Y_SIZE; ++y) { |
| 170 | for (int x = 0; x < X_SIZE; ++x) { |
| 171 | alphaData[y * X_SIZE + x] = y*X_SIZE+x; |
| 172 | } |
| 173 | } |
| 174 | |
Robert Phillips | bab2dbb | 2017-04-17 07:43:27 -0400 | [diff] [blame] | 175 | const SkImageInfo dstInfo = SkImageInfo::Make(X_SIZE, Y_SIZE, |
| 176 | kAlpha_8_SkColorType, |
| 177 | kPremul_SkAlphaType); |
| 178 | |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 179 | // Attempt to read back just alpha from a RGBA/BGRA texture. Once with a texture-only src and |
| 180 | // once with a render target. |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 181 | for (auto info : kInfos) { |
Robert Phillips | 9dbcdcc | 2019-05-13 10:40:06 -0400 | [diff] [blame] | 182 | for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) { |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 183 | uint32_t rgbaData[X_SIZE * Y_SIZE]; |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 184 | // Make the alpha channel of the rgba texture come from alphaData. |
| 185 | for (int y = 0; y < Y_SIZE; ++y) { |
| 186 | for (int x = 0; x < X_SIZE; ++x) { |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 187 | rgbaData[y * X_SIZE + x] = GrColorPackRGBA(6, 7, 8, alphaData[y * X_SIZE + x]); |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 188 | } |
| 189 | } |
Robert Phillips | 0bd24dc | 2018-01-16 08:06:32 -0500 | [diff] [blame] | 190 | |
Robert Phillips | 9dbcdcc | 2019-05-13 10:40:06 -0400 | [diff] [blame] | 191 | auto origin = GrRenderable::kYes == renderable ? kBottomLeft_GrSurfaceOrigin |
| 192 | : kTopLeft_GrSurfaceOrigin; |
Brian Salomon | e7499c7 | 2019-06-24 12:12:36 -0400 | [diff] [blame] | 193 | auto proxy = sk_gpu_test::MakeTextureProxyFromData( |
Brian Salomon | 4eda710 | 2019-10-21 15:04:52 -0400 | [diff] [blame] | 194 | context, renderable, origin, |
| 195 | {info.fColorType, info.fAlphaType, nullptr, X_SIZE, Y_SIZE}, rgbaData, 0); |
Robert Phillips | e78b725 | 2017-04-06 07:59:41 -0400 | [diff] [blame] | 196 | if (!proxy) { |
bsalomon | e957331 | 2016-01-25 14:33:25 -0800 | [diff] [blame] | 197 | continue; |
| 198 | } |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 199 | |
Greg Daniel | 3912a4b | 2020-01-14 09:56:04 -0500 | [diff] [blame] | 200 | GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(), |
| 201 | info.fColorType); |
| 202 | GrSurfaceProxyView view(std::move(proxy), origin, swizzle); |
| 203 | auto sContext = GrSurfaceContext::Make(context, std::move(view), info.fColorType, |
Greg Daniel | bfa19c4 | 2019-12-19 16:41:40 -0500 | [diff] [blame] | 204 | kPremul_SkAlphaType, nullptr); |
Robert Phillips | bab2dbb | 2017-04-17 07:43:27 -0400 | [diff] [blame] | 205 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 206 | for (auto rowBytes : kRowBytes) { |
| 207 | size_t nonZeroRowBytes = rowBytes ? rowBytes : X_SIZE; |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 208 | |
Ben Wagner | 7ecc596 | 2016-11-02 17:07:33 -0400 | [diff] [blame] | 209 | std::unique_ptr<uint8_t[]> readback(new uint8_t[nonZeroRowBytes * Y_SIZE]); |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 210 | // Clear so we don't accidentally see values from previous iteration. |
robertphillips | df082c5 | 2016-04-19 08:32:40 -0700 | [diff] [blame] | 211 | memset(readback.get(), kClearValue, nonZeroRowBytes * Y_SIZE); |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 212 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 213 | // read the texture back |
Brian Salomon | 1d43530 | 2019-07-01 13:05:28 -0400 | [diff] [blame] | 214 | bool result = sContext->readPixels(dstInfo, readback.get(), rowBytes, {0, 0}); |
Brian Salomon | 1c80e99 | 2018-01-29 09:50:47 -0500 | [diff] [blame] | 215 | REPORTER_ASSERT(reporter, result, "8888 readPixels failed"); |
bsalomon | 23e5666 | 2016-01-14 07:19:47 -0800 | [diff] [blame] | 216 | |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 217 | // make sure the original & read back versions match |
| 218 | SkString msg; |
Robert Phillips | 9dbcdcc | 2019-05-13 10:40:06 -0400 | [diff] [blame] | 219 | msg.printf("rt:%d, rb:%d 8888", GrRenderable::kYes == renderable, |
| 220 | SkToU32(rowBytes)); |
bsalomon | 9d02b26 | 2016-02-01 12:49:30 -0800 | [diff] [blame] | 221 | validate_alpha_data(reporter, X_SIZE, Y_SIZE, readback.get(), nonZeroRowBytes, |
Brian Salomon | 58389b9 | 2018-03-07 13:01:25 -0500 | [diff] [blame] | 222 | alphaData, msg, info.fColorType); |
kkinnunen | 1530283 | 2015-12-01 04:35:26 -0800 | [diff] [blame] | 223 | } |
| 224 | } |
| 225 | } |
robertphillips@google.com | 6995068 | 2012-04-06 18:06:10 +0000 | [diff] [blame] | 226 | } |