Add support for NEON intrinsics to speed up texture compression. We can

src/utils/SkTextureCompressor.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 "SkBitmap.h"
 #include "SkData.h"
 #include "SkEndian.h"
 
+#include "SkTextureCompression_opts.h"
+
 ////////////////////////////////////////////////////////////////////////////////
 //
 // Utility Functions
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 // Absolute difference between two values. More correct than SkTAbs(a - b)
 // because it works on unsigned values.
 template <typename T> inline T abs_diff(const T &a, const T &b) {
     return (a > b) ? (a - b) : (b - a);
@@ skipping 555 matching lines @@
     // using a shuffle and a few shift-rotates...
     uint64_t x = (static_cast<uint64_t>(topRows) << 32) | static_cast<uint64_t>(bottomRows);
 
     // x: 00 a e 00 b f 00 c g 00 d h 00 i m 00 j n 00 k o 00 l p
 
     uint64_t t = (x ^ (x >> 10)) & 0x3FC0003FC00000ULL;
     x = x ^ t ^ (t << 10);
 
     // x: b f 00 00 00 a e c g i m 00 00 00 d h j n 00 k o 00 l p
 
-    x |= ((x << 52) & (0x3FULL << 52));
-    x = (x | ((x << 20) & (0x3FULL << 28))) >> 16;
+    x = (x | ((x << 52) & (0x3FULL << 52)) | ((x << 20) & (0x3FULL << 28))) >> 16;
 
-#if defined (SK_CPU_BENDIAN)
     // x: 00 00 00 00 00 00 00 00 b f l p a e c g i m k o d h j n
 
     t = (x ^ (x >> 6)) & 0xFC0000ULL;
     x = x ^ t ^ (t << 6);
 
+#if defined (SK_CPU_BENDIAN)
     // x: 00 00 00 00 00 00 00 00 b f l p a e i m c g k o d h j n
 
     t = (x ^ (x >> 36)) & 0x3FULL;
     x = x ^ t ^ (t << 36);
 
     // x: 00 00 00 00 00 00 00 00 b f j n a e i m c g k o d h l p
 
     t = (x ^ (x >> 12)) & 0xFFF000000ULL;
     x = x ^ t ^ (t << 12);
 
     // x: 00 00 00 00 00 00 00 00 a e i m b f j n c g k o d h l p
     return x;
 #else
     // If our CPU is little endian, then the above logic will
     // produce the following indices:
-    // x: 00 00 00 00 00 00 00 00 c g i m d h b f l p j n a e k o
-
-    t = (x ^ (x >> 6)) & 0xFC0000ULL;

[mtklein, 2014/07/11 15:24:27]

Removing this was intentional?

[krajcevski, 2014/07/11 16:11:47]

Yes, it was the same as line 595 above, which I moved out of the #ifdef.

-    x = x ^ t ^ (t << 6);
-
     // x: 00 00 00 00 00 00 00 00 c g i m d h l p b f j n a e k o
 
     t = (x ^ (x >> 36)) & 0xFC0ULL;
     x = x ^ t ^ (t << 36);
 
     // x: 00 00 00 00 00 00 00 00 a e i m d h l p b f j n c g k o
     
     x = (x & (0xFFFULL << 36)) | ((x & 0xFFFFFFULL) << 12) | ((x >> 24) & 0xFFFULL);
 
     // x: 00 00 00 00 00 00 00 00 a e i m b f j n c g k o d h l p
@@ skipping 135 matching lines @@
 
             return blocksX * blocksY * kLATCEncodedBlockSize;
         }
 
         default:
             SkFAIL("Unknown compressed format!");
             return 0;
     }
 }
 
-typedef bool (*CompressBitmapProc)(uint8_t* dst, const uint8_t* src,
-                                   int width, int height, int rowBytes);
+static class CompressionProcTable 
+{
+public:
+    CompressionProcTable() {

[mtklein, 2014/07/11 15:24:27]

We try to avoid static initializers when possible.  Chrome hates them.

Can you just write this out as a switch or if in CompressBufferToFormat rather
than creating the table ahead of time like this?  Something like,

CompressionProc proc = NULL;
if (kAlpha_8_SkColorType == srcColorType) {
  proc = SkTextureCompressorGetPlatformProc(format)
  if (NULL == proc) {
    switch (format) {
      case kLATC_Format:    proc = compress_a8_to_latc;   break;
      case kR11_EAC_Format: proc = compress_a8_to_r11eac; break;
    }
  }
}
return NULL == proc ? false : proc(dst, src, width, height, rowBytes);

[krajcevski, 2014/07/11 16:11:47]

Done.

+        memset(kProcMap, 0, sizeof(kProcMap));
+
+        kProcMap[kLATC_Format][kAlpha_8_SkColorType] = compress_a8_to_latc;
+        kProcMap[kR11_EAC_Format][kAlpha_8_SkColorType] = compress_a8_to_r11eac;
+        CompressionProc r11opt = SkTextureCompressorGetPlatformProc(kR11_EAC_Format);
+        if (NULL != r11opt) {
+           kProcMap[kR11_EAC_Format][kAlpha_8_SkColorType] = r11opt;
+        }
+    }
+
+    CompressionProc getProc(SkColorType colorType, Format fmt) const {
+        return kProcMap[fmt][colorType];
+    }
+
+private:
+    CompressionProc kProcMap[kFormatCnt][kLastEnum_SkColorType + 1];
+} kCompressionProcTable;
 
 bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType,
                             int width, int height, int rowBytes, Format format) {
-
-    CompressBitmapProc kProcMap[kFormatCnt][kLastEnum_SkColorType + 1];
-    memset(kProcMap, 0, sizeof(kProcMap));
-
-    kProcMap[kLATC_Format][kAlpha_8_SkColorType] = compress_a8_to_latc;
-    kProcMap[kR11_EAC_Format][kAlpha_8_SkColorType] = compress_a8_to_r11eac;
-
-    CompressBitmapProc proc = kProcMap[format][srcColorType];
+    CompressionProc proc = kCompressionProcTable.getProc(srcColorType, format);
     if (NULL != proc) {
         return proc(dst, src, width, height, rowBytes);
     }
 
     return false;
 }
 
 SkData *CompressBitmapToFormat(const SkBitmap &bitmap, Format format) {
     SkAutoLockPixels alp(bitmap);
 
     int compressedDataSize = get_compressed_data_size(format, bitmap.width(), bitmap.height());
     const uint8_t* src = reinterpret_cast<const uint8_t*>(bitmap.getPixels());
     uint8_t* dst = reinterpret_cast<uint8_t*>(sk_malloc_throw(compressedDataSize));
     if (CompressBufferToFormat(dst, src, bitmap.colorType(), bitmap.width(), bitmap.height(),
                                bitmap.rowBytes(), format)) {
         return SkData::NewFromMalloc(dst, compressedDataSize);
     }
 
     sk_free(dst);
     return NULL;
 }
 
 }  // namespace SkTextureCompressor