Add initial pipeline for decompressors

src/utils/SkTextureCompressor_R11EAC.cpp

 /*
  * 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 "SkTextureCompressor_Blitter.h"
 
@@ skipping 11 matching lines @@
 // clamp[0, 2047](base_cw * 8 + 4 + mod_val*mul*8)
 //
 // mod_val is chosen from a palette of values based on the index of the
 // given pixel. The palette is chosen by the value stored in mod.
 // This formula returns a value between 0 and 2047, which is converted
 // to a float from 0 to 1 in OpenGL.
 //
 // If mul is zero, then we set mul = 1/8, so that the formula becomes
 // clamp[0, 2047](base_cw * 8 + 4 + mod_val)
 
-#if COMPRESS_R11_EAC_SLOW
-
 static const int kNumR11EACPalettes = 16;
 static const int kR11EACPaletteSize = 8;
 static const int kR11EACModifierPalettes[kNumR11EACPalettes][kR11EACPaletteSize] = {
     {-3, -6, -9, -15, 2, 5, 8, 14},
     {-3, -7, -10, -13, 2, 6, 9, 12},
     {-2, -5, -8, -13, 1, 4, 7, 12},
     {-2, -4, -6, -13, 1, 3, 5, 12},
     {-3, -6, -8, -12, 2, 5, 7, 11},
     {-3, -7, -9, -11, 2, 6, 8, 10},
     {-4, -7, -8, -11, 3, 6, 7, 10},
     {-3, -5, -8, -11, 2, 4, 7, 10},
     {-2, -6, -8, -10, 1, 5, 7, 9},
     {-2, -5, -8, -10, 1, 4, 7, 9},
     {-2, -4, -8, -10, 1, 3, 7, 9},
     {-2, -5, -7, -10, 1, 4, 6, 9},
     {-3, -4, -7, -10, 2, 3, 6, 9},
     {-1, -2, -3, -10, 0, 1, 2, 9},
     {-4, -6, -8, -9, 3, 5, 7, 8},
     {-3, -5, -7, -9, 2, 4, 6, 8}
 };
 
+#if COMPRESS_R11_EAC_SLOW
+
 // Pack the base codeword, palette, and multiplier into the 64 bits necessary
 // to decode it.
 static uint64_t pack_r11eac_block(uint16_t base_cw, uint16_t palette, uint16_t multiplier,
                                   uint64_t indices) {
     SkASSERT(palette < 16);
     SkASSERT(multiplier < 16);
     SkASSERT(indices < (static_cast<uint64_t>(1) << 48));
 
     const uint64_t b = static_cast<uint64_t>(base_cw) << 56;
     const uint64_t m = static_cast<uint64_t>(multiplier) << 52;
@@ skipping 485 matching lines @@
     const uint32_t packedIndexColumn2 = pack_indices_vertical(indexColumn2);
     const uint32_t packedIndexColumn3 = pack_indices_vertical(indexColumn3);
 
     *dst = SkEndian_SwapBE64(0x8490000000000000ULL |
                              (static_cast<uint64_t>(packedIndexColumn0) << 36) |
                              (static_cast<uint64_t>(packedIndexColumn1) << 24) |
                              static_cast<uint64_t>(packedIndexColumn2 << 12) |
                              static_cast<uint64_t>(packedIndexColumn3));
 }
 
+static inline int get_r11_eac_index(uint64_t block, int x, int y) {
+    SkASSERT(x >= 0 && x < 4);
+    SkASSERT(y >= 0 && y < 4);
+    const int idx = x*4 + y;
+    return (block >> ((15-idx)*3)) & 0x7;
+}
+
+static void decompress_r11_eac_block(uint8_t* dst, int dstRowBytes, const uint8_t* src) {
+    const uint64_t block = SkEndian_SwapBE64(*(reinterpret_cast<const uint64_t *>(src)));
+
+    const int base_cw = (block >> 56) & 0xFF;
+    const int mod = (block >> 52) & 0xF;
+    const int palette_idx = (block >> 48) & 0xF;
+
+    const int* palette = kR11EACModifierPalettes[palette_idx];
+
+    for (int j = 0; j < 4; ++j) {
+        for (int i = 0; i < 4; ++i) {
+            const int idx = get_r11_eac_index(block, i, j);
+            const int val = base_cw*8 + 4 + palette[idx]*mod*8;
+            if (val < 0) {
+                dst[i] = 0;
+            } else if (val > 2047) {
+                dst[i] = 0xFF;
+            } else {
+                dst[i] = (val >> 3) & 0xFF;
+            }
+        }
+        dst += dstRowBytes;
+    }

[robertphillips, 2014/07/31 15:01:02]

extra line ?

[krajcevski, 2014/07/31 15:12:18]

Done.

+
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace SkTextureCompressor {
 
 bool CompressA8ToR11EAC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) {
 
 #if (COMPRESS_R11_EAC_SLOW) || (COMPRESS_R11_EAC_FAST)
 
     return compress_4x4_a8_to_64bit(dst, src, width, height, rowBytes, compress_r11eac_block);
 
 #elif COMPRESS_R11_EAC_FASTEST
 
     return compress_a8_to_r11eac_fast(dst, src, width, height, rowBytes);
 
 #else
 #error "Must choose R11 EAC algorithm"
 #endif
 }
 
 SkBlitter* CreateR11EACBlitter(int width, int height, void* outputBuffer) {
     return new
         SkTCompressedAlphaBlitter<4, 8, compress_block_vertical>
         (width, height, outputBuffer);
 }
 
+void DecompressR11EAC(uint8_t* dst, int dstRowBytes, const uint8_t* src, int width, int height) {
+    for (int j = 0; j < height; j += 4) {
+        for (int i = 0; i < width; i += 4) {
+            decompress_r11_eac_block(dst + i, dstRowBytes, src);
+            src += 8;
+        }
+        dst += 4 * dstRowBytes;
+    }    
+}
+
 }  // namespace SkTextureCompressor