AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Bring LATC in line with other formats (i.e. write a blitter and

Browse Source 
an "optimized" compression routine).

R=robertphillips@google.com

Author: krajcevski@google.com

Review URL: https://codereview.chromium.org/429683003
This commit is contained in:
krajcevski 2014-07-30 08:34:51 -07:00 committed by Commit bot
parent ed6f03e5ed
commit b5294e8d45
3 changed files with 194 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/utils/SkTextureCompressor_ASTC.cpp
View File

@ -256,7 +256,7 @@ static void compress_a8_astc_block(uint8_t** dst, const uint8_t* src, int rowByt
send_packing(dst, SkEndian_SwapLE64(top), SkEndian_SwapLE64(bottom));
}
inline void compress_a8_astc_block_vertical(uint8_t* dst, const uint8_t* src) {
inline void CompressA8ASTCBlockVertical(uint8_t* dst, const uint8_t* src) {
compress_a8_astc_block<GetAlphaTranspose>(&dst, src, 12);
}
@ -270,8 +270,8 @@ bool CompressA8To12x12ASTC(uint8_t* dst, const uint8_t* src, int width, int heig
}
uint8_t** dstPtr = &dst;
for (int y = 0; y < height; y+=12) {
for (int x = 0; x < width; x+=12) {
for (int y = 0; y < height; y += 12) {
for (int x = 0; x < width; x += 12) {
compress_a8_astc_block<GetAlpha>(dstPtr, src + y*rowBytes + x, rowBytes);
}
}
@ -281,7 +281,7 @@ bool CompressA8To12x12ASTC(uint8_t* dst, const uint8_t* src, int width, int heig
SkBlitter* CreateASTCBlitter(int width, int height, void* outputBuffer) {
return new
SkTCompressedAlphaBlitter<12, 16, compress_a8_astc_block_vertical>
SkTCompressedAlphaBlitter<12, 16, CompressA8ASTCBlockVertical>
(width, height, outputBuffer);
}

127
src/utils/SkTextureCompressor_LATC.cpp
View File

@ -6,9 +6,19 @@
*/
#include "SkTextureCompressor_LATC.h"
#include "SkTextureCompressor_Blitter.h"
#include "SkEndian.h"
// Compression options. In general, the slow version is much more accurate, but
// much slower. The fast option is much faster, but much less accurate. YMMV.
#define COMPRESS_LATC_SLOW 0
#define COMPRESS_LATC_FAST 1
////////////////////////////////////////////////////////////////////////////////
#if COMPRESS_LATC_SLOW
////////////////////////////////////////////////////////////////////////////////
//
// Utility Functions
@ -278,17 +288,134 @@ static uint64_t compress_latc_block(const uint8_t pixels[]) {
}
}
#endif // COMPRESS_LATC_SLOW
////////////////////////////////////////////////////////////////////////////////
#if COMPRESS_LATC_FAST
// Take the top three indices of each int and pack them into the low 12
// bits of the integer.
static inline uint32_t convert_index(uint32_t x) {
// Since the palette is
// 255, 0, 219, 182, 146, 109, 73, 36
// we need to map the high three bits of each byte in the integer
// from
// 0 1 2 3 4 5 6 7
// to
// 1 7 6 5 4 3 2 0
//
// This first operation takes the mapping from
// 0 1 2 3 4 5 6 7 --> 7 6 5 4 3 2 1 0
x = 0x07070707 - ((x >> 5) & 0x07070707);
// mask is 1 if index is non-zero
const uint32_t mask = (x | (x >> 1) | (x >> 2)) & 0x01010101;
// add mask:
// 7 6 5 4 3 2 1 0 --> 8 7 6 5 4 3 2 0
x = (x + mask);
// Handle overflow:
// 8 7 6 5 4 3 2 0 --> 9 7 6 5 4 3 2 0
x |= (x >> 3) & 0x01010101;
// Mask out high bits:
// 9 7 6 5 4 3 2 0 --> 1 7 6 5 4 3 2 0
x &= 0x07070707;
// Pack it in...
#if defined (SK_CPU_BENDIAN)
return
(x >> 24) |
((x >> 13) & 0x38) |
((x >> 2) & 0x1C0) |
((x << 9) & 0xE00);
#else
return
(x & 0x7) |
((x >> 5) & 0x38) |
((x >> 10) & 0x1C0) |
((x >> 15) & 0xE00);
#endif
}
typedef uint64_t (*PackIndicesProc)(const uint8_t* alpha, int rowBytes);
template<PackIndicesProc packIndicesProc>
static void compress_a8_latc_block(uint8_t** dstPtr, const uint8_t* src, int rowBytes) {
*(reinterpret_cast<uint64_t*>(*dstPtr)) =
SkEndian_SwapLE64(0xFF | (packIndicesProc(src, rowBytes) << 16));
*dstPtr += 8;
}
inline uint64_t PackRowMajor(const uint8_t *indices, int rowBytes) {
uint64_t result = 0;
for (int i = 0; i < 4; ++i) {
const uint32_t idx = *(reinterpret_cast<const uint32_t*>(indices + i*rowBytes));
result |= static_cast<uint64_t>(convert_index(idx)) << 12*i;
}
return result;
}
inline uint64_t PackColumnMajor(const uint8_t *indices, int rowBytes) {
// !SPEED! Blarg, this is kind of annoying. SSE4 can make this
// a LOT faster.
uint8_t transposed[16];
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
transposed[j*4+i] = indices[i*rowBytes + j];
}
}
return PackRowMajor(transposed, 4);
}
static bool compress_4x4_a8_latc(uint8_t* dst, const uint8_t* src,
int width, int height, int rowBytes) {
if (width < 0 || ((width % 4) != 0) || height < 0 || ((height % 4) != 0)) {
return false;
}
uint8_t** dstPtr = &dst;
for (int y = 0; y < height; y += 4) {
for (int x = 0; x < width; x += 4) {
compress_a8_latc_block<PackRowMajor>(dstPtr, src + y*rowBytes + x, rowBytes);
}
}
return true;
}
void CompressA8LATCBlockVertical(uint8_t* dst, const uint8_t block[]) {
compress_a8_latc_block<PackColumnMajor>(&dst, block, 4);
}
#endif // COMPRESS_LATC_FAST
////////////////////////////////////////////////////////////////////////////////
namespace SkTextureCompressor {
bool CompressA8ToLATC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) {
#if COMPRESS_LATC_FAST
return compress_4x4_a8_latc(dst, src, width, height, rowBytes);
#elif COMPRESS_LATC_SLOW
return compress_4x4_a8_to_64bit(dst, src, width, height, rowBytes, compress_latc_block);
#else
#error "Must choose either fast or slow LATC compression"
#endif
}
SkBlitter* CreateLATCBlitter(int width, int height, void* outputBuffer) {
#if COMPRESS_LATC_FAST
return new
SkTCompressedAlphaBlitter<4, 8, CompressA8LATCBlockVertical>
(width, height, outputBuffer);
#elif COMPRESS_LATC_SLOW
// TODO (krajcevski)
return NULL;
#endif
}
} // SkTextureCompressor

