Bring LATC in line with other formats (i.e. write a blitter and

tests/TextureCompressionTest.cpp

Index: tests/TextureCompressionTest.cpp
diff --git a/tests/TextureCompressionTest.cpp b/tests/TextureCompressionTest.cpp
index 2079fa38a21300306804af82d5fa0364bb977e5c..603c6fa9a4bcd18b5c746990a2cb76ea8a387d08 100644
--- a/tests/TextureCompressionTest.cpp
+++ b/tests/TextureCompressionTest.cpp
@@ -12,19 +12,21 @@
 #include "SkTextureCompressor.h"
 #include "Test.h"
 
-static const int kLATCBlockDimension = 4;
-static const int kLATCEncodedBlockSize = 8;
-
 /**
  * Make sure that we properly fail when we don't have multiple of four image dimensions.
  */
-DEF_TEST(CompressLATCFailDimensions, reporter) {
+DEF_TEST(CompressAlphaFailDimensions, reporter) {
     SkBitmap bitmap;
     static const int kWidth = 63;
     static const int kHeight = 63;
     SkImageInfo info = SkImageInfo::MakeA8(kWidth, kHeight);
-    REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension != 0);
-    REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension != 0);
+
+    // R11_EAC and LATC are both dimensions of 4, so we need to make sure that we
+    // are violating those assumptions. And if we are, then we're also violating the
+    // assumptions of ASTC, which is 12x12 since any number not divisible by 4 is
+    // also not divisible by 12.
+    REPORTER_ASSERT(reporter, kWidth % 4 != 0);
+    REPORTER_ASSERT(reporter, kHeight % 4 != 0);
 
     bool setInfoSuccess = bitmap.setInfo(info);
     REPORTER_ASSERT(reporter, setInfoSuccess);
@@ -32,23 +34,28 @@ DEF_TEST(CompressLATCFailDimensions, reporter) {
     bool allocPixelsSuccess = bitmap.allocPixels(info);
     REPORTER_ASSERT(reporter, allocPixelsSuccess);
     bitmap.unlockPixels();
-
-    const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
-    SkAutoDataUnref latcData(SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
-    REPORTER_ASSERT(reporter, NULL == latcData);
+    
+    for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
+        const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
+        SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
+        REPORTER_ASSERT(reporter, NULL == data);
+    }
 }
 
 /**
  * Make sure that we properly fail when we don't have the correct bitmap type.
- * LATC compressed textures can only be created from A8 bitmaps.
+ * compressed textures can (currently) only be created from A8 bitmaps.
  */
-DEF_TEST(CompressLATCFailColorType, reporter) {
+DEF_TEST(CompressAlphaFailColorType, reporter) {
     SkBitmap bitmap;
-    static const int kWidth = 64;
-    static const int kHeight = 64;
+    static const int kWidth = 60;
+    static const int kHeight = 60;
     SkImageInfo info = SkImageInfo::MakeN32Premul(kWidth, kHeight);
-    REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension == 0);
-    REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension == 0);
+
+    // ASTC is at most 12x12, and any dimension divisible by 12 is also divisible
+    // by 4, which is the dimensions of R11_EAC and LATC

[robertphillips, 2014/07/30 15:02:23]

What about 8 ?

[krajcevski, 2014/07/30 15:23:27]

We don't currently support 8x8 ASTC, if we do ever add additional kinds of ASTC
support, then we would probably need to update this. I've added a note in the
comments.

+    REPORTER_ASSERT(reporter, kWidth % 12 == 0);
+    REPORTER_ASSERT(reporter, kHeight % 12 == 0);
 
     bool setInfoSuccess = bitmap.setInfo(info);
     REPORTER_ASSERT(reporter, setInfoSuccess);
@@ -57,15 +64,21 @@ DEF_TEST(CompressLATCFailColorType, reporter) {
     REPORTER_ASSERT(reporter, allocPixelsSuccess);
     bitmap.unlockPixels();
 
-    const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
-    SkAutoDataUnref latcData(SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
-    REPORTER_ASSERT(reporter, NULL == latcData);
+    for (int i = 0; i < SkTextureCompressor::kFormatCnt; ++i) {
+        const SkTextureCompressor::Format fmt = static_cast<SkTextureCompressor::Format>(i);
+        SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(bitmap, fmt));
+        REPORTER_ASSERT(reporter, NULL == data);
+    }
 }
 
 /**
  * Make sure that if we pass in a solid color bitmap that we get the appropriate results
  */
 DEF_TEST(CompressLATC, reporter) {
+
+    const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
+    static const int kLATCEncodedBlockSize = 8;
+
     SkBitmap bitmap;
     static const int kWidth = 8;
     static const int kHeight = 8;
@@ -78,10 +91,15 @@ DEF_TEST(CompressLATC, reporter) {
     REPORTER_ASSERT(reporter, allocPixelsSuccess);
     bitmap.unlockPixels();
 
-    REPORTER_ASSERT(reporter, kWidth % kLATCBlockDimension == 0);
-    REPORTER_ASSERT(reporter, kHeight % kLATCBlockDimension == 0);
-    const int numBlocks = (kWidth / kLATCBlockDimension) * (kHeight / kLATCBlockDimension);
-    const size_t kSizeToBe = static_cast<size_t>(kLATCEncodedBlockSize * numBlocks);
+    int latcDimX, latcDimY;
+    SkTextureCompressor::GetBlockDimensions(kLATCFormat, &latcDimX, &latcDimY);
+
+    REPORTER_ASSERT(reporter, kWidth % latcDimX == 0);
+    REPORTER_ASSERT(reporter, kHeight % latcDimY == 0);
+    const size_t kSizeToBe =
+        SkTextureCompressor::GetCompressedDataSize(kLATCFormat, kWidth, kHeight);
+    REPORTER_ASSERT(reporter, kSizeToBe == ((kWidth*kHeight*kLATCEncodedBlockSize)/16));
+    REPORTER_ASSERT(reporter, (kSizeToBe % kLATCEncodedBlockSize) == 0);
 
     for (int lum = 0; lum < 256; ++lum) {
         bitmap.lockPixels();
@@ -93,21 +111,29 @@ DEF_TEST(CompressLATC, reporter) {
         }
         bitmap.unlockPixels();
 
-        const SkTextureCompressor::Format kLATCFormat = SkTextureCompressor::kLATC_Format;
         SkAutoDataUnref latcData(
             SkTextureCompressor::CompressBitmapToFormat(bitmap, kLATCFormat));
         REPORTER_ASSERT(reporter, NULL != latcData);
         REPORTER_ASSERT(reporter, kSizeToBe == latcData->size());
 
-        // Make sure that it all matches a given block encoding. If the entire bitmap
-        // is a single value, then the lower two bytes of the encoded data should be that
-        // value. The remaining indices can be any value, and since we try to match the pixels
-        // in the chosen palette in increasing index order, each one should be zero. Hence,
-        // the correct encoding should be just the two luminance values in the bottom two
-        // bytes of the block encoding.
-        const uint64_t kConstColorEncoding = SkEndian_SwapLE64(lum | (lum << 8));
+        // Make sure that it all matches a given block encoding. Since we have
+        // COMPRESS_LATC_FAST defined in SkTextureCompressor_LATC.cpp, we are using
+        // an approximation scheme that optimizes for speed against coverage maps.
+        // That means that each palette in the encoded block is exactly the same,
+        // and that the three bits saved per pixel are computed from the top three
+        // bits of the luminance value.
+        const uint64_t kIndexEncodingMap[8] = { 1, 7, 6, 5, 4, 3, 2, 0 };
+        const uint64_t kIndex = kIndexEncodingMap[lum >> 5];
+        const uint64_t kConstColorEncoding =
+            SkEndian_SwapLE64(
+                255 |
+                (kIndex << 16) | (kIndex << 19) | (kIndex << 22) | (kIndex << 25) |
+                (kIndex << 28) | (kIndex << 31) | (kIndex << 34) | (kIndex << 37) |
+                (kIndex << 40) | (kIndex << 43) | (kIndex << 46) | (kIndex << 49) |
+                (kIndex << 52) | (kIndex << 55) | (kIndex << 58) | (kIndex << 61));
+
         const uint64_t* blockPtr = reinterpret_cast<const uint64_t*>(latcData->data());
-        for (int i = 0; i < numBlocks; ++i) {
+        for (size_t i = 0; i < (kSizeToBe/8); ++i) {
             REPORTER_ASSERT(reporter, blockPtr[i] == kConstColorEncoding);
         }
     }