1 /*
2 * Copyright 2020 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 "include/core/SkTypes.h"
9
10 #if !defined(SK_BUILD_FOR_GOOGLE3) // Google3 doesn't have etc1.h
11
12 #include "gm/gm.h"
13 #include "include/core/SkBitmap.h"
14 #include "include/core/SkCanvas.h"
15 #include "include/core/SkColor.h"
16 #include "include/core/SkColorSpace.h"
17 #include "include/core/SkData.h"
18 #include "include/core/SkImage.h"
19 #include "include/core/SkImageInfo.h"
20 #include "include/core/SkPath.h"
21 #include "include/core/SkRect.h"
22 #include "include/core/SkRefCnt.h"
23 #include "include/core/SkSize.h"
24 #include "include/core/SkString.h"
25 #include "include/core/SkTextureCompressionType.h"
26 #include "include/gpu/ganesh/GrDirectContext.h"
27 #include "include/gpu/ganesh/GrRecordingContext.h"
28 #include "include/gpu/ganesh/SkImageGanesh.h"
29 #include "src/core/SkCompressedDataUtils.h"
30 #include "src/core/SkMipmap.h"
31 #include "src/gpu/ganesh/GrCaps.h"
32 #include "src/gpu/ganesh/GrDataUtils.h"
33 #include "src/gpu/ganesh/GrImageContextPriv.h"
34 #include "src/gpu/ganesh/GrRecordingContextPriv.h"
35 #include "src/gpu/ganesh/image/SkImage_GaneshBase.h"
36 #include "src/image/SkImage_Base.h"
37 #include "third_party/etc1/etc1.h"
38 #include "tools/gpu/ProxyUtils.h"
39
40 #if defined(SK_GRAPHITE)
41 #include "include/gpu/graphite/Image.h"
42 #include "include/gpu/graphite/Recorder.h"
43 #include "src/gpu/GpuTypesPriv.h"
44 #include "src/gpu/graphite/Caps.h"
45 #include "src/gpu/graphite/RecorderPriv.h"
46 #include "tools/gpu/ManagedBackendTexture.h"
47 #endif
48
gen_pt(float angle,const SkVector & scale)49 static SkPoint gen_pt(float angle, const SkVector& scale) {
50 SkScalar s = SkScalarSin(angle);
51 SkScalar c = SkScalarCos(angle);
52
53 return { scale.fX * c, scale.fY * s };
54 }
55
56 // The resulting path will be centered at (0,0) and its size will match 'dimensions'
make_gear(SkISize dimensions,int numTeeth)57 static SkPath make_gear(SkISize dimensions, int numTeeth) {
58 SkVector outerRad{ dimensions.fWidth / 2.0f, dimensions.fHeight / 2.0f };
59 SkVector innerRad{ dimensions.fWidth / 2.5f, dimensions.fHeight / 2.5f };
60 const float kAnglePerTooth = 2.0f * SK_ScalarPI / (3 * numTeeth);
61
62 float angle = 0.0f;
63
64 SkPath tmp;
65 tmp.setFillType(SkPathFillType::kWinding);
66
67 tmp.moveTo(gen_pt(angle, outerRad));
68
69 for (int i = 0; i < numTeeth; ++i, angle += 3*kAnglePerTooth) {
70 tmp.lineTo(gen_pt(angle+kAnglePerTooth, outerRad));
71 tmp.lineTo(gen_pt(angle+(1.5f*kAnglePerTooth), innerRad));
72 tmp.lineTo(gen_pt(angle+(2.5f*kAnglePerTooth), innerRad));
73 tmp.lineTo(gen_pt(angle+(3.0f*kAnglePerTooth), outerRad));
74 }
75
76 tmp.close();
77
78 float fInnerRad = 0.1f * std::min(dimensions.fWidth, dimensions.fHeight);
79 if (fInnerRad > 0.5f) {
80 tmp.addCircle(0.0f, 0.0f, fInnerRad, SkPathDirection::kCCW);
81 }
82
83 return tmp;
84 }
85
86 // Render one level of a mipmap
render_level(SkISize dimensions,SkColor color,SkColorType colorType,bool opaque)87 SkBitmap render_level(SkISize dimensions, SkColor color, SkColorType colorType, bool opaque) {
88 SkPath path = make_gear(dimensions, 9);
89
90 SkImageInfo ii = SkImageInfo::Make(dimensions.width(), dimensions.height(),
91 colorType, opaque ? kOpaque_SkAlphaType
92 : kPremul_SkAlphaType);
93 SkBitmap bm;
94 bm.allocPixels(ii);
95
96 bm.eraseColor(opaque ? SK_ColorBLACK : SK_ColorTRANSPARENT);
97
98 SkCanvas c(bm);
99
100 SkPaint paint;
101 paint.setColor(color | 0xFF000000);
102 paint.setAntiAlias(false);
103
104 c.translate(dimensions.width() / 2.0f, dimensions.height() / 2.0f);
105 c.drawPath(path, paint);
106
107 return bm;
108 }
109
110 struct CompressedImageObjects {
111 sk_sp<SkImage> fImage;
112 #if defined(SK_GRAPHITE)
113 sk_sp<sk_gpu_test::ManagedGraphiteTexture> fGraphiteTexture;
114 #else
115 void* fGraphiteTexture = nullptr;
116 #endif
117 };
118
119 // Create the compressed data blob needed to represent a mipmapped 2-color texture of the specified
120 // compression format. In this case 2-color means either opaque black or transparent black plus
121 // one other color.
122 // Note that ETC1/ETC2_RGB8_UNORM only supports 565 opaque textures.
make_compressed_image(SkCanvas * canvas,const SkISize dimensions,SkColorType colorType,bool opaque,SkTextureCompressionType compression)123 static CompressedImageObjects make_compressed_image(SkCanvas* canvas,
124 const SkISize dimensions,
125 SkColorType colorType,
126 bool opaque,
127 SkTextureCompressionType compression) {
128 size_t totalSize = SkCompressedDataSize(compression, dimensions, nullptr, true);
129
130 sk_sp<SkData> tmp = SkData::MakeUninitialized(totalSize);
131 char* pixels = (char*) tmp->writable_data();
132
133 int numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
134
135 size_t offset = 0;
136
137 // Use a different color for each mipmap level so we can visually evaluate the draws
138 static const SkColor kColors[] = {
139 SK_ColorRED,
140 SK_ColorGREEN,
141 SK_ColorBLUE,
142 SK_ColorCYAN,
143 SK_ColorMAGENTA,
144 SK_ColorYELLOW,
145 SK_ColorWHITE,
146 };
147
148 SkISize levelDims = dimensions;
149 for (int i = 0; i < numMipLevels; ++i) {
150 size_t levelSize = SkCompressedDataSize(compression, levelDims, nullptr, false);
151
152 SkBitmap bm = render_level(levelDims, kColors[i%7], colorType, opaque);
153 if (compression == SkTextureCompressionType::kETC2_RGB8_UNORM) {
154 SkASSERT(bm.colorType() == kRGB_565_SkColorType);
155 SkASSERT(opaque);
156
157 if (etc1_encode_image((unsigned char*)bm.getAddr16(0, 0),
158 bm.width(), bm.height(), 2, bm.rowBytes(),
159 (unsigned char*) &pixels[offset])) {
160 return {nullptr, nullptr};
161 }
162 } else {
163 GrTwoColorBC1Compress(bm.pixmap(), kColors[i%7], &pixels[offset]);
164 }
165
166 offset += levelSize;
167 levelDims = {std::max(1, levelDims.width()/2), std::max(1, levelDims.height()/2)};
168 }
169
170 sk_sp<SkImage> image;
171 #if defined(SK_GRAPHITE)
172 skgpu::graphite::Recorder* recorder = canvas->recorder();
173 if (recorder) {
174 sk_sp<sk_gpu_test::ManagedGraphiteTexture> texture =
175 sk_gpu_test::ManagedGraphiteTexture::MakeFromCompressedData(recorder,
176 dimensions,
177 compression,
178 tmp,
179 skgpu::Mipmapped::kYes);
180 if (texture) {
181 image = SkImages::WrapTexture(recorder,
182 texture->texture(),
183 skgpu::CompressionTypeToSkColorType(compression),
184 kPremul_SkAlphaType,
185 /*colorSpace=*/nullptr);
186 if (image) {
187 return {image, texture};
188 }
189 }
190 }
191 #endif
192 auto dContext = GrAsDirectContext(canvas->recordingContext());
193 if (dContext) {
194 image = SkImages::TextureFromCompressedTextureData(dContext,
195 std::move(tmp),
196 dimensions.width(),
197 dimensions.height(),
198 compression,
199 skgpu::Mipmapped::kYes);
200 } else {
201 image = SkImages::RasterFromCompressedTextureData(
202 std::move(tmp), dimensions.width(), dimensions.height(), compression);
203 }
204 return {image, nullptr};
205 }
206
207 // Basic test of Ganesh's ETC1 and BC1 support
208 // The layout is:
209 // ETC2 BC1
210 // --------------------------------------
211 // RGB8 | kETC2_RGB8_UNORM | kBC1_RGB8_UNORM |
212 // |--------------------------------------|
213 // RGBA8 | | kBC1_RGBA8_UNORM |
214 // --------------------------------------
215 //
216 // The nonPowerOfTwo and nonMultipleOfFour cases exercise some compression edge cases.
217 class CompressedTexturesGM : public skiagm::GM {
218 public:
219 enum class Type {
220 kNormal,
221 kNonPowerOfTwo,
222 kNonMultipleOfFour
223 };
224
CompressedTexturesGM(Type type)225 CompressedTexturesGM(Type type) : fType(type) {
226 this->setBGColor(0xFFCCCCCC);
227
228 switch (fType) {
229 case Type::kNonPowerOfTwo:
230 // These dimensions force the top two mip levels to be 1x3 and 1x1
231 fImgDimensions.set(20, 60);
232 break;
233 case Type::kNonMultipleOfFour:
234 // These dimensions force the top three mip levels to be 1x7, 1x3 and 1x1
235 fImgDimensions.set(13, 61); // prime numbers - just bc
236 break;
237 default:
238 fImgDimensions.set(kBaseTexWidth, kBaseTexHeight);
239 break;
240 }
241
242 }
243
244 protected:
getName() const245 SkString getName() const override {
246 SkString name("compressed_textures");
247
248 if (fType == Type::kNonPowerOfTwo) {
249 name.append("_npot");
250 } else if (fType == Type::kNonMultipleOfFour) {
251 name.append("_nmof");
252 }
253
254 return name;
255 }
256
getISize()257 SkISize getISize() override {
258 return SkISize::Make(2*kCellWidth + 3*kPad, 2*kBaseTexHeight + 3*kPad);
259 }
260
onGpuSetup(SkCanvas * canvas,SkString * errorMsg,GraphiteTestContext * graphiteTestContext)261 DrawResult onGpuSetup(SkCanvas* canvas, SkString* errorMsg,
262 GraphiteTestContext* graphiteTestContext) override {
263 auto dContext = GrAsDirectContext(canvas->recordingContext());
264 if (dContext && dContext->abandoned()) {
265 // This isn't a GpuGM so a null 'context' is okay but an abandoned context
266 // if forbidden.
267 return DrawResult::kSkip;
268 }
269
270 if (dContext &&
271 dContext->backend() == GrBackendApi::kDirect3D && fType == Type::kNonMultipleOfFour) {
272 // skbug.com/10541 - Are non-multiple-of-four BC1 textures supported in D3D?
273 return DrawResult::kSkip;
274 }
275
276 fOpaqueETC2Image = make_compressed_image(canvas, fImgDimensions,
277 kRGB_565_SkColorType, true,
278 SkTextureCompressionType::kETC2_RGB8_UNORM);
279
280 fOpaqueBC1Image = make_compressed_image(canvas, fImgDimensions,
281 kRGBA_8888_SkColorType, true,
282 SkTextureCompressionType::kBC1_RGB8_UNORM);
283
284 fTransparentBC1Image = make_compressed_image(canvas, fImgDimensions,
285 kRGBA_8888_SkColorType, false,
286 SkTextureCompressionType::kBC1_RGBA8_UNORM);
287
288 if (!fOpaqueETC2Image.fImage || !fOpaqueBC1Image.fImage || !fTransparentBC1Image.fImage) {
289 *errorMsg = "Failed to create compressed images.";
290 return DrawResult::kFail;
291 }
292
293 return DrawResult::kOk;
294 }
295
onGpuTeardown()296 void onGpuTeardown() override {
297 fOpaqueETC2Image.fImage = nullptr;
298 fOpaqueBC1Image.fImage = nullptr;
299 fTransparentBC1Image.fImage = nullptr;
300 fOpaqueETC2Image.fGraphiteTexture = nullptr;
301 fOpaqueBC1Image.fGraphiteTexture = nullptr;
302 fTransparentBC1Image.fGraphiteTexture = nullptr;
303 }
304
onDraw(SkCanvas * canvas)305 void onDraw(SkCanvas* canvas) override {
306 this->drawCell(canvas, fOpaqueETC2Image.fImage.get(), { kPad, kPad });
307
308 this->drawCell(canvas, fOpaqueBC1Image.fImage.get(), { 2*kPad + kCellWidth, kPad });
309
310 this->drawCell(canvas, fTransparentBC1Image.fImage.get(),
311 { 2*kPad + kCellWidth, 2*kPad + kBaseTexHeight });
312 }
313
314 private:
drawCell(SkCanvas * canvas,SkImage * image,SkIVector offset)315 void drawCell(SkCanvas* canvas, SkImage* image, SkIVector offset) {
316
317 SkISize levelDimensions = fImgDimensions;
318 int numMipLevels = SkMipmap::ComputeLevelCount(levelDimensions.width(),
319 levelDimensions.height()) + 1;
320
321 SkSamplingOptions sampling(SkCubicResampler::Mitchell());
322
323 bool isCompressed = false;
324 if (image->isTextureBacked()) {
325 auto dContext = GrAsDirectContext(canvas->recordingContext());
326 if (dContext) {
327 const GrCaps* caps = as_IB(image)->context()->priv().caps();
328 GrTextureProxy* proxy = sk_gpu_test::GetTextureImageProxy(
329 image, canvas->recordingContext());
330 isCompressed = caps->isFormatCompressed(proxy->backendFormat());
331 } else {
332 // Graphite has no fallback to upload the compressed data to a non-compressed
333 // format. So if the image is texture backed and graphite then it will be a
334 // compressed format.
335 isCompressed = true;
336 }
337 }
338
339 SkPaint redStrokePaint;
340 redStrokePaint.setColor(SK_ColorRED);
341 redStrokePaint.setStyle(SkPaint::kStroke_Style);
342
343 for (int i = 0; i < numMipLevels; ++i) {
344 SkRect r = SkRect::MakeXYWH(offset.fX, offset.fY,
345 levelDimensions.width(), levelDimensions.height());
346
347 canvas->drawImageRect(image, r, sampling);
348 if (!isCompressed) {
349 // Make it obvious which drawImages used decompressed images
350 canvas->drawRect(r, redStrokePaint);
351 }
352
353 if (i == 0) {
354 offset.fX += levelDimensions.width()+1;
355 } else {
356 offset.fY += levelDimensions.height()+1;
357 }
358
359 levelDimensions = {std::max(1, levelDimensions.width()/2),
360 std::max(1, levelDimensions.height()/2)};
361 }
362 }
363
364 static const int kPad = 8;
365 static const int kBaseTexWidth = 64;
366 static const int kCellWidth = 1.5f * kBaseTexWidth;
367 static const int kBaseTexHeight = 64;
368
369 Type fType;
370 SkISize fImgDimensions;
371
372
373 CompressedImageObjects fOpaqueETC2Image;
374 CompressedImageObjects fOpaqueBC1Image;
375 CompressedImageObjects fTransparentBC1Image;
376
377 using INHERITED = GM;
378 };
379
380 //////////////////////////////////////////////////////////////////////////////
381
382 DEF_GM(return new CompressedTexturesGM(CompressedTexturesGM::Type::kNormal);)
383 DEF_GM(return new CompressedTexturesGM(CompressedTexturesGM::Type::kNonPowerOfTwo);)
384 DEF_GM(return new CompressedTexturesGM(CompressedTexturesGM::Type::kNonMultipleOfFour);)
385
386 #endif
387