97
tests/TextureCompressionTest.cpp
View File

@ -12,19 +12,22 @@
#include "SkTextureCompressor.h"
#include "Test.h"
static const int kLATCBlockDimension = 4;
static const int kLATCEncodedBlockSize = 8;
/**
* Make sure that we properly fail when we don't have multiple of four image dimensions.
*/
DEF_TEST(CompressLATCFailDimensions, reporter) {
DEF_TEST(CompressAlphaFailDimensions, reporter) {
SkBitmap bitmap;
static const int kWidth = 63;
static const int kHeight = 63;
static const int kWidth = 17;
static const int kHeight = 17;
SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight);
REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension != 0);
REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension != 0);
// R11_EAC and LATC are both dimensions of 4, so we need to make sure that we
// are violating those assumptions. And if we are, then we're also violating the
// assumptions of ASTC, which is 12x12 since any number not divisible by 4 is
// also not divisible by 12. Our dimensions are prime, so any block dimension
// larger than 1 should fail.
REPORTER_ASSERT(reporter, kWidth % 4 != 0);
REPORTER_ASSERT(reporter, kHeight % 4 != 0);
bool setInfoSuccess = bitmap.setInfo(info);
REPORTER_ASSERT(reporter, setInfoSuccess);
@ -32,23 +35,30 @@ DEF_TEST(CompressLATCFailDimensions, reporter) {
bool allocPixelsSuccess = bitmap.allocPixels(info);
REPORTER_ASSERT(reporter, allocPixelsSuccess);
bitmap.unlockPixels();
const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
SkAutoDataUnref latcData(SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
REPORTER_ASSERT(reporter, NULL == latcData);
for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
REPORTER_ASSERT(reporter, NULL == data);
}
}
/**
* Make sure that we properly fail when we don't have the correct bitmap type.
* LATC compressed textures can only be created from A8 bitmaps.
* compressed textures can (currently) only be created from A8 bitmaps.
*/
DEF_TEST(CompressLATCFailColorType, reporter) {
DEF_TEST(CompressAlphaFailColorType, reporter) {
SkBitmap bitmap;
static const int kWidth = 64;
static const int kHeight = 64;
static const int kWidth = 12;
static const int kHeight = 12;
SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension == 0);
REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension == 0);
// ASTC is at most 12x12, and any dimension divisible by 12 is also divisible
// by 4, which is the dimensions of R11_EAC and LATC. In the future, we might
// support additional variants of ASTC, such as 5x6 and 8x8, in which case this would
// need to be updated.
REPORTER_ASSERT(reporter, kWidth % 12 == 0);
REPORTER_ASSERT(reporter, kHeight % 12 == 0);
bool setInfoSuccess = bitmap.setInfo(info);
REPORTER_ASSERT(reporter, setInfoSuccess);
@ -57,15 +67,21 @@ DEF_TEST(CompressLATCFailColorType, reporter) {
REPORTER_ASSERT(reporter, allocPixelsSuccess);
bitmap.unlockPixels();
const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
SkAutoDataUnref latcData(SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
REPORTER_ASSERT(reporter, NULL == latcData);
for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
REPORTER_ASSERT(reporter, NULL == data);
}
}
/**
* Make sure that if we pass in a solid color bitmap that we get the appropriate results
*/
DEF_TEST(CompressLATC, reporter) {
const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
static const int kLATCEncodedBlockSize = 8;
SkBitmap bitmap;
static const int kWidth = 8;
static const int kHeight = 8;
@ -78,10 +94,15 @@ DEF_TEST(CompressLATC, reporter) {
REPORTER_ASSERT(reporter, allocPixelsSuccess);
bitmap.unlockPixels();
REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension == 0);
REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension == 0);
const int numBlocks = (kWidth / kLATCBlockDimension) * (kHeight / kLATCBlockDimension);
const size_t kSizeToBe = static_cast<size_t>(kLATCEncodedBlockSize * numBlocks);
int latcDimX, latcDimY;
SkTextureCompressor::GetBlockDimensions(kLATCFormat, &latcDimX, &latcDimY);
REPORTER_ASSERT(reporter, kWidth % latcDimX == 0);
REPORTER_ASSERT(reporter, kHeight % latcDimY == 0);
const size_t kSizeToBe =
SkTextureCompressor::GetCompressedDataSize(kLATCFormat, kWidth, kHeight);
REPORTER_ASSERT(reporter, kSizeToBe == ((kWidth*kHeight*kLATCEncodedBlockSize)/16));
REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0);
for (int lum = 0; lum < 256; ++lum) {
bitmap.lockPixels();
@ -93,21 +114,29 @@ DEF_TEST(CompressLATC, reporter) {
}
bitmap.unlockPixels();
const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
SkAutoDataUnref latcData(
SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
REPORTER_ASSERT(reporter, NULL != latcData);
REPORTER_ASSERT(reporter, kSizeToBe == latcData->size());
// Make sure that it all matches a given block encoding. If the entire bitmap
// is a single value, then the lower two bytes of the encoded data should be that
// value. The remaining indices can be any value, and since we try to match the pixels
// in the chosen palette in increasing index order, each one should be zero. Hence,
// the correct encoding should be just the two luminance values in the bottom two
// bytes of the block encoding.
const uint64_t kConstColorEncoding = SkEndian_SwapLE64(lum | (lum << 8));
// Make sure that it all matches a given block encoding. Since we have
// COMPRESS_LATC_FAST defined in SkTextureCompressor_LATC.cpp, we are using
// an approximation scheme that optimizes for speed against coverage maps.
// That means that each palette in the encoded block is exactly the same,
// and that the three bits saved per pixel are computed from the top three
// bits of the luminance value.
const uint64_t kIndexEncodingMap[8] = { 1, 7, 6, 5, 4, 3, 2, 0 };
const uint64_t kIndex = kIndexEncodingMap[lum >> 5];
const uint64_t kConstColorEncoding =
SkEndian_SwapLE64(
255 |
(kIndex << 16) | (kIndex << 19) | (kIndex << 22) | (kIndex << 25) |
(kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
(kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
(kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
for (int i = 0; i < numBlocks; ++i) {
for (size_t i = 0; i < (kSizeToBe/8); ++i) {
REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
}
}