| /* |
| * 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.h" |
| |
| #include "SkBitmap.h" |
| #include "SkData.h" |
| #include "SkEndian.h" |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Utility Functions |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // Absolute difference between two values. More correct than SkTAbs(a - b) |
| // because it works on unsigned values. |
| template <typename T> inline T abs_diff(const T &a, const T &b) { |
| return (a > b) ? (a - b) : (b - a); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // LATC compressor |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| // LATC compressed texels down into square 4x4 blocks |
| static const int kPaletteSize = 8; |
| static const int kLATCBlockSize = 4; |
| static const int kPixelsPerBlock = kLATCBlockSize * kLATCBlockSize; |
| |
| // Generates an LATC palette. LATC constructs |
| // a palette of eight colors from LUM0 and LUM1 using the algorithm: |
| // |
| // LUM0, if lum0 > lum1 and code(x,y) == 0 |
| // LUM1, if lum0 > lum1 and code(x,y) == 1 |
| // (6*LUM0+ LUM1)/7, if lum0 > lum1 and code(x,y) == 2 |
| // (5*LUM0+2*LUM1)/7, if lum0 > lum1 and code(x,y) == 3 |
| // (4*LUM0+3*LUM1)/7, if lum0 > lum1 and code(x,y) == 4 |
| // (3*LUM0+4*LUM1)/7, if lum0 > lum1 and code(x,y) == 5 |
| // (2*LUM0+5*LUM1)/7, if lum0 > lum1 and code(x,y) == 6 |
| // ( LUM0+6*LUM1)/7, if lum0 > lum1 and code(x,y) == 7 |
| // |
| // LUM0, if lum0 <= lum1 and code(x,y) == 0 |
| // LUM1, if lum0 <= lum1 and code(x,y) == 1 |
| // (4*LUM0+ LUM1)/5, if lum0 <= lum1 and code(x,y) == 2 |
| // (3*LUM0+2*LUM1)/5, if lum0 <= lum1 and code(x,y) == 3 |
| // (2*LUM0+3*LUM1)/5, if lum0 <= lum1 and code(x,y) == 4 |
| // ( LUM0+4*LUM1)/5, if lum0 <= lum1 and code(x,y) == 5 |
| // 0, if lum0 <= lum1 and code(x,y) == 6 |
| // 255, if lum0 <= lum1 and code(x,y) == 7 |
| |
| static void generate_palette(uint8_t palette[], uint8_t lum0, uint8_t lum1) { |
| palette[0] = lum0; |
| palette[1] = lum1; |
| if (lum0 > lum1) { |
| for (int i = 1; i < 7; i++) { |
| palette[i+1] = ((7-i)*lum0 + i*lum1) / 7; |
| } |
| } else { |
| for (int i = 1; i < 5; i++) { |
| palette[i+1] = ((5-i)*lum0 + i*lum1) / 5; |
| } |
| palette[6] = 0; |
| palette[7] = 255; |
| } |
| } |
| |
| static bool is_extremal(uint8_t pixel) { |
| return 0 == pixel || 255 == pixel; |
| } |
| |
| // Compress a block by using the bounding box of the pixels. It is assumed that |
| // there are no extremal pixels in this block otherwise we would have used |
| // compressBlockBBIgnoreExtremal. |
| static uint64_t compress_block_bb(const uint8_t pixels[]) { |
| uint8_t minVal = 255; |
| uint8_t maxVal = 0; |
| for (int i = 0; i < kPixelsPerBlock; ++i) { |
| minVal = SkTMin(pixels[i], minVal); |
| maxVal = SkTMax(pixels[i], maxVal); |
| } |
| |
| SkASSERT(!is_extremal(minVal)); |
| SkASSERT(!is_extremal(maxVal)); |
| |
| uint8_t palette[kPaletteSize]; |
| generate_palette(palette, maxVal, minVal); |
| |
| uint64_t indices = 0; |
| for (int i = kPixelsPerBlock - 1; i >= 0; --i) { |
| |
| // Find the best palette index |
| uint8_t bestError = abs_diff(pixels[i], palette[0]); |
| uint8_t idx = 0; |
| for (int j = 1; j < kPaletteSize; ++j) { |
| uint8_t error = abs_diff(pixels[i], palette[j]); |
| if (error < bestError) { |
| bestError = error; |
| idx = j; |
| } |
| } |
| |
| indices <<= 3; |
| indices |= idx; |
| } |
| |
| return |
| SkEndian_SwapLE64( |
| static_cast<uint64_t>(maxVal) | |
| (static_cast<uint64_t>(minVal) << 8) | |
| (indices << 16)); |
| } |
| |
| // Compress a block by using the bounding box of the pixels without taking into |
| // account the extremal values. The generated palette will contain extremal values |
| // and fewer points along the line segment to interpolate. |
| static uint64_t compress_block_bb_ignore_extremal(const uint8_t pixels[]) { |
| uint8_t minVal = 255; |
| uint8_t maxVal = 0; |
| for (int i = 0; i < kPixelsPerBlock; ++i) { |
| if (is_extremal(pixels[i])) { |
| continue; |
| } |
| |
| minVal = SkTMin(pixels[i], minVal); |
| maxVal = SkTMax(pixels[i], maxVal); |
| } |
| |
| SkASSERT(!is_extremal(minVal)); |
| SkASSERT(!is_extremal(maxVal)); |
| |
| uint8_t palette[kPaletteSize]; |
| generate_palette(palette, minVal, maxVal); |
| |
| uint64_t indices = 0; |
| for (int i = kPixelsPerBlock - 1; i >= 0; --i) { |
| |
| // Find the best palette index |
| uint8_t idx = 0; |
| if (is_extremal(pixels[i])) { |
| if (0xFF == pixels[i]) { |
| idx = 7; |
| } else if (0 == pixels[i]) { |
| idx = 6; |
| } else { |
| SkFAIL("Pixel is extremal but not really?!"); |
| } |
| } else { |
| uint8_t bestError = abs_diff(pixels[i], palette[0]); |
| for (int j = 1; j < kPaletteSize - 2; ++j) { |
| uint8_t error = abs_diff(pixels[i], palette[j]); |
| if (error < bestError) { |
| bestError = error; |
| idx = j; |
| } |
| } |
| } |
| |
| indices <<= 3; |
| indices |= idx; |
| } |
| |
| return |
| SkEndian_SwapLE64( |
| static_cast<uint64_t>(minVal) | |
| (static_cast<uint64_t>(maxVal) << 8) | |
| (indices << 16)); |
| } |
| |
| |
| // Compress LATC block. Each 4x4 block of pixels is decompressed by LATC from two |
| // values LUM0 and LUM1, and an index into the generated palette. Details of how |
| // the palette is generated can be found in the comments of generatePalette above. |
| // |
| // We choose which palette type to use based on whether or not 'pixels' contains |
| // any extremal values (0 or 255). If there are extremal values, then we use the |
| // palette that has the extremal values built in. Otherwise, we use the full bounding |
| // box. |
| |
| static uint64_t compress_block(const uint8_t pixels[]) { |
| // Collect unique pixels |
| int nUniquePixels = 0; |
| uint8_t uniquePixels[kPixelsPerBlock]; |
| for (int i = 0; i < kPixelsPerBlock; ++i) { |
| bool foundPixel = false; |
| for (int j = 0; j < nUniquePixels; ++j) { |
| foundPixel = foundPixel || uniquePixels[j] == pixels[i]; |
| } |
| |
| if (!foundPixel) { |
| uniquePixels[nUniquePixels] = pixels[i]; |
| ++nUniquePixels; |
| } |
| } |
| |
| // If there's only one unique pixel, then our compression is easy. |
| if (1 == nUniquePixels) { |
| return SkEndian_SwapLE64(pixels[0] | (pixels[0] << 8)); |
| |
| // Similarly, if there are only two unique pixels, then our compression is |
| // easy again: place the pixels in the block header, and assign the indices |
| // with one or zero depending on which pixel they belong to. |
| } else if (2 == nUniquePixels) { |
| uint64_t outBlock = 0; |
| for (int i = kPixelsPerBlock - 1; i >= 0; --i) { |
| int idx = 0; |
| if (pixels[i] == uniquePixels[1]) { |
| idx = 1; |
| } |
| |
| outBlock <<= 3; |
| outBlock |= idx; |
| } |
| outBlock <<= 16; |
| outBlock |= (uniquePixels[0] | (uniquePixels[1] << 8)); |
| return SkEndian_SwapLE64(outBlock); |
| } |
| |
| // Count non-maximal pixel values |
| int nonExtremalPixels = 0; |
| for (int i = 0; i < nUniquePixels; ++i) { |
| if (!is_extremal(uniquePixels[i])) { |
| ++nonExtremalPixels; |
| } |
| } |
| |
| // If all the pixels are nonmaximal then compute the palette using |
| // the bounding box of all the pixels. |
| if (nonExtremalPixels == nUniquePixels) { |
| // This is really just for correctness, in all of my tests we |
| // never take this step. We don't lose too much perf here because |
| // most of the processing in this function is worth it for the |
| // 1 == nUniquePixels optimization. |
| return compress_block_bb(pixels); |
| } else { |
| return compress_block_bb_ignore_extremal(pixels); |
| } |
| } |
| |
| static bool compress_a8_to_latc(uint8_t* dst, const uint8_t* src, |
| int width, int height, int rowBytes) { |
| // Make sure that our data is well-formed enough to be |
| // considered for LATC compression |
| if (0 == width || 0 == height || |
| (width % kLATCBlockSize) != 0 || (height % kLATCBlockSize) != 0) { |
| return false; |
| } |
| |
| int blocksX = width / kLATCBlockSize; |
| int blocksY = height / kLATCBlockSize; |
| |
| uint8_t block[16]; |
| uint64_t* encPtr = reinterpret_cast<uint64_t*>(dst); |
| for (int y = 0; y < blocksY; ++y) { |
| for (int x = 0; x < blocksX; ++x) { |
| // Load block |
| static const int kBS = kLATCBlockSize; |
| for (int k = 0; k < kBS; ++k) { |
| memcpy(block + k*kBS, src + k*rowBytes + (kBS * x), kBS); |
| } |
| |
| // Compress it |
| *encPtr = compress_block(block); |
| ++encPtr; |
| } |
| src += kLATCBlockSize * rowBytes; |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| |
| namespace SkTextureCompressor { |
| |
| static size_t get_compressed_data_size(Format fmt, int width, int height) { |
| switch (fmt) { |
| case kLATC_Format: |
| { |
| // The LATC format is 64 bits per 4x4 block. |
| static const int kLATCEncodedBlockSize = 8; |
| |
| int blocksX = width / kLATCBlockSize; |
| int blocksY = height / kLATCBlockSize; |
| |
| return blocksX * blocksY * kLATCEncodedBlockSize; |
| } |
| |
| default: |
| SkFAIL("Unknown compressed format!"); |
| return 0; |
| } |
| } |
| |
| typedef bool (*CompressBitmapProc)(uint8_t* dst, const uint8_t* src, |
| int width, int height, int rowBytes); |
| |
| bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType, |
| int width, int height, int rowBytes, Format format) { |
| |
| CompressBitmapProc kProcMap[kFormatCnt][kLastEnum_SkColorType + 1]; |
| memset(kProcMap, 0, sizeof(kProcMap)); |
| |
| kProcMap[kLATC_Format][kAlpha_8_SkColorType] = compress_a8_to_latc; |
| |
| CompressBitmapProc proc = kProcMap[format][srcColorType]; |
| if (NULL != proc) { |
| return proc(dst, src, width, height, rowBytes); |
| } |
| |
| return false; |
| } |
| |
| SkData *CompressBitmapToFormat(const SkBitmap &bitmap, Format format) { |
| SkAutoLockPixels alp(bitmap); |
| |
| int compressedDataSize = get_compressed_data_size(format, bitmap.width(), bitmap.height()); |
| const uint8_t* src = reinterpret_cast<const uint8_t*>(bitmap.getPixels()); |
| uint8_t* dst = reinterpret_cast<uint8_t*>(sk_malloc_throw(compressedDataSize)); |
| if (CompressBufferToFormat(dst, src, bitmap.colorType(), bitmap.width(), bitmap.height(), |
| bitmap.rowBytes(), format)) { |
| return SkData::NewFromMalloc(dst, compressedDataSize); |
| } |
| |
| sk_free(dst); |
| return NULL; |
| } |
| |
| } // namespace SkTextureCompressor |
