1 /*
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
8 #include "gm/gm.h"
9
10 #include "include/core/SkBitmap.h"
11 #include "include/core/SkCanvas.h"
12 #include "include/core/SkImage.h"
13 #include "include/core/SkPixmap.h"
14 #include "include/core/SkShader.h"
15 #include "include/core/SkStream.h"
16 #include "include/core/SkSurface.h"
17 #include "include/core/SkTileMode.h"
18 #include "include/encode/SkJpegEncoder.h"
19 #include "include/gpu/ganesh/GrRecordingContext.h"
20 #include "include/gpu/ganesh/SkImageGanesh.h"
21 #include "src/base/SkRandom.h"
22 #include "src/core/SkCachedData.h"
23 #include "src/image/SkImage_Base.h"
24 #include "tools/DecodeUtils.h"
25 #include "tools/Resources.h"
26 #include "tools/gpu/YUVUtils.h"
27
28 static constexpr int kScale = 10;
29 static constexpr SkISize kImageDim = {5, 5};
30
make_image(GrRecordingContext * rContext,skgpu::graphite::Recorder * recorder)31 static sk_sp<SkImage> make_image(GrRecordingContext* rContext,
32 skgpu::graphite::Recorder* recorder) {
33 // Generate a small jpeg with odd dimensions.
34 SkBitmap bmp;
35 bmp.allocPixels(SkImageInfo::Make(kImageDim, kRGBA_8888_SkColorType, kPremul_SkAlphaType));
36 SkRandom random;
37 // These random values won't compress well, but it doesn't matter. This test exists to
38 // compare the GPU YUV code path to the SW.
39 for (int y = 0; y < bmp.height(); ++y) {
40 for (int x = 0; x < bmp.width(); ++x) {
41 *bmp.getAddr32(x, y) = random.nextU() | 0xFF000000;
42 }
43 }
44 bmp.notifyPixelsChanged();
45 SkDynamicMemoryWStream stream;
46 SkJpegEncoder::Options options;
47 options.fDownsample = SkJpegEncoder::Downsample::k420;
48 options.fQuality = 100;
49 if (!SkJpegEncoder::Encode(&stream, bmp.pixmap(), options)) {
50 return nullptr;
51 }
52 auto imageHelper = sk_gpu_test::LazyYUVImage::Make(stream.detachAsData());
53 if (!imageHelper) {
54 return nullptr;
55 }
56 #if defined(SK_GRAPHITE)
57 if (recorder) {
58 return imageHelper->refImage(recorder, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
59 } else
60 #endif
61 {
62 return imageHelper->refImage(rContext, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
63 }
64 }
65
66 // This GM tests that the YUVA image code path in the GPU backend handles odd sized images with
67 // 420 chroma subsampling correctly.
68 DEF_SIMPLE_GM_CAN_FAIL(yuv420_odd_dim, canvas, errMsg,
69 kScale* kImageDim.width(), kScale* kImageDim.height()) {
70 auto rContext = canvas->recordingContext();
71 skgpu::graphite::Recorder* recorder = nullptr;
72 #if defined(SK_GRAPHITE)
73 recorder = canvas->recorder();
74 #endif
75 if (!rContext && !recorder) {
76 // This GM exists to exercise GPU planar images.
77 return skiagm::DrawResult::kSkip;
78 }
79 auto image = make_image(rContext, recorder);
80 if (!image) {
81 if (rContext) {
82 return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
83 } else {
84 return skiagm::DrawResult::kFail;
85 }
86 }
87 // We draw the image offscreen and then blow it up using nearest filtering by kScale.
88 // This avoids skbug.com/9693
89 sk_sp<SkSurface> surface;
90 if (auto origSurface = canvas->getSurface()) {
91 surface = origSurface->makeSurface(image->width(), image->height());
92 } else {
93 auto ct = canvas->imageInfo().colorType();
94 if (ct == kUnknown_SkColorType) {
95 ct = image->colorType();
96 }
97 auto info = canvas->imageInfo().makeColorType(ct);
98 info = info.makeAlphaType(kPremul_SkAlphaType);
99 surface = SkSurfaces::Raster(info);
100 }
101 surface->getCanvas()->drawImage(image, 0, 0);
102 canvas->scale(kScale, kScale);
103 canvas->drawImage(surface->makeImageSnapshot(), 0, 0);
104 return skiagm::DrawResult::kOk;
105 }
106
107 // crbug.com/1210557 Subsampled planes weren't repeated at the correct frequency.
108 DEF_SIMPLE_GM_CAN_FAIL(yuv420_odd_dim_repeat, canvas, errMsg,
109 1000,
110 500) {
111 auto rContext = canvas->recordingContext();
112 skgpu::graphite::Recorder* recorder = nullptr;
113 #if defined(SK_GRAPHITE)
114 recorder = canvas->recorder();
115 #endif
116 if (!rContext && !recorder) {
117 // This GM exists to exercise GPU planar images.
118 return skiagm::DrawResult::kSkip;
119 }
120 auto image = ToolUtils::GetResourceAsImage("images/mandrill_256.png");
121 if (!image) {
122 if (rContext) {
123 return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
124 } else {
125 return skiagm::DrawResult::kFail;
126 }
127 }
128 // Make sure the image is odd dimensioned.
129 int w = image->width() & 0b1 ? image->width() : image->width() - 1;
130 int h = image->height() & 0b1 ? image->height() : image->height() - 1;
131 image = image->makeSubset(nullptr, SkIRect::MakeWH(w, h));
132
133 auto [planes, yuvaInfo] = sk_gpu_test::MakeYUVAPlanesAsA8(image.get(),
134 kJPEG_SkYUVColorSpace,
135 SkYUVAInfo::Subsampling::k420,
136 nullptr);
137 SkPixmap pixmaps[4];
138 for (int i = 0; i < yuvaInfo.numPlanes(); ++i) {
139 planes[i]->peekPixels(&pixmaps[i]);
140 }
141 auto yuvaPixmaps = SkYUVAPixmaps::FromExternalPixmaps(yuvaInfo, pixmaps);
142 auto lazyYUV = sk_gpu_test::LazyYUVImage::Make(yuvaPixmaps, skgpu::Mipmapped::kYes);
143
144 #if defined(SK_GRAPHITE)
145 if (recorder) {
146 image = lazyYUV->refImage(recorder, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
147 } else
148 #endif
149 {
150 image = lazyYUV->refImage(rContext, sk_gpu_test::LazyYUVImage::Type::kFromPixmaps);
151 }
152 if (!image) {
153 *errMsg = "Could not make YUVA image";
154 if (rContext) {
155 return rContext->abandoned() ? skiagm::DrawResult::kOk : skiagm::DrawResult::kFail;
156 } else {
157 return skiagm::DrawResult::kFail;
158 }
159 }
160 int i = 0;
161 for (SkMipmapMode mm : {SkMipmapMode::kNone, SkMipmapMode::kLinear}) {
162 int j = 0;
163 for (SkFilterMode filter : {SkFilterMode::kNearest, SkFilterMode::kLinear}) {
164 canvas->save();
165 canvas->clipRect(SkRect::MakeXYWH(500.f*j, 250.f*i, 500.f, 250.f));
166 canvas->rotate(30.f);
167 canvas->scale(0.4f, 0.4f); // so mipmaps sampling doesn't just use base level.
168 // Large translation so that if U/V planes aren't repeated correctly WRT to Y plane we
169 // accumulate a lot of error.
170 canvas->translate(-240000.f, -240000.f);
171 auto shader = image->makeShader(SkTileMode::kRepeat,
172 SkTileMode::kRepeat,
173 SkSamplingOptions(filter, mm));
174 SkPaint paint;
175 paint.setShader(std::move(shader));
176 canvas->drawPaint(paint);
177 canvas->restore();
178 ++j;
179 }
180 ++i;
181 }
182 return skiagm::DrawResult::kOk;
183 }
184
