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