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