Revert "Revert "remove kA1_Config, as it is no longer supported""

tests/BitmapCopyTest.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkBitmap.h"
 #include "SkRect.h"
 
 static const char* boolStr(bool value) {
     return value ? "true" : "false";
 }
 
 // these are in the same order as the SkBitmap::Config enum
 static const char* gConfigName[] = {
-    "None", "A1", "A8", "Index8", "565", "4444", "8888", "RLE_Index8"
+    "None", "A8", "Index8", "565", "4444", "8888"
 };
 
 static void report_opaqueness(skiatest::Reporter* reporter, const SkBitmap& src,
                               const SkBitmap& dst) {
     SkString str;
     str.printf("src %s opaque:%d, dst %s opaque:%d",
                gConfigName[src.config()], src.isOpaque(),
                gConfigName[dst.config()], dst.isOpaque());
     reporter->reportFailed(str);
 }
@@ skipping 21 matching lines @@
     if (srcOpaque.isOpaque() != dst.isOpaque()) {
         report_opaqueness(reporter, srcOpaque, dst);
     }
 }
 
 static void init_src(const SkBitmap& bitmap) {
     SkAutoLockPixels lock(bitmap);
     if (bitmap.getPixels()) {
         if (bitmap.getColorTable()) {
             sk_bzero(bitmap.getPixels(), bitmap.getSize());
-        } else if (SkBitmap::kA1_Config == bitmap.config()) {
-            // The A1 config can have uninitialized bits at the
-            // end of each row if eraseColor is used
-            memset(bitmap.getPixels(), 0xff, bitmap.getSafeSize());
         } else {
             bitmap.eraseColor(SK_ColorWHITE);
         }
     }
 }
 
 static SkColorTable* init_ctable(SkAlphaType alphaType) {
     static const SkColor colors[] = {
         SK_ColorBLACK, SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE
     };
@@ skipping 11 matching lines @@
 // getSkConfigName()
 // struct Coordinates
 // reportCopyVerification()
 // writeCoordPixels()
 
 // Utility function to read the value of a given pixel in bm. All
 // values converted to uint32_t for simplification of comparisons.
 static uint32_t getPixel(int x, int y, const SkBitmap& bm) {
     uint32_t val = 0;
     uint16_t val16;
-    uint8_t val8, shift;
+    uint8_t val8;
     SkAutoLockPixels lock(bm);
     const void* rawAddr = bm.getAddr(x,y);
 
     switch (bm.config()) {
         case SkBitmap::kARGB_8888_Config:
             memcpy(&val, rawAddr, sizeof(uint32_t));
             break;
         case SkBitmap::kARGB_4444_Config:
         case SkBitmap::kRGB_565_Config:
             memcpy(&val16, rawAddr, sizeof(uint16_t));
             val = val16;
             break;
         case SkBitmap::kA8_Config:
         case SkBitmap::kIndex8_Config:
             memcpy(&val8, rawAddr, sizeof(uint8_t));
             val = val8;
             break;
-        case SkBitmap::kA1_Config:
-            memcpy(&val8, rawAddr, sizeof(uint8_t));
-            shift = x % 8;
-            val = (val8 >> shift) & 0x1 ;
-            break;
         default:
             break;
     }
     return val;
 }
 
 // Utility function to set value of any pixel in bm.
 // bm.getConfig() specifies what format 'val' must be
 // converted to, but at present uint32_t can handle all formats.
 static void setPixel(int x, int y, uint32_t val, SkBitmap& bm) {
     uint16_t val16;
-    uint8_t val8, shift;
+    uint8_t val8;
     SkAutoLockPixels lock(bm);
     void* rawAddr = bm.getAddr(x,y);
 
     switch (bm.config()) {
         case SkBitmap::kARGB_8888_Config:
             memcpy(rawAddr, &val, sizeof(uint32_t));
             break;
         case SkBitmap::kARGB_4444_Config:
         case SkBitmap::kRGB_565_Config:
             val16 = val & 0xFFFF;
             memcpy(rawAddr, &val16, sizeof(uint16_t));
             break;
         case SkBitmap::kA8_Config:
         case SkBitmap::kIndex8_Config:
             val8 = val & 0xFF;
             memcpy(rawAddr, &val8, sizeof(uint8_t));
             break;
-        case SkBitmap::kA1_Config:
-            shift = x % 8; // We assume we're in the right byte.
-            memcpy(&val8, rawAddr, sizeof(uint8_t));
-            if (val & 0x1) // Turn bit on.
-                val8 |= (0x1 << shift);
-            else // Turn bit off.
-                val8 &= ~(0x1 << shift);
-            memcpy(rawAddr, &val8, sizeof(uint8_t));
-            break;
         default:
             // Ignore.
             break;
     }
 }
 
 // Utility to return string containing name of each format, to
 // simplify diagnostic output.
 static const char* getSkConfigName(const SkBitmap& bm) {
     switch (bm.config()) {
         case SkBitmap::kNo_Config: return "SkBitmap::kNo_Config";
-        case SkBitmap::kA1_Config: return "SkBitmap::kA1_Config";
         case SkBitmap::kA8_Config: return "SkBitmap::kA8_Config";
         case SkBitmap::kIndex8_Config: return "SkBitmap::kIndex8_Config";
         case SkBitmap::kRGB_565_Config: return "SkBitmap::kRGB_565_Config";
         case SkBitmap::kARGB_4444_Config: return "SkBitmap::kARGB_4444_Config";
         case SkBitmap::kARGB_8888_Config: return "SkBitmap::kARGB_8888_Config";
         default: return "Unknown SkBitmap configuration.";
     }
 }
 
 // Helper struct to contain pixel locations, while avoiding need for STL.
@@ skipping 40 matching lines @@
 }
 
 // Writes unique pixel values at locations specified by coords.
 static void writeCoordPixels(SkBitmap& bm, const Coordinates& coords) {
     for (int i = 0; i < coords.length; ++i)
         setPixel(coords[i]->fX, coords[i]->fY, i, bm);
 }
 
 static void TestBitmapCopy(skiatest::Reporter* reporter) {
     static const Pair gPairs[] = {
-        { SkBitmap::kNo_Config,         "00000000"  },
-        { SkBitmap::kA1_Config,         "01000000"  },
-        { SkBitmap::kA8_Config,         "00101010"  },
-        { SkBitmap::kIndex8_Config,     "00111010"  },
-        { SkBitmap::kRGB_565_Config,    "00101010"  },
-        { SkBitmap::kARGB_4444_Config,  "00101110"  },
-        { SkBitmap::kARGB_8888_Config,  "00101110"  },
+        { SkBitmap::kNo_Config,         "0000000"  },
+        { SkBitmap::kA8_Config,         "0101010"  },
+        { SkBitmap::kIndex8_Config,     "0111010"  },
+        { SkBitmap::kRGB_565_Config,    "0101010"  },
+        { SkBitmap::kARGB_4444_Config,  "0101110"  },
+        { SkBitmap::kARGB_8888_Config,  "0101110"  },
     };
 
     static const bool isExtracted[] = {
         false, true
     };
 
     const int W = 20;
     const int H = 33;
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
@@ skipping 123 matching lines @@
                 str.printf("getSafeSize64() negative: %s",
                     getSkConfigName(tstSafeSize));
                 reporter->reportFailed(str);
             }
             bool sizeFail = false;
             // Compare against hand-computed values.
             switch (gPairs[i].fConfig) {
                 case SkBitmap::kNo_Config:
                     break;
 
-                case SkBitmap::kA1_Config:
-                    if (safeSize.fHi != 0x470DE ||
-                        safeSize.fLo != 0x4DF82000)
-                        sizeFail = true;
-                    break;
-
                 case SkBitmap::kA8_Config:
                 case SkBitmap::kIndex8_Config:
                     if (safeSize.fHi != 0x2386F2 ||
                         safeSize.fLo != 0x6FC10000)
                         sizeFail = true;
                     break;
 
                 case SkBitmap::kRGB_565_Config:
                 case SkBitmap::kARGB_4444_Config:
                     if (safeSize.fHi != 0x470DE4 ||
@@ skipping 10 matching lines @@
                 default:
                     break;
             }
             if (sizeFail) {
                 SkString str;
                 str.printf("getSafeSize64() wrong size: %s",
                     getSkConfigName(tstSafeSize));
                 reporter->reportFailed(str);
             }
 
-            int subW, subH;
-            // Set sizes to be height = 2 to force the last row of the
-            // source to be used, thus verifying correct operation if
-            // the bitmap is an extracted subset.
-            if (gPairs[i].fConfig == SkBitmap::kA1_Config) {
-                // If one-bit per pixel, use 9 pixels to force more than
-                // one byte per row.
-                subW = 9;
-                subH = 2;
-            } else {
-                // All other configurations are at least one byte per pixel,
-                // and different configs will test copying different numbers
-                // of bytes.
-                subW = subH = 2;
-            }
+            int subW = 2;
+            int subH = 2;
 
             // Create bitmap to act as source for copies and subsets.
             SkBitmap src, subset;
             SkColorTable* ct = NULL;
             if (isExtracted[copyCase]) { // A larger image to extract from.
                 src.setConfig(gPairs[i].fConfig, 2 * subW + 1, subH);
             } else { // Tests expect a 2x2 bitmap, so make smaller.
                 src.setConfig(gPairs[i].fConfig, subW, subH);
             }
             if (SkBitmap::kIndex8_Config == src.config()) {
                 ct = init_ctable(kPremul_SkAlphaType);
             }
 
             src.allocPixels(ct);
             SkSafeUnref(ct);
 
             // Either copy src or extract into 'subset', which is used
             // for subsequent calls to copyPixelsTo/From.
             bool srcReady = false;
             if (isExtracted[copyCase]) {
                 // The extractedSubset() test case allows us to test copy-
                 // ing when src and dst mave possibly different strides.
                 SkIRect r;
-                if (gPairs[i].fConfig == SkBitmap::kA1_Config)
-                    // This config seems to need byte-alignment of
-                    // extracted subset bits.
-                    r.set(0, 0, subW, subH);
-                else
-                    r.set(1, 0, 1 + subW, subH); // 2x2 extracted bitmap
+                r.set(1, 0, 1 + subW, subH); // 2x2 extracted bitmap
 
                 srcReady = src.extractSubset(&subset, r);
             } else {
                 srcReady = src.copyTo(&subset, src.config());
             }
 
             // Not all configurations will generate a valid 'subset'.
             if (srcReady) {
 
                 // Allocate our target buffer 'buf' for all copies.
@@ skipping 122 matching lines @@
                         false);
 
 #endif
             }
         } // for (size_t copyCase ...
     }
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("BitmapCopy", TestBitmapCopyClass, TestBitmapCopy)