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