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 18 static 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 29 static 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 */ 44 DEF_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 */ 78 DEF_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 */ 111 DEF_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 */ 202 DEF_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
