From b2ef181ed614d1a5772367a8cd7ab77aa015ae29 Mon Sep 17 00:00:00 2001 From: krajcevski Date: Fri, 25 Jul 2014 07:33:01 -0700 Subject: [PATCH] Add preliminary ASTC encoder R=robertphillips@google.com Author: krajcevski@google.com Review URL: https://codereview.chromium.org/417933005 --- gyp/utils.gypi | 2 + src/utils/SkTextureCompressor.cpp | 39 ++-- src/utils/SkTextureCompressor.h | 7 +- src/utils/SkTextureCompressor_ASTC.cpp | 271 +++++++++++++++++++++++++ src/utils/SkTextureCompressor_ASTC.h | 24 +++ 5 files changed, 326 insertions(+), 17 deletions(-) create mode 100644 src/utils/SkTextureCompressor_ASTC.cpp create mode 100644 src/utils/SkTextureCompressor_ASTC.h diff --git a/gyp/utils.gypi b/gyp/utils.gypi index 9efa28005b..c90dbc530a 100644 --- a/gyp/utils.gypi +++ b/gyp/utils.gypi @@ -85,6 +85,8 @@ '<(skia_src_path)/utils/SkRTConf.cpp', '<(skia_src_path)/utils/SkTextureCompressor.cpp', '<(skia_src_path)/utils/SkTextureCompressor.h', + '<(skia_src_path)/utils/SkTextureCompressor_ASTC.cpp', + '<(skia_src_path)/utils/SkTextureCompressor_ASTC.h', '<(skia_src_path)/utils/SkTextureCompressor_R11EAC.cpp', '<(skia_src_path)/utils/SkTextureCompressor_R11EAC.h', '<(skia_src_path)/utils/SkTextureCompressor_LATC.cpp', diff --git a/src/utils/SkTextureCompressor.cpp b/src/utils/SkTextureCompressor.cpp index 453d98912d..40c0d3e5e8 100644 --- a/src/utils/SkTextureCompressor.cpp +++ b/src/utils/SkTextureCompressor.cpp @@ -6,8 +6,9 @@ */ #include "SkTextureCompressor.h" -#include "SkTextureCompressor_R11EAC.h" +#include "SkTextureCompressor_ASTC.h" #include "SkTextureCompressor_LATC.h" +#include "SkTextureCompressor_R11EAC.h" #include "SkBitmap.h" #include "SkData.h" @@ -20,29 +21,36 @@ namespace SkTextureCompressor { int GetCompressedDataSize(Format fmt, int width, int height) { + int blockDimension = 0; + int encodedBlockSize = 0; + switch (fmt) { // These formats are 64 bits per 4x4 block. case kR11_EAC_Format: case kLATC_Format: - { - static const int kBlockDimension = 4; - static const int kEncodedBlockSize = 8; + blockDimension = 4; + encodedBlockSize = 8; + break; - if(((width % kBlockDimension) == 0) && ((height % kBlockDimension) == 0)) { - - const int blocksX = width / kBlockDimension; - const int blocksY = height / kBlockDimension; - - return blocksX * blocksY * kEncodedBlockSize; - } - - return -1; - } + // This format is 12x12 blocks to 128 bits. + case kASTC_12x12_Format: + blockDimension = 12; + encodedBlockSize = 16; + break; default: SkFAIL("Unknown compressed format!"); return -1; } + + if(((width % blockDimension) == 0) && ((height % blockDimension) == 0)) { + const int blocksX = width / blockDimension; + const int blocksY = height / blockDimension; + + return blocksX * blocksY * encodedBlockSize; + } + + return -1; } bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType, @@ -63,6 +71,9 @@ bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcCol case kR11_EAC_Format: proc = CompressA8ToR11EAC; break; + case kASTC_12x12_Format: + proc = CompressA8To12x12ASTC; + break; default: // Do nothing... break; diff --git a/src/utils/SkTextureCompressor.h b/src/utils/SkTextureCompressor.h index a7afe0384b..5238ba221b 100644 --- a/src/utils/SkTextureCompressor.h +++ b/src/utils/SkTextureCompressor.h @@ -18,10 +18,11 @@ namespace SkTextureCompressor { // Various texture compression formats that we support. enum Format { // Alpha only formats. - kLATC_Format, // 4x4 blocks, compresses A8 - kR11_EAC_Format, // 4x4 blocks, compresses A8 + kLATC_Format, // 4x4 blocks, compresses A8 + kR11_EAC_Format, // 4x4 blocks, compresses A8 + kASTC_12x12_Format, // 12x12 blocks, compresses A8 - kLast_Format = kR11_EAC_Format + kLast_Format = kASTC_12x12_Format }; static const int kFormatCnt = kLast_Format + 1; diff --git a/src/utils/SkTextureCompressor_ASTC.cpp b/src/utils/SkTextureCompressor_ASTC.cpp new file mode 100644 index 0000000000..543ff57ddb --- /dev/null +++ b/src/utils/SkTextureCompressor_ASTC.cpp @@ -0,0 +1,271 @@ +/* + * Copyright 2014 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "SkTextureCompressor_ASTC.h" + +#include "SkBlitter.h" +#include "SkEndian.h" + +// This table contains the weight values for each texel. This is used in determining +// how to convert a 12x12 grid of alpha values into a 6x5 grid of index values. Since +// we have a 6x5 grid, that gives 30 values that we have to compute. For each index, +// we store up to 20 different triplets of values. In order the triplets are: +// weight, texel-x, texel-y +// The weight value corresponds to the amount that this index contributes to the final +// index value of the given texel. Hence, we need to reconstruct the 6x5 index grid +// from their relative contribution to the 12x12 texel grid. +// +// The algorithm is something like this: +// foreach index i: +// total-weight = 0; +// total-alpha = 0; +// for w = 1 to 20: +// weight = table[i][w*3]; +// texel-x = table[i][w*3 + 1]; +// texel-y = table[i][w*3 + 2]; +// if weight >= 0: +// total-weight += weight; +// total-alpha += weight * alphas[texel-x][texel-y]; +// +// total-alpha /= total-weight; +// index = top three bits of total-alpha +// +// If the associated index does not contribute to 20 different texels (e.g. it's in +// a corner), then the extra texels are stored with -1's in the table. + +static const int k6x5To12x12Table[30][60] = { +{ 16, 0, 0, 9, 1, 0, 1, 2, 0, 10, 0, 1, 6, 1, 1, 1, 2, 1, 4, 0, 2, 2, + 1, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 7, 1, 0, 15, 2, 0, 10, 3, 0, 3, 4, 0, 4, 1, 1, 9, 2, 1, 6, 3, 1, 2, + 4, 1, 2, 1, 2, 4, 2, 2, 3, 3, 2, 1, 4, 2, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 6, 3, 0, 13, 4, 0, 12, 5, 0, 4, 6, 0, 4, 3, 1, 8, 4, 1, 8, 5, 1, 3, + 6, 1, 1, 3, 2, 3, 4, 2, 3, 5, 2, 1, 6, 2, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 4, 5, 0, 12, 6, 0, 13, 7, 0, 6, 8, 0, 2, 5, 1, 7, 6, 1, 8, 7, 1, 4, + 8, 1, 1, 5, 2, 3, 6, 2, 3, 7, 2, 2, 8, 2, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 3, 7, 0, 10, 8, 0, 15, 9, 0, 7, 10, 0, 2, 7, 1, 6, 8, 1, 9, 9, 1, 4, + 10, 1, 1, 7, 2, 2, 8, 2, 4, 9, 2, 2, 10, 2, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 9, 0, 9, 10, 0, 16, 11, 0, 1, 9, 1, 6, 10, 1, 10, 11, 1, 2, 10, 2, 4, + 11, 2, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 6, 0, 1, 3, 1, 1, 12, 0, 2, 7, 1, 2, 1, 2, 2, 15, 0, 3, 8, 1, 3, 1, + 2, 3, 9, 0, 4, 5, 1, 4, 1, 2, 4, 3, 0, 5, 2, 1, 5, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 3, 1, 1, 6, 2, 1, 4, 3, 1, 1, 4, 1, 5, 1, 2, 11, 2, 2, 7, 3, 2, 2, + 4, 2, 7, 1, 3, 14, 2, 3, 9, 3, 3, 3, 4, 3, 4, 1, 4, 8, 2, 4, 6, 3, + 4, 2, 4, 4, 1, 1, 5, 3, 2, 5, 2, 3, 5, 1, 4, 5}, // n = 20 +{ 2, 3, 1, 5, 4, 1, 4, 5, 1, 1, 6, 1, 5, 3, 2, 10, 4, 2, 9, 5, 2, 3, + 6, 2, 6, 3, 3, 12, 4, 3, 11, 5, 3, 4, 6, 3, 3, 3, 4, 7, 4, 4, 7, 5, + 4, 2, 6, 4, 1, 3, 5, 2, 4, 5, 2, 5, 5, 1, 6, 5}, // n = 20 +{ 2, 5, 1, 5, 6, 1, 5, 7, 1, 2, 8, 1, 3, 5, 2, 9, 6, 2, 10, 7, 2, 4, + 8, 2, 4, 5, 3, 11, 6, 3, 12, 7, 3, 6, 8, 3, 2, 5, 4, 7, 6, 4, 7, 7, + 4, 3, 8, 4, 1, 5, 5, 2, 6, 5, 2, 7, 5, 1, 8, 5}, // n = 20 +{ 1, 7, 1, 4, 8, 1, 6, 9, 1, 3, 10, 1, 2, 7, 2, 8, 8, 2, 11, 9, 2, 5, + 10, 2, 3, 7, 3, 9, 8, 3, 14, 9, 3, 7, 10, 3, 2, 7, 4, 6, 8, 4, 8, 9, + 4, 4, 10, 4, 1, 7, 5, 2, 8, 5, 3, 9, 5, 1, 10, 5}, // n = 20 +{ 3, 10, 1, 6, 11, 1, 1, 9, 2, 7, 10, 2, 12, 11, 2, 1, 9, 3, 8, 10, 3, 15, + 11, 3, 1, 9, 4, 5, 10, 4, 9, 11, 4, 2, 10, 5, 3, 11, 5, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 0, 3, 1, 1, 3, 7, 0, 4, 4, 1, 4, 13, 0, 5, 7, 1, 5, 1, 2, 5, 13, + 0, 6, 7, 1, 6, 1, 2, 6, 7, 0, 7, 4, 1, 7, 1, 0, 8, 1, 1, 8, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 2, 3, 1, 3, 3, 3, 1, 4, 7, 2, 4, 4, 3, 4, 1, 4, 4, 6, 1, 5, 12, + 2, 5, 8, 3, 5, 2, 4, 5, 6, 1, 6, 12, 2, 6, 8, 3, 6, 2, 4, 6, 3, 1, + 7, 7, 2, 7, 4, 3, 7, 1, 4, 7, 1, 2, 8, 1, 3, 8}, // n = 20 +{ 1, 4, 3, 1, 5, 3, 3, 3, 4, 6, 4, 4, 5, 5, 4, 2, 6, 4, 5, 3, 5, 11, + 4, 5, 10, 5, 5, 3, 6, 5, 5, 3, 6, 11, 4, 6, 10, 5, 6, 3, 6, 6, 3, 3, + 7, 6, 4, 7, 5, 5, 7, 2, 6, 7, 1, 4, 8, 1, 5, 8}, // n = 20 +{ 1, 6, 3, 1, 7, 3, 2, 5, 4, 5, 6, 4, 6, 7, 4, 3, 8, 4, 3, 5, 5, 10, + 6, 5, 11, 7, 5, 5, 8, 5, 3, 5, 6, 10, 6, 6, 11, 7, 6, 5, 8, 6, 2, 5, + 7, 5, 6, 7, 6, 7, 7, 3, 8, 7, 1, 6, 8, 1, 7, 8}, // n = 20 +{ 1, 8, 3, 1, 9, 3, 1, 7, 4, 4, 8, 4, 7, 9, 4, 3, 10, 4, 2, 7, 5, 8, + 8, 5, 12, 9, 5, 6, 10, 5, 2, 7, 6, 8, 8, 6, 12, 9, 6, 6, 10, 6, 1, 7, + 7, 4, 8, 7, 7, 9, 7, 3, 10, 7, 1, 8, 8, 1, 9, 8}, // n = 20 +{ 1, 10, 3, 1, 11, 3, 4, 10, 4, 7, 11, 4, 1, 9, 5, 7, 10, 5, 13, 11, 5, 1, + 9, 6, 7, 10, 6, 13, 11, 6, 4, 10, 7, 7, 11, 7, 1, 10, 8, 1, 11, 8, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 3, 0, 6, 2, 1, 6, 9, 0, 7, 5, 1, 7, 1, 2, 7, 15, 0, 8, 8, 1, 8, 1, + 2, 8, 12, 0, 9, 7, 1, 9, 1, 2, 9, 6, 0, 10, 3, 1, 10, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 1, 6, 3, 2, 6, 2, 3, 6, 1, 4, 6, 4, 1, 7, 8, 2, 7, 6, 3, 7, 2, + 4, 7, 7, 1, 8, 14, 2, 8, 9, 3, 8, 3, 4, 8, 5, 1, 9, 11, 2, 9, 8, 3, + 9, 2, 4, 9, 3, 1, 10, 6, 2, 10, 4, 3, 10, 1, 4, 10}, // n = 20 +{ 1, 3, 6, 2, 4, 6, 2, 5, 6, 1, 6, 6, 3, 3, 7, 7, 4, 7, 7, 5, 7, 2, + 6, 7, 6, 3, 8, 12, 4, 8, 11, 5, 8, 4, 6, 8, 4, 3, 9, 10, 4, 9, 9, 5, + 9, 3, 6, 9, 2, 3, 10, 5, 4, 10, 5, 5, 10, 2, 6, 10}, // n = 20 +{ 1, 5, 6, 2, 6, 6, 2, 7, 6, 1, 8, 6, 2, 5, 7, 7, 6, 7, 7, 7, 7, 3, + 8, 7, 4, 5, 8, 11, 6, 8, 12, 7, 8, 6, 8, 8, 3, 5, 9, 9, 6, 9, 10, 7, + 9, 5, 8, 9, 1, 5, 10, 4, 6, 10, 5, 7, 10, 2, 8, 10}, // n = 20 +{ 1, 7, 6, 2, 8, 6, 3, 9, 6, 1, 10, 6, 2, 7, 7, 6, 8, 7, 8, 9, 7, 4, + 10, 7, 3, 7, 8, 9, 8, 8, 14, 9, 8, 7, 10, 8, 2, 7, 9, 7, 8, 9, 11, 9, + 9, 5, 10, 9, 1, 7, 10, 4, 8, 10, 6, 9, 10, 3, 10, 10}, // n = 20 +{ 2, 10, 6, 3, 11, 6, 1, 9, 7, 5, 10, 7, 9, 11, 7, 1, 9, 8, 8, 10, 8, 15, + 11, 8, 1, 9, 9, 7, 10, 9, 12, 11, 9, 3, 10, 10, 6, 11, 10, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 4, 0, 9, 2, 1, 9, 10, 0, 10, 6, 1, 10, 1, 2, 10, 16, 0, 11, 9, 1, 11, 1, + 2, 11, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 2, 1, 9, 4, 2, 9, 2, 3, 9, 1, 4, 9, 4, 1, 10, 9, 2, 10, 6, 3, 10, 2, + 4, 10, 7, 1, 11, 15, 2, 11, 10, 3, 11, 3, 4, 11, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 2, 3, 9, 3, 4, 9, 3, 5, 9, 1, 6, 9, 4, 3, 10, 8, 4, 10, 7, 5, 10, 2, + 6, 10, 6, 3, 11, 13, 4, 11, 12, 5, 11, 4, 6, 11, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 5, 9, 3, 6, 9, 3, 7, 9, 1, 8, 9, 3, 5, 10, 8, 6, 10, 8, 7, 10, 4, + 8, 10, 4, 5, 11, 12, 6, 11, 13, 7, 11, 6, 8, 11, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 1, 7, 9, 3, 8, 9, 4, 9, 9, 2, 10, 9, 2, 7, 10, 6, 8, 10, 9, 9, 10, 4, + 10, 10, 3, 7, 11, 10, 8, 11, 15, 9, 11, 7, 10, 11, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0}, // n = 20 +{ 2, 10, 9, 4, 11, 9, 1, 9, 10, 6, 10, 10, 10, 11, 10, 1, 9, 11, 9, 10, 11, 16, + 11, 11, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, + 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0} // n = 20 +}; + +// Returns the alpha value of a texel at position (x, y) from src. +// (x, y) are assumed to be in the range [0, 12). +uint8_t get_alpha(const uint8_t *src, int rowBytes, int x, int y) { + SkASSERT(x >= 0 && x < 12); + SkASSERT(y >= 0 && y < 12); + SkASSERT(rowBytes >= 12); + return *(src + y*rowBytes + x); +} + +// Output the 16 bytes stored in top and bottom and advance the pointer. The bytes +// are stored as the integers are represented in memory, so they should be swapped +// if necessary. +static inline void send_packing(uint8_t** dst, const uint64_t top, const uint64_t bottom) { + uint64_t* dst64 = reinterpret_cast(*dst); + dst64[0] = top; + dst64[1] = bottom; + *dst += 16; +} + +// Compresses an ASTC block, by looking up the proper contributions from +// k6x5To12x12Table and computing an index from the associated values. +static void compress_a8_astc_block(uint8_t** dst, const uint8_t* src, int rowBytes) { + // Check for single color + bool constant = true; + const uint32_t firstInt = *(reinterpret_cast(src)); + for (int i = 0; i < 12; ++i) { + const uint32_t *rowInt = reinterpret_cast(src + i*rowBytes); + constant = constant && (rowInt[0] == firstInt); + constant = constant && (rowInt[1] == firstInt); + constant = constant && (rowInt[2] == firstInt); + } + + if (constant) { + if (0 == firstInt) { + // All of the indices are set to zero, and the colors are + // v0 = 0, v1 = 255, so everything will be transparent. + send_packing(dst, SkTEndian_SwapLE64(0x0000000001FE000173ULL), 0); + return; + } else if (0xFFFFFFFF == firstInt) { + // All of the indices are set to zero, and the colors are + // v0 = 255, v1 = 0, so everything will be opaque. + send_packing(dst, SkTEndian_SwapLE64(0x000000000001FE0173ULL), 0); + return; + } + } + + uint8_t indices[30]; // 6x5 index grid + for (int idx = 0; idx < 30; ++idx) { + int weightTot = 0; + int alphaTot = 0; + + for (int w = 0; w < 20; ++w) { + const int weight = k6x5To12x12Table[idx][w*3]; + if (weight > 0) { + const int x = k6x5To12x12Table[idx][w*3 + 1]; + const int y = k6x5To12x12Table[idx][w*3 + 2]; + weightTot += weight; + alphaTot += weight * get_alpha(src, rowBytes, x, y); + } + } + + indices[idx] = (alphaTot + (weightTot/2)) / weightTot; + } + + // Pack indices... The ASTC block layout is fairly complicated. An extensive + // description can be found here: + // https://www.opengl.org/registry/specs/KHR/texture_compression_astc_hdr.txt + // + // Here is a summary of the options that we've chosen: + // 1. Block mode: 0b00101110011 + // - 6x5 texel grid + // - Single plane + // - Low-precision index values + // - Index range 0-7 (three bits per index) + // 2. Partitions: 0b00 + // - One partition + // 3. Color Endpoint Mode: 0b0000 + // - Direct luminance -- e0=(v0,v0,v0,0xFF); e1=(v1,v1,v1,0xFF); + // 4. 8-bit endpoints: + // v0 = 0, v1 = 255 + // + // The rest of the block contains the 30 index values from before, which + // are currently stored in the indices variable. + + uint64_t top = 0x0000000001FE000173ULL; + uint64_t bottom = 0; + + for (int idx = 0; idx <= 20; ++idx) { + const uint8_t index = (indices[idx] & 0xE0) >> 5; + bottom |= static_cast(index) << (61-(idx*3)); + } + + // index 21 straddles top and bottom + { + const uint8_t index = (indices[21] & 0xE0) >> 5; + bottom |= index & 1; + top |= static_cast((index >> 2) | (index & 2)) << 62; + } + + for (int idx = 22; idx < 30; ++idx) { + const uint8_t index = (indices[idx] & 0xE0) >> 5; + top |= static_cast(index) << (59-(idx-22)*3); + } + + // Reverse each 3-bit index since indices are read in reverse order... + uint64_t t = (bottom ^ (bottom >> 2)) & 0x2492492492492492ULL; + bottom = bottom ^ t ^ (t << 2); + + t = (top ^ (top >> 2)) & 0x0924924000000000ULL; + top = top ^ t ^ (t << 2); + + send_packing(dst, SkEndian_SwapLE64(top), SkEndian_SwapLE64(bottom)); +} + +//////////////////////////////////////////////////////////////////////////////// + +namespace SkTextureCompressor { + +bool CompressA8To12x12ASTC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) { + if (width < 0 || ((width % 12) != 0) || height < 0 || ((height % 12) != 0)) { + return false; + } + + uint8_t** dstPtr = &dst; + for (int y = 0; y < height; y+=12) { + for (int x = 0; x < width; x+=12) { + compress_a8_astc_block(dstPtr, src + y*rowBytes + x, rowBytes); + } + } + + return true; +} + +SkBlitter* CreateASTCBlitter(int width, int height, void* outputBuffer) { + // TODO (krajcevski) + return NULL; +} + +} // SkTextureCompressor diff --git a/src/utils/SkTextureCompressor_ASTC.h b/src/utils/SkTextureCompressor_ASTC.h new file mode 100644 index 0000000000..152fc62f16 --- /dev/null +++ b/src/utils/SkTextureCompressor_ASTC.h @@ -0,0 +1,24 @@ +/* + * Copyright 2014 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#ifndef SkTextureCompressor_ASTC_DEFINED +#define SkTextureCompressor_ASTC_DEFINED + +#include + +// Forward declare +class SkBlitter; + +namespace SkTextureCompressor { + + bool CompressA8To12x12ASTC(uint8_t* dst, const uint8_t* src, + int width, int height, int rowBytes); + + SkBlitter* CreateASTCBlitter(int width, int height, void* outputBuffer); +} + +#endif // SkTextureCompressor_ASTC_DEFINED