Port SkTextureCompression opts to SkOpts

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 "SkTextureCompressor_ASTC.h"
 #include "SkTextureCompressor_LATC.h"
 #include "SkTextureCompressor_R11EAC.h"
 
 #include "SkBitmap.h"
 #include "SkBitmapProcShader.h"
 #include "SkData.h"
 #include "SkEndian.h"
-
-#include "SkTextureCompression_opts.h"
+#include "SkOpts.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "etc1.h"
 #endif
 
 // Convert ETC1 functions to our function signatures
 static bool compress_etc1_565(uint8_t* dst, const uint8_t* src,
                               int width, int height, size_t rowBytes) {
 #ifndef SK_IGNORE_ETC1_SUPPORT
     return 0 == etc1_encode_image(src, width, height, 2, SkToInt(rowBytes), dst);
 #else
     return false;
 #endif
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace SkTextureCompressor {
 
 void GetBlockDimensions(Format format, int* dimX, int* dimY, bool matchSpec) {
     if (NULL == dimX || NULL == dimY) {
         return;
     }
 
-    if (!matchSpec && SkTextureCompressorGetPlatformDims(format, dimX, dimY)) {
+    if (!matchSpec && SkOpts::fill_block_dimensions(format, dimX, dimY)) {
         return;
     }
 
     // No specialized arguments, return the dimensions as they are in the spec.
     static const struct FormatDimensions {
         const int fBlockSizeX;
         const int fBlockSizeY;
     } kFormatDimensions[kFormatCnt] = {
         { 4, 4 }, // kLATC_Format
         { 4, 4 }, // kR11_EAC_Format
@@ skipping 16 matching lines @@
 
     *dimX = kFormatDimensions[format].fBlockSizeX;
     *dimY = kFormatDimensions[format].fBlockSizeY;
 }
 
 int GetCompressedDataSize(Format fmt, int width, int height) {
     int dimX, dimY;
     GetBlockDimensions(fmt, &dimX, &dimY, true);
 
     int encodedBlockSize = 0;
-            
+
     switch (fmt) {
         // These formats are 64 bits per 4x4 block.
         case kLATC_Format:
         case kR11_EAC_Format:
         case kETC1_Format:
             encodedBlockSize = 8;
             break;
 
         // This format is 128 bits.
         case kASTC_4x4_Format:
@@ skipping 22 matching lines @@
         const int blocksX = width / dimX;
         const int blocksY = height / dimY;
 
         return blocksX * blocksY * encodedBlockSize;
     }
 
     return -1;
 }
 
 bool CompressBufferToFormat(uint8_t* dst, const uint8_t* src, SkColorType srcColorType,
-                            int width, int height, size_t rowBytes, Format format, bool opt) {
-    CompressionProc proc = NULL;
-    if (opt) {
-        proc = SkTextureCompressorGetPlatformProc(srcColorType, format);
+                            int width, int height, size_t rowBytes, Format format) {
+    SkOpts::TextureCompressor proc = SkOpts::texture_compressor(srcColorType, format);
+    if (proc && proc(dst, src, width, height, rowBytes)) {
+        return true;
     }
 
-    if (NULL == proc) {
-        switch (srcColorType) {
-            case kAlpha_8_SkColorType:
-            {
-                switch (format) {
-                    case kLATC_Format:
-                        proc = CompressA8ToLATC;
-                        break;
-                    case kR11_EAC_Format:
-                        proc = CompressA8ToR11EAC;
-                        break;
-                    case kASTC_12x12_Format:
-                        proc = CompressA8To12x12ASTC;
-                        break;
-                    default:
-                        // Do nothing...
-                        break;
-                }
-            }
+    switch (srcColorType) {
+        case kAlpha_8_SkColorType:
+            if (format == kLATC_Format)       { proc = CompressA8ToLATC;      }
+            if (format == kR11_EAC_Format)    { proc = CompressA8ToR11EAC;    }
+            if (format == kASTC_12x12_Format) { proc = CompressA8To12x12ASTC; }
             break;
-
-            case kRGB_565_SkColorType:
-            {
-                switch (format) {
-                    case kETC1_Format:
-                        proc = compress_etc1_565;
-                        break;
-                    default:
-                        // Do nothing...
-                        break;
-                }
-            }
+        case kRGB_565_SkColorType:
+            if (format == kETC1_Format) { proc = compress_etc1_565; }
             break;
-
-            default:
-                // Do nothing...
-                break;
-        }
+        default:
+            break;
     }
-
-    if (proc) {
-        return proc(dst, src, width, height, rowBytes);
+    if (proc && proc(dst, src, width, height, rowBytes)) {
+        return true;
     }
 
     return false;
 }
 
 SkData* CompressBitmapToFormat(const SkPixmap& pixmap, Format format) {
     int compressedDataSize = GetCompressedDataSize(format, pixmap.width(), pixmap.height());
     if (compressedDataSize < 0) {
         return NULL;
     }
@@ skipping 70 matching lines @@
 
         default:
             // Do nothing...
             break;
     }
 
     return false;
 }
 
 }  // namespace SkTextureCompressor