Add BlitRect to SkTCompressedAlphaBlitter

src/utils/SkTextureCompressor_LATC.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_LATC.h"
 #include "SkTextureCompressor_Blitter.h"
 
@@ skipping 279 matching lines @@
         return compress_latc_block_bb_ignore_extremal(pixels);
     }
 }
 
 #endif  // COMPRESS_LATC_SLOW
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #if COMPRESS_LATC_FAST
 
-// Take the top three indices of each int and pack them into the low 12
+// Take the top three bits of each index and pack them into the low 12
 // bits of the integer.
+static inline uint32_t pack_index(uint32_t x) {
+    // Pack it in...
+#if defined (SK_CPU_BENDIAN)
+    return
+        (x >> 24) |
+        ((x >> 13) & 0x38) |
+        ((x >> 2) & 0x1C0) |
+        ((x << 9) & 0xE00);
+#else
+    return
+        (x & 0x7) |
+        ((x >> 5) & 0x38) |
+        ((x >> 10) & 0x1C0) |
+        ((x >> 15) & 0xE00);
+#endif
+}
+
+// Converts each 8-bit byte in the integer into an LATC index, and then packs
+// the indices into the low 12 bits of the integer.
 static inline uint32_t convert_index(uint32_t x) {
     // Since the palette is 
     // 255, 0, 219, 182, 146, 109, 73, 36
     // we need to map the high three bits of each byte in the integer
     // from
     // 0 1 2 3 4 5 6 7
     // to
     // 1 7 6 5 4 3 2 0
     //
     // This first operation takes the mapping from
     // 0 1 2 3 4 5 6 7  -->  7 6 5 4 3 2 1 0
     x = 0x07070707 - ((x >> 5) & 0x07070707);
 
     // mask is 1 if index is non-zero
     const uint32_t mask = (x | (x >> 1) | (x >> 2)) & 0x01010101;
 
     // add mask:
     // 7 6 5 4 3 2 1 0 --> 8 7 6 5 4 3 2 0
     x = (x + mask);
 
     // Handle overflow:
     // 8 7 6 5 4 3 2 0 --> 9 7 6 5 4 3 2 0
     x |= (x >> 3) & 0x01010101;
 
     // Mask out high bits:
     // 9 7 6 5 4 3 2 0 --> 1 7 6 5 4 3 2 0
     x &= 0x07070707;
-
-    // Pack it in...
-#if defined (SK_CPU_BENDIAN)
-    return
-        (x >> 24) |
-        ((x >> 13) & 0x38) |
-        ((x >> 2) & 0x1C0) |
-        ((x << 9) & 0xE00);
-#else
-    return
-        (x & 0x7) |
-        ((x >> 5) & 0x38) |
-        ((x >> 10) & 0x1C0) |
-        ((x >> 15) & 0xE00);
-#endif
+    
+    return pack_index(x);
 }
 
 typedef uint64_t (*PackIndicesProc)(const uint8_t* alpha, int rowBytes);
 template<PackIndicesProc packIndicesProc>
 static void compress_a8_latc_block(uint8_t** dstPtr, const uint8_t* src, int rowBytes) {
     *(reinterpret_cast<uint64_t*>(*dstPtr)) =
         SkEndian_SwapLE64(0xFF | (packIndicesProc(src, rowBytes) << 16));
     *dstPtr += 8;
 }
 
@@ skipping 66 matching lines @@
 struct CompressorLATC {
     static inline void CompressA8Vertical(uint8_t* dst, const uint8_t block[]) {
         compress_a8_latc_block<PackColumnMajor>(&dst, block, 4);
     }
 
     static inline void CompressA8Horizontal(uint8_t* dst, const uint8_t* src,
                                             int srcRowBytes) {
         compress_a8_latc_block<PackRowMajor>(&dst, src, srcRowBytes);
     }
 
-    static inline void UpdateBlock(uint8_t* dst, const uint8_t* src) {
+#if PEDANTIC_BLIT_RECT
+    static inline void UpdateBlock(uint8_t* dst, const uint8_t* src, int srcRowBytes,
+                                   const uint8_t* mask) {
+        // Pack the mask
+        uint64_t cmpMask = 0;
+        for (int i = 0; i < 4; ++i) {
+            const uint32_t idx = *(reinterpret_cast<const uint32_t*>(src + i*srcRowBytes));
+            cmpMask |= static_cast<uint64_t>(pack_index(idx)) << 12*i;
+        }
+        cmpMask = SkEndian_SwapLE64(cmpMask << 16); // avoid header
+
+        uint64_t cmpSrc;
+        uint8_t *cmpSrcPtr = reinterpret_cast<uint8_t*>(&cmpSrc);
+        compress_a8_latc_block<PackRowMajor>(&cmpSrcPtr, src, srcRowBytes);
+
+        // Mask out header
+        cmpSrc = cmpSrc & cmpMask;
+
+        // Read destination encoding
+        uint64_t *cmpDst = reinterpret_cast<uint64_t*>(dst);
+
+        // If the destination is the encoding for a blank block, then we need
+        // to properly set the header
+        if (0 == cmpDst) {
+            *cmpDst = SkTEndian_SwapLE64(0x24924924924900FFULL);
+        }
+
+        // Set the new indices
+        *cmpDst &= ~cmpMask;
+        *cmpDst |= cmpSrc;
     }
+#endif  // PEDANTIC_BLIT_RECT
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace SkTextureCompressor {
 
 bool CompressA8ToLATC(uint8_t* dst, const uint8_t* src, int width, int height, int rowBytes) {
 #if COMPRESS_LATC_FAST
     return compress_4x4_a8_latc(dst, src, width, height, rowBytes);
 #elif COMPRESS_LATC_SLOW
@@ skipping 31 matching lines @@
     for (int j = 0; j < height; j += 4) {
         for (int i = 0; i < width; i += 4) {
             decompress_latc_block(dst + i, dstRowBytes, src);
             src += 8;
         }
         dst += 4 * dstRowBytes;
     }
 }
 
 }  // SkTextureCompressor