Add function for creating ASTC blitter

src/utils/SkTextureCompressor_ASTC.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_ASTC.h"
+#include "SkTextureCompressor_Blitter.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
@@ skipping 106 matching lines @@
 { 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).
-static inline uint8_t get_alpha(const uint8_t *src, int rowBytes, int x, int y) {
+inline uint8_t GetAlpha(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);
 }
 
+inline uint8_t GetAlphaTranspose(const uint8_t *src, int rowBytes, int x, int y) {
+    return GetAlpha(src, rowBytes, y, 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<uint64_t*>(*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.
+typedef uint8_t (*GetAlphaProc)(const uint8_t* src, int rowBytes, int x, int y);
+
+template<GetAlphaProc getAlphaProc>
 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<const uint32_t*>(src));
     for (int i = 0; i < 12; ++i) {
         const uint32_t *rowInt = reinterpret_cast<const uint32_t *>(src + i*rowBytes);
         constant = constant && (rowInt[0] == firstInt);
         constant = constant && (rowInt[1] == firstInt);
         constant = constant && (rowInt[2] == firstInt);
     }
@@ skipping 15 matching lines @@
     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 int8_t 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);
+                alphaTot += weight * getAlphaProc(src, rowBytes, x, y);
             } else {
                 // In our table, not every entry has 20 weights, and all
                 // of them are nonzero. Once we hit a negative weight, we
                 // know that all of the other weights are not valid either.
                 break;
             }
         }
 
         indices[idx] = (alphaTot / weightTot) >> 5;
     }
@@ skipping 41 matching lines @@
     // 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));
 }
 
+inline void compress_a8_astc_block_vertical(uint8_t* dst, const uint8_t* src) {
+    compress_a8_astc_block<GetAlphaTranspose>(&dst, src, 12);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 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);
+            compress_a8_astc_block<GetAlpha>(dstPtr, src + y*rowBytes + x, rowBytes);
         }
     }
 
     return true;
 }
 
 SkBlitter* CreateASTCBlitter(int width, int height, void* outputBuffer) {
-    // TODO (krajcevski)
-    return NULL;
+    return new
+        SkTCompressedAlphaBlitter<12, 16, compress_a8_astc_block_vertical>
+        (width, height, outputBuffer);
 }
 
 }  // SkTextureCompressor