Some small ASTC optimizations

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 "SkBlitter.h"
@@ skipping 19 matching lines @@
 //       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] = {
+static const int8_t 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,
@@ skipping 74 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).
-uint8_t get_alpha(const uint8_t *src, int rowBytes, int x, int y) {
+static inline 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) {
@@ skipping 27 matching lines @@
             // 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];
+            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);
+            } 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/2)) / weightTot;
+        indices[idx] = (alphaTot / weightTot) >> 5;
     }
 
     // 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;
+        const uint8_t index = indices[idx];
         bottom |= static_cast<uint64_t>(index) << (61-(idx*3));
     }
 
     // index 21 straddles top and bottom
     {
-        const uint8_t index = (indices[21] & 0xE0) >> 5;
+        const uint8_t index = indices[21];
         bottom |= index & 1;
         top |= static_cast<uint64_t>((index >> 2) | (index & 2)) << 62;
     }
 
     for (int idx = 22; idx < 30; ++idx) {
-        const uint8_t index = (indices[idx] & 0xE0) >> 5;
+        const uint8_t index = indices[idx];
         top |= static_cast<uint64_t>(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);
 
@@ skipping 18 matching lines @@
 
     return true;
 }
 
 SkBlitter* CreateASTCBlitter(int width, int height, void* outputBuffer) {
     // TODO (krajcevski)
     return NULL;
 }
 
 }  // SkTextureCompressor