1 /*
2  * Copyright 2014 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 "SkBitmap.h"
9 #include "SkData.h"
10 #include "SkEndian.h"
11 #include "SkImageInfo.h"
12 #include "SkTemplates.h"
13 #include "SkTextureCompressor.h"
14 #include "Test.h"
15 
16 // TODO: Create separate tests for RGB and RGBA data once
17 // ASTC and ETC1 decompression is implemented.
18 
decompresses_a8(SkTextureCompressor::Format fmt)19 static bool decompresses_a8(SkTextureCompressor::Format fmt) {
20     switch (fmt) {
21         case SkTextureCompressor::kLATC_Format:
22         case SkTextureCompressor::kR11_EAC_Format:
23             return true;
24 
25         default:
26             return false;
27     }
28 }
29 
compresses_a8(SkTextureCompressor::Format fmt)30 static bool compresses_a8(SkTextureCompressor::Format fmt) {
31     switch (fmt) {
32         case SkTextureCompressor::kLATC_Format:
33         case SkTextureCompressor::kR11_EAC_Format:
34         case SkTextureCompressor::kASTC_12x12_Format:
35             return true;
36 
37         default:
38             return false;
39     }
40 }
41 
42 /**
43  * Make sure that we properly fail when we don't have multiple of four image dimensions.
44  */
DEF_TEST(CompressAlphaFailDimensions,reporter)45 DEF_TEST(CompressAlphaFailDimensions, reporter) {
46     static const int kWidth = 17;
47     static const int kHeight = 17;
48 
49     // R11_EAC and LATC are both dimensions of 4, so we need to make sure that we
50     // are violating those assumptions. And if we are, then we're also violating the
51     // assumptions of ASTC, which is 12x12 since any number not divisible by 4 is
52     // also not divisible by 12. Our dimensions are prime, so any block dimension
53     // larger than 1 should fail.
54     REPORTER_ASSERT(reporter, kWidth % 4 != 0);
55     REPORTER_ASSERT(reporter, kHeight % 4 != 0);
56 
57     SkAutoPixmapStorage pixmap;
58     pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight));
59     // leaving the pixels uninitialized, as they don't affect the test...
60 
61     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
62         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
63         if (!compresses_a8(fmt)) {
64             continue;
65         }
66         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
67         REPORTER_ASSERT(reporter, nullptr == data);
68     }
69 }
70 
71 /**
72  * Make sure that we properly fail when we don't have the correct bitmap type.
73  * compressed textures can (currently) only be created from A8 bitmaps.
74  */
DEF_TEST(CompressAlphaFailColorType,reporter)75 DEF_TEST(CompressAlphaFailColorType, reporter) {
76     static const int kWidth = 12;
77     static const int kHeight = 12;
78 
79     // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible
80     // by 4, which is the dimensions of R11_EAC and LATC. In the future, we might
81     // support additional variants of ASTC, such as 5x6 and 8x8, in which case this would
82     // need to be updated.
83     REPORTER_ASSERT(reporter, kWidth % 12 == 0);
84     REPORTER_ASSERT(reporter, kHeight % 12 == 0);
85 
86     SkAutoPixmapStorage pixmap;
87     pixmap.alloc(SkImageInfo::MakeN32Premul(kWidth, kHeight));
88     // leaving the pixels uninitialized, as they don't affect the test...
89 
90     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
91         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
92         if (!compresses_a8(fmt)) {
93             continue;
94         }
95         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
96         REPORTER_ASSERT(reporter, nullptr == data);
97     }
98 }
99 
100 /**
101  * Make sure that if you compress a texture with alternating black/white pixels, and
102  * then decompress it, you get what you started with.
103  */
DEF_TEST(CompressCheckerboard,reporter)104 DEF_TEST(CompressCheckerboard, reporter) {
105     static const int kWidth = 48;  // We need the number to be divisible by both
106     static const int kHeight = 48; // 12 (ASTC) and 16 (ARM NEON R11 EAC).
107 
108     // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible
109     // by 4, which is the dimensions of R11_EAC and LATC. In the future, we might
110     // support additional variants of ASTC, such as 5x6 and 8x8, in which case this would
111     // need to be updated. Additionally, ARM NEON and SSE code paths support up to
112     // four blocks of R11 EAC at once, so they operate on 16-wide blocks. Hence, the
113     // valid width and height is going to be the LCM of 12 and 16 which is 4*4*3 = 48
114     REPORTER_ASSERT(reporter, kWidth % 48 == 0);
115     REPORTER_ASSERT(reporter, kHeight % 48 == 0);
116 
117     SkAutoPixmapStorage pixmap;
118     pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight));
119 
120     // Populate the pixels
121     {
122         uint8_t* pixels = reinterpret_cast<uint8_t*>(pixmap.writable_addr());
123         REPORTER_ASSERT(reporter, pixels);
124         if (nullptr == pixels) {
125             return;
126         }
127 
128         for (int y = 0; y < kHeight; ++y) {
129             for (int x = 0; x < kWidth; ++x) {
130                 if ((x ^ y) & 1) {
131                     pixels[x] = 0xFF;
132                 } else {
133                     pixels[x] = 0;
134                 }
135             }
136             pixels += pixmap.rowBytes();
137         }
138     }
139 
140     SkAutoTMalloc<uint8_t> decompMemory(kWidth*kHeight);
141     uint8_t* decompBuffer = decompMemory.get();
142     REPORTER_ASSERT(reporter, decompBuffer);
143     if (nullptr == decompBuffer) {
144         return;
145     }
146 
147     for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
148         const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
149 
150         // Ignore formats for RGBA data, since the decompressed buffer
151         // won't match the size and contents of the original.
152         if (!decompresses_a8(fmt) || !compresses_a8(fmt)) {
153             continue;
154         }
155 
156         SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
157         REPORTER_ASSERT(reporter, data);
158         if (nullptr == data) {
159             continue;
160         }
161 
162         bool decompResult =
163             SkTextureCompressor::DecompressBufferFromFormat(
164                 decompBuffer, kWidth,
165                 data->bytes(),
166                 kWidth, kHeight, fmt);
167         REPORTER_ASSERT(reporter, decompResult);
168 
169         const uint8_t* pixels = reinterpret_cast<const uint8_t*>(pixmap.addr());
170         REPORTER_ASSERT(reporter, pixels);
171         if (nullptr == pixels) {
172             continue;
173         }
174 
175         for (int y = 0; y < kHeight; ++y) {
176             for (int x = 0; x < kWidth; ++x) {
177                 bool ok = pixels[y*pixmap.rowBytes() + x] == decompBuffer[y*kWidth + x];
178                 REPORTER_ASSERT(reporter, ok);
179             }
180         }
181     }
182 }
183 
184 /**
185  * Make sure that if we pass in a solid color bitmap that we get the appropriate results
186  */
DEF_TEST(CompressLATC,reporter)187 DEF_TEST(CompressLATC, reporter) {
188 
189     const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
190     static const int kLATCEncodedBlockSize = 8;
191 
192     static const int kWidth = 8;
193     static const int kHeight = 8;
194 
195     SkAutoPixmapStorage pixmap;
196     pixmap.alloc(SkImageInfo::MakeA8(kWidth, kHeight));
197 
198     int latcDimX, latcDimY;
199     SkTextureCompressor::GetBlockDimensions(kLATCFormat, &latcDimX, &latcDimY);
200 
201     REPORTER_ASSERT(reporter, kWidth % latcDimX == 0);
202     REPORTER_ASSERT(reporter, kHeight % latcDimY == 0);
203     const size_t kSizeToBe =
204         SkTextureCompressor::GetCompressedDataSize(kLATCFormat, kWidth, kHeight);
205     REPORTER_ASSERT(reporter, kSizeToBe == ((kWidth*kHeight*kLATCEncodedBlockSize)/16));
206     REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0);
207 
208     for (int lum = 0; lum < 256; ++lum) {
209         uint8_t* pixels = reinterpret_cast<uint8_t*>(pixmap.writable_addr());
210         for (int i = 0; i < kWidth*kHeight; ++i) {
211             pixels[i] = lum;
212         }
213 
214         SkAutoDataUnref latcData(
215             SkTextureCompressor::CompressBitmapToFormat(pixmap, kLATCFormat));
216         REPORTER_ASSERT(reporter, latcData);
217         if (nullptr == latcData) {
218             continue;
219         }
220 
221         REPORTER_ASSERT(reporter, kSizeToBe == latcData->size());
222 
223         // Make sure that it all matches a given block encoding. Since we have
224         // COMPRESS_LATC_FAST defined in SkTextureCompressor_LATC.cpp, we are using
225         // an approximation scheme that optimizes for speed against coverage maps.
226         // That means that each palette in the encoded block is exactly the same,
227         // and that the three bits saved per pixel are computed from the top three
228         // bits of the luminance value.
229         const uint64_t kIndexEncodingMap[8] = { 1, 7, 6, 5, 4, 3, 2, 0 };
230 
231         // Quantize to three bits in the same way that we do our LATC compression:
232         // 1. Divide by two
233         // 2. Add 9
234         // 3. Divide by two
235         // 4. Approximate division by three twice
236         uint32_t quant = static_cast<uint32_t>(lum);
237         quant >>= 1; // 1
238         quant += 9;  // 2
239         quant >>= 1; // 3
240 
241         uint32_t a, b, c, ar, br, cr;
242 
243         // First division by three
244         a = quant >> 2;
245         ar = (quant & 0x3) << 4;
246         b = quant >> 4;
247         br = (quant & 0xF) << 2;
248         c = quant >> 6;
249         cr = (quant & 0x3F);
250         quant = (a + b + c) + ((ar + br + cr) >> 6);
251 
252         // Second division by three
253         a = quant >> 2;
254         ar = (quant & 0x3) << 4;
255         b = quant >> 4;
256         br = (quant & 0xF) << 2;
257         c = quant >> 6;
258         cr = (quant & 0x3F);
259         quant = (a + b + c) + ((ar + br + cr) >> 6);
260 
261         const uint64_t kIndex = kIndexEncodingMap[quant];
262 
263         const uint64_t kConstColorEncoding =
264             SkEndian_SwapLE64(
265                 255 |
266                 (kIndex << 16) | (kIndex << 19) | (kIndex << 22) | (kIndex << 25) |
267                 (kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
268                 (kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
269                 (kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
270 
271         const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
272         for (size_t i = 0; i < (kSizeToBe/8); ++i) {
273             REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
274         }
275     }
276 }
277