bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | // This test only works with the GPU backend. |
| 9 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "gm/gm.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkBitmap.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 12 | #include "include/core/SkCanvas.h" |
| 13 | #include "include/core/SkColor.h" |
| 14 | #include "include/core/SkColorFilter.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 15 | #include "include/core/SkImage.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 16 | #include "include/core/SkImageInfo.h" |
| 17 | #include "include/core/SkPaint.h" |
| 18 | #include "include/core/SkPixmap.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 19 | #include "include/core/SkRefCnt.h" |
| 20 | #include "include/core/SkScalar.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 21 | #include "include/core/SkSize.h" |
| 22 | #include "include/core/SkString.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 23 | #include "include/core/SkTypes.h" |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 24 | #include "include/core/SkYUVAIndex.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 25 | #include "include/gpu/GrBackendSurface.h" |
Robert Phillips | b87b39b | 2020-07-01 14:45:24 -0400 | [diff] [blame] | 26 | #include "include/gpu/GrDirectContext.h" |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 27 | #include "include/gpu/GrTypes.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 28 | #include "include/private/SkTo.h" |
Brian Salomon | c505a45 | 2020-04-06 10:29:02 -0400 | [diff] [blame] | 29 | #include "src/core/SkMathPriv.h" |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 30 | #include "src/core/SkYUVMath.h" |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 31 | #include "tools/Resources.h" |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 32 | #include "tools/gpu/YUVUtils.h" |
| 33 | |
| 34 | using sk_gpu_test::YUVABackendReleaseContext; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 35 | |
Ben Wagner | 7fde8e1 | 2019-05-01 17:28:53 -0400 | [diff] [blame] | 36 | class GrRenderTargetContext; |
| 37 | |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 38 | namespace skiagm { |
Chris Dalton | 3a77837 | 2019-02-07 15:23:36 -0700 | [diff] [blame] | 39 | class ImageFromYUVTextures : public GpuGM { |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 40 | public: |
| 41 | ImageFromYUVTextures() { |
| 42 | this->setBGColor(0xFFFFFFFF); |
| 43 | } |
| 44 | |
| 45 | protected: |
| 46 | SkString onShortName() override { |
| 47 | return SkString("image_from_yuv_textures"); |
| 48 | } |
| 49 | |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 50 | SkISize onISize() override { return {1420, 610}; } |
Brian Salomon | 9b22838 | 2020-03-24 12:55:29 -0400 | [diff] [blame] | 51 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 52 | static SkBitmap CreateBmpAndPlanes(const char* name, SkBitmap yuvaBmps[4]) { |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 53 | SkBitmap bmp; |
| 54 | if (!GetResourceAsBitmap(name, &bmp)) { |
| 55 | return {}; |
| 56 | } |
| 57 | auto ii = SkImageInfo::Make(bmp.dimensions(), kRGBA_8888_SkColorType, kPremul_SkAlphaType); |
| 58 | |
| 59 | SkBitmap rgbaBmp; |
| 60 | rgbaBmp.allocPixels(ii); |
| 61 | bmp.readPixels(rgbaBmp.pixmap(), 0, 0); |
| 62 | |
| 63 | SkImageInfo yaInfo = SkImageInfo::Make(rgbaBmp.dimensions(), kAlpha_8_SkColorType, |
| 64 | kUnpremul_SkAlphaType); |
| 65 | yuvaBmps[0].allocPixels(yaInfo); |
| 66 | SkISize uvSize = {rgbaBmp.width()/2, rgbaBmp.height()/2}; |
| 67 | SkImageInfo uvInfo = SkImageInfo::Make(uvSize, kAlpha_8_SkColorType, kUnpremul_SkAlphaType); |
| 68 | yuvaBmps[1].allocPixels(uvInfo); |
| 69 | yuvaBmps[2].allocPixels(uvInfo); |
| 70 | yuvaBmps[3].allocPixels(yaInfo); |
| 71 | |
| 72 | unsigned char* yuvPixels[] = { |
| 73 | static_cast<unsigned char*>(yuvaBmps[0].getPixels()), |
| 74 | static_cast<unsigned char*>(yuvaBmps[1].getPixels()), |
| 75 | static_cast<unsigned char*>(yuvaBmps[2].getPixels()), |
| 76 | static_cast<unsigned char*>(yuvaBmps[3].getPixels()), |
| 77 | }; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 78 | |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 79 | float m[20]; |
| 80 | SkColorMatrix_RGB2YUV(kJPEG_SkYUVColorSpace, m); |
Robert Phillips | 0a22ba8 | 2019-03-06 12:36:47 -0500 | [diff] [blame] | 81 | // Here we encode using the kJPEG_SkYUVColorSpace (i.e., full-swing Rec 601) even though |
| 82 | // we will draw it with all the supported yuv color spaces when converted back to RGB |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 83 | for (int j = 0; j < yaInfo.height(); ++j) { |
| 84 | for (int i = 0; i < yaInfo.width(); ++i) { |
| 85 | auto rgba = *rgbaBmp.getAddr32(i, j); |
| 86 | auto r = (rgba & 0x000000ff) >> 0; |
| 87 | auto g = (rgba & 0x0000ff00) >> 8; |
| 88 | auto b = (rgba & 0x00ff0000) >> 16; |
| 89 | auto a = (rgba & 0xff000000) >> 24; |
| 90 | yuvPixels[0][j*yaInfo.width() + i] = SkToU8( |
| 91 | sk_float_round2int(m[0]*r + m[1]*g + m[2]*b + m[3]*a + 255*m[4])); |
| 92 | yuvPixels[3][j*yaInfo.width() + i] = SkToU8(sk_float_round2int( |
| 93 | m[15]*r + m[16]*g + m[17]*b + m[18]*a + 255*m[19])); |
| 94 | } |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 95 | } |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 96 | for (int j = 0; j < uvInfo.height(); ++j) { |
| 97 | for (int i = 0; i < uvInfo.width(); ++i) { |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 98 | // Average together 4 pixels of RGB. |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 99 | int rgba[] = {0, 0, 0, 0}; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 100 | for (int y = 0; y < 2; ++y) { |
| 101 | for (int x = 0; x < 2; ++x) { |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 102 | auto src = *rgbaBmp.getAddr32(2 * i + x, 2 * j + y); |
| 103 | rgba[0] += (src & 0x000000ff) >> 0; |
| 104 | rgba[1] += (src & 0x0000ff00) >> 8; |
| 105 | rgba[2] += (src & 0x00ff0000) >> 16; |
| 106 | rgba[3] += (src & 0xff000000) >> 24; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 107 | } |
| 108 | } |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 109 | for (int c = 0; c < 4; ++c) { |
| 110 | rgba[c] /= 4; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 111 | } |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 112 | int uvIndex = j*uvInfo.width() + i; |
| 113 | yuvPixels[1][uvIndex] = SkToU8(sk_float_round2int( |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 114 | m[5]*rgba[0] + m[6]*rgba[1] + m[7]*rgba[2] + m[8]*rgba[3] + 255*m[9])); |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 115 | yuvPixels[2][uvIndex] = SkToU8(sk_float_round2int( |
Brian Salomon | 7c94d18 | 2020-03-18 17:24:02 -0400 | [diff] [blame] | 116 | m[10]*rgba[0] + m[11]*rgba[1] + m[12]*rgba[2] + m[13]*rgba[3] + 255*m[14])); |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 117 | } |
| 118 | } |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 119 | return rgbaBmp; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 120 | } |
| 121 | |
Robert Phillips | b87b39b | 2020-07-01 14:45:24 -0400 | [diff] [blame] | 122 | static bool CreateYUVBackendTextures(GrDirectContext* context, SkBitmap bmps[4], |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 123 | SkYUVAIndex indices[4], |
| 124 | YUVABackendReleaseContext* beContext) { |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 125 | for (int i = 0; i < 4; ++i) { |
Robert Phillips | 98c39ba | 2020-06-26 10:01:19 -0400 | [diff] [blame] | 126 | GrBackendTexture tmp = context->createBackendTexture( |
| 127 | bmps[i].pixmap(), GrRenderable::kNo, GrProtected::kNo, |
| 128 | YUVABackendReleaseContext::CreationCompleteProc(i), |
| 129 | beContext); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 130 | if (!tmp.isValid()) { |
| 131 | return false; |
Brian Salomon | c505a45 | 2020-04-06 10:29:02 -0400 | [diff] [blame] | 132 | } |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 133 | |
| 134 | beContext->set(i, tmp); |
| 135 | } |
| 136 | |
| 137 | for (int i = 0; i < 4; ++i) { |
| 138 | auto chanMask = beContext->beTexture(i).getBackendFormat().channelMask(); |
Brian Salomon | c505a45 | 2020-04-06 10:29:02 -0400 | [diff] [blame] | 139 | // We expect the single channel bitmaps to produce single channel textures. |
| 140 | SkASSERT(chanMask && SkIsPow2(chanMask)); |
| 141 | if (chanMask & kGray_SkColorChannelFlag) { |
| 142 | indices[i].fChannel = SkColorChannel::kR; |
| 143 | } else { |
| 144 | indices[i].fChannel = static_cast<SkColorChannel>(31 - SkCLZ(chanMask)); |
| 145 | } |
| 146 | indices[i].fIndex = i; |
| 147 | } |
Brian Salomon | 8efbbbc | 2020-04-02 16:59:19 -0400 | [diff] [blame] | 148 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 149 | return true; |
| 150 | } |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 151 | |
Robert Phillips | b87b39b | 2020-07-01 14:45:24 -0400 | [diff] [blame] | 152 | sk_sp<SkImage> makeYUVAImage(GrDirectContext* context) { |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 153 | auto releaseContext = new YUVABackendReleaseContext(context); |
| 154 | SkYUVAIndex indices[4]; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 155 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 156 | if (!CreateYUVBackendTextures(context, fYUVABmps, indices, releaseContext)) { |
Robert Phillips | 98c39ba | 2020-06-26 10:01:19 -0400 | [diff] [blame] | 157 | YUVABackendReleaseContext::Unwind(context, releaseContext, false); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 158 | return nullptr; |
| 159 | } |
| 160 | |
| 161 | return SkImage::MakeFromYUVATextures(context, |
| 162 | kJPEG_SkYUVColorSpace, |
| 163 | releaseContext->beTextures(), |
| 164 | indices, |
| 165 | fRGBABmp.dimensions(), |
| 166 | kTopLeft_GrSurfaceOrigin, |
| 167 | nullptr, |
| 168 | YUVABackendReleaseContext::Release, |
| 169 | releaseContext); |
| 170 | } |
| 171 | |
Robert Phillips | b87b39b | 2020-07-01 14:45:24 -0400 | [diff] [blame] | 172 | sk_sp<SkImage> createReferenceImage(GrDirectContext* context) { |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 173 | auto planeReleaseContext = new YUVABackendReleaseContext(context); |
| 174 | SkYUVAIndex indices[4]; |
| 175 | |
| 176 | if (!CreateYUVBackendTextures(context, fYUVABmps, indices, planeReleaseContext)) { |
Robert Phillips | 98c39ba | 2020-06-26 10:01:19 -0400 | [diff] [blame] | 177 | YUVABackendReleaseContext::Unwind(context, planeReleaseContext, false); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 178 | return nullptr; |
| 179 | } |
| 180 | |
| 181 | auto rgbaReleaseContext = new YUVABackendReleaseContext(context); |
Robert Phillips | 98c39ba | 2020-06-26 10:01:19 -0400 | [diff] [blame] | 182 | |
| 183 | GrBackendTexture resultTexture = context->createBackendTexture( |
| 184 | fRGBABmp.dimensions().width(), fRGBABmp.dimensions().height(), |
| 185 | kRGBA_8888_SkColorType, SkColors::kTransparent, |
| 186 | GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo, |
| 187 | YUVABackendReleaseContext::CreationCompleteProc(0), |
| 188 | rgbaReleaseContext); |
| 189 | if (!resultTexture.isValid()) { |
| 190 | YUVABackendReleaseContext::Unwind(context, planeReleaseContext, false); |
| 191 | YUVABackendReleaseContext::Unwind(context, rgbaReleaseContext, false); |
| 192 | return nullptr; |
| 193 | } |
| 194 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 195 | rgbaReleaseContext->set(0, resultTexture); |
| 196 | |
| 197 | auto tmp = SkImage::MakeFromYUVATexturesCopyWithExternalBackend( |
| 198 | context, |
| 199 | kJPEG_SkYUVColorSpace, |
| 200 | planeReleaseContext->beTextures(), |
| 201 | indices, |
| 202 | fRGBABmp.dimensions(), |
| 203 | kTopLeft_GrSurfaceOrigin, |
| 204 | resultTexture, |
| 205 | nullptr, |
| 206 | YUVABackendReleaseContext::Release, |
| 207 | rgbaReleaseContext); |
Robert Phillips | 98c39ba | 2020-06-26 10:01:19 -0400 | [diff] [blame] | 208 | YUVABackendReleaseContext::Unwind(context, planeReleaseContext, true); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 209 | return tmp; |
| 210 | } |
| 211 | |
Robert Phillips | b87b39b | 2020-07-01 14:45:24 -0400 | [diff] [blame] | 212 | DrawResult onGpuSetup(GrDirectContext* context, SkString* errorMsg) override { |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 213 | if (!context || context->abandoned()) { |
| 214 | return DrawResult::kSkip; |
| 215 | } |
| 216 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 217 | fRGBABmp = CreateBmpAndPlanes("images/mandrill_32.png", fYUVABmps); |
| 218 | |
| 219 | // We make a version of this image for each draw because, if any draw flattens it to |
| 220 | // RGBA, then all subsequent draws would use the RGBA texture. |
| 221 | for (int i = 0; i < kNumImages; ++i) { |
| 222 | fYUVAImages[i] = this->makeYUVAImage(context); |
| 223 | if (!fYUVAImages[i]) { |
| 224 | *errorMsg = "Couldn't create src YUVA image."; |
| 225 | return DrawResult::kFail; |
| 226 | } |
| 227 | } |
| 228 | |
| 229 | fReferenceImage = this->createReferenceImage(context); |
| 230 | if (!fReferenceImage) { |
| 231 | *errorMsg = "Couldn't create reference YUVA image."; |
| 232 | return DrawResult::kFail; |
| 233 | } |
| 234 | |
| 235 | // Some backends (e.g., Vulkan) require all work be completed for backend textures |
| 236 | // before they are deleted. Since we don't know when we'll next have access to a |
| 237 | // direct context, flush all the work now. |
Greg Daniel | ce9f016 | 2020-06-30 13:42:46 -0400 | [diff] [blame] | 238 | context->flush(); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 239 | context->submit(true); |
| 240 | |
| 241 | return DrawResult::kOk; |
| 242 | } |
| 243 | |
Robert Phillips | b795bea | 2020-06-25 12:38:53 -0400 | [diff] [blame] | 244 | void onGpuTeardown() override { |
| 245 | for (sk_sp<SkImage>& image : fYUVAImages) { |
| 246 | image.reset(); |
| 247 | } |
| 248 | fReferenceImage.reset(); |
| 249 | } |
| 250 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 251 | SkImage* getYUVAImage(int index) { |
| 252 | SkASSERT(index >= 0 && index < kNumImages); |
| 253 | return fYUVAImages[index].get(); |
| 254 | } |
| 255 | |
Robert Phillips | 95c250c | 2020-06-29 15:36:12 -0400 | [diff] [blame] | 256 | void onDraw(GrRecordingContext*, GrRenderTargetContext*, SkCanvas* canvas) override { |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 257 | auto draw_image = [canvas](SkImage* image, SkFilterQuality fq) -> SkSize { |
| 258 | if (!image) { |
| 259 | return {0, 0}; |
Brian Salomon | 3673748 | 2020-03-24 16:47:52 -0400 | [diff] [blame] | 260 | } |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 261 | SkPaint paint; |
| 262 | paint.setFilterQuality(fq); |
| 263 | canvas->drawImage(image, 0, 0, &paint); |
| 264 | return {SkIntToScalar(image->width()), SkIntToScalar(image->height())}; |
| 265 | }; |
Brian Salomon | 3673748 | 2020-03-24 16:47:52 -0400 | [diff] [blame] | 266 | |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 267 | auto draw_image_rect = [canvas](SkImage* image, SkFilterQuality fq) -> SkSize { |
| 268 | if (!image) { |
| 269 | return {0, 0}; |
| 270 | } |
| 271 | SkPaint paint; |
| 272 | paint.setFilterQuality(fq); |
| 273 | auto subset = SkRect::Make(image->dimensions()); |
| 274 | subset.inset(subset.width() * .05f, subset.height() * .1f); |
| 275 | auto dst = SkRect::MakeWH(subset.width(), subset.height()); |
| 276 | canvas->drawImageRect(image, subset, dst, &paint); |
| 277 | return {dst.width(), dst.height()}; |
| 278 | }; |
| 279 | |
| 280 | auto draw_image_shader = [canvas](SkImage* image, SkFilterQuality fq) -> SkSize { |
| 281 | if (!image) { |
| 282 | return {0, 0}; |
| 283 | } |
| 284 | SkMatrix m; |
| 285 | m.setRotate(45, image->width()/2.f, image->height()/2.f); |
| 286 | auto shader = image->makeShader(SkTileMode::kMirror, SkTileMode::kDecal, m); |
| 287 | SkPaint paint; |
| 288 | paint.setFilterQuality(fq); |
| 289 | paint.setShader(std::move(shader)); |
| 290 | auto rect = SkRect::MakeWH(image->width() * 1.3f, image->height()); |
| 291 | canvas->drawRect(rect, paint); |
| 292 | return {rect.width(), rect.height()}; |
| 293 | }; |
| 294 | |
| 295 | canvas->translate(kPad, kPad); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 296 | int imageIndex = 0; |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 297 | using DrawSig = SkSize(SkImage* image, SkFilterQuality fq); |
| 298 | using DF = std::function<DrawSig>; |
| 299 | for (const auto& draw : {DF(draw_image), DF(draw_image_rect), DF(draw_image_shader)}) { |
| 300 | for (auto scale : {1.f, 4.f, 0.75f}) { |
| 301 | SkScalar h = 0; |
| 302 | canvas->save(); |
| 303 | for (auto fq : {kNone_SkFilterQuality, kLow_SkFilterQuality, |
| 304 | kMedium_SkFilterQuality, kHigh_SkFilterQuality}) { |
| 305 | canvas->save(); |
| 306 | canvas->scale(scale, scale); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 307 | auto s1 = draw(this->getYUVAImage(imageIndex++), fq); |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 308 | canvas->restore(); |
| 309 | canvas->translate(kPad + SkScalarCeilToScalar(scale*s1.width()), 0); |
| 310 | canvas->save(); |
| 311 | canvas->scale(scale, scale); |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 312 | auto s2 = draw(fReferenceImage.get(), fq); |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 313 | canvas->restore(); |
| 314 | canvas->translate(kPad + SkScalarCeilToScalar(scale*s2.width()), 0); |
| 315 | h = std::max({h, s1.height(), s2.height()}); |
| 316 | } |
| 317 | canvas->restore(); |
| 318 | canvas->translate(0, kPad + SkScalarCeilToScalar(scale*h)); |
| 319 | } |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 320 | } |
| 321 | } |
| 322 | |
| 323 | private: |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 324 | SkBitmap fRGBABmp; // TODO: oddly, it looks like this could just be an SkISize |
Brian Salomon | 5c4c61e | 2020-03-25 14:26:01 -0400 | [diff] [blame] | 325 | SkBitmap fYUVABmps[4]; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 326 | |
Robert Phillips | f105d38 | 2020-06-19 14:27:14 -0400 | [diff] [blame] | 327 | // 3 draws x 3 scales x 4 filter qualities |
| 328 | static constexpr int kNumImages = 3 * 3 * 4; |
| 329 | sk_sp<SkImage> fYUVAImages[kNumImages]; |
| 330 | sk_sp<SkImage> fReferenceImage; |
| 331 | |
Robert Phillips | 0a22ba8 | 2019-03-06 12:36:47 -0500 | [diff] [blame] | 332 | static constexpr SkScalar kPad = 10.0f; |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 333 | |
| 334 | typedef GM INHERITED; |
| 335 | }; |
| 336 | |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 337 | DEF_GM(return new ImageFromYUVTextures;) |
bsalomon | 993a421 | 2015-05-29 11:37:25 -0700 | [diff] [blame] | 338 | } |