Revert of 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 | ((x << 52) & (0x3FULL << 52)) | ((x << 20) & (0x3FULL << 28))) >> 16;
+    x |= ((x << 52) & (0x3FULL << 52));
+    x = (x | ((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;
+    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);
+
 bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType,
-                            int width, int height, int rowBytes, Format format, bool opt) {
-    CompressionProc proc = NULL;
-    if (opt) {
-        proc = SkTextureCompressorGetPlatformProc(srcColorType, format);
-    }
+                            int width, int height, int rowBytes, Format format) {
 
-    if (NULL == proc) {
-        switch (srcColorType) {
-            case kAlpha_8_SkColorType:
-            {
-                switch (format) {
-                    case kLATC_Format:
-                        proc = compress_a8_to_latc;
-                        break;
-                    case kR11_EAC_Format:
-                        proc = compress_a8_to_r11eac;
-                        break;
-                    default:
-                        // Do nothing...
-                        break;
-                }
-            }
-            break;
+    CompressBitmapProc kProcMap[kFormatCnt][kLastEnum_SkColorType + 1];
+    memset(kProcMap, 0, sizeof(kProcMap));
 
-            default:
-                // Do nothing...
-                break;
-        }
-    }
+    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];
     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