Pass a struct of functions instead of a function to the compressed 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"
 
@@ skipping 1972 matching lines @@
     // stored in the block.
     dst += data.fDimY * dstRowBytes;
     for (int y = 0; y < data.fDimY; ++y) {
         dst -= dstRowBytes;
         SkColor* colorPtr = reinterpret_cast<SkColor*>(dst);
         for (int x = 0; x < data.fDimX; ++x) {
             colorPtr[x] = data.getTexel(endpoints, texelWeights, x, y);
         }
     }
 }
 

[robertphillips, 2014/08/07 17:53:15]

Add a comment like the following for all three instances:

// The CompressorType for ASTC compression. See SkTextureCompressor_Blitter.h
for more information/definition

?

[krajcevski, 2014/08/07 18:00:41]

Done.

+struct CompressorASTC {
+    static inline void CompressA8Vertical(uint8_t* dst, const uint8_t* src) {
+        compress_a8_astc_block<GetAlphaTranspose>(&dst, src, 12);
+    }
+
+    static inline void CompressA8Horizontal(uint8_t* dst, const uint8_t* src,
+                                            int srcRowBytes) {
+        compress_a8_astc_block<GetAlpha>(&dst, src, srcRowBytes);
+    }
+
+    static inline void UpdateBlock(uint8_t* dst, const uint8_t* src) {
+    }
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 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;
     }
 
@@ skipping 19 matching lines @@
     // In the case of ASTC, if everything index is zero, then the interpolated value
     // will decode to zero provided we have the right header. We use the encoding
     // from recognizing all zero blocks from above.
     const int nBlocks = (width * height / 144);
     uint8_t *dst = reinterpret_cast<uint8_t *>(outputBuffer);
     for (int i = 0; i < nBlocks; ++i) {
         send_packing(&dst, SkTEndian_SwapLE64(0x0000000001FE000173ULL), 0);
     }
 
     return allocator->createT<
-        SkTCompressedAlphaBlitter<12, 16, CompressA8ASTCBlockVertical>, int, int, void* >
+        SkTCompressedAlphaBlitter<12, 16, CompressorASTC>, int, int, void* >
         (width, height, outputBuffer);
 }
 
 void DecompressASTC(uint8_t* dst, int dstRowBytes, const uint8_t* src,
                     int width, int height, int blockDimX, int blockDimY) {
     // ASTC is encoded in what they call "raster order", so that the first
     // block is the bottom-left block in the image, and the first pixel
     // is the bottom-left pixel of the image
     dst += height * dstRowBytes;
 
     ASTCDecompressionData data(blockDimX, blockDimY);
     for (int y = 0; y < height; y += blockDimY) {
         dst -= blockDimY * dstRowBytes;
         SkColor *colorPtr = reinterpret_cast<SkColor*>(dst);
         for (int x = 0; x < width; x += blockDimX) {
             read_astc_block(&data, src);
             decompress_astc_block(reinterpret_cast<uint8_t*>(colorPtr + x), dstRowBytes, data);
 
             // ASTC encoded blocks are 16 bytes (128 bits) large.
             src += 16;
         }
     }
 }
 
 }  // SkTextureCompressor