Scanline decoding for wbmp

src/codec/SkSwizzler.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 #include "SkUtils.h"
 
 SkSwizzler::ResultAlpha SkSwizzler::GetResult(uint8_t zeroAlpha,
                                               uint8_t maxAlpha) {
     // In the transparent case, this returns 0x0000
     // In the opaque case, this returns 0xFFFF
     // If the row is neither transparent nor opaque, returns something else
     return (((uint16_t) maxAlpha) << 8) | zeroAlpha;
 }
 
+// kBit
+// These routines exclusively choose between white and black
+
+#define GRAYSCALE_BLACK 0
+#define GRAYSCALE_WHITE 0xFF
+
+static SkSwizzler::ResultAlpha swizzle_bit_to_grayscale(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+    uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
+
+    // Determine how many full bytes are in the row
+    int bytesInRow = width >> 3;
+    int i;
+    for (i = 0; i < bytesInRow; i++) {
+        U8CPU currByte = src[i];
+        for (int j = 0; j < 8; j++) {
+            dst[j] = ((currByte >> (7 - j)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+        }
+        dst += 8;
+    }
+
+    // Finish the remaining bits
+    width &= 7;
+    U8CPU currByte = src[i];
+    for (int j = 0; j < width; j++) {
+        dst[j] = ((currByte >> 7) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+        currByte <<= 1;
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
+#undef GRAYSCALE_BLACK
+#undef GRAYSCALE_WHITE
+
+static SkSwizzler::ResultAlpha swizzle_bit_to_index(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+    uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
+
+    // Determine how many full bytes are in the row
+    int bytesInRow = width >> 3;
+    int i;
+    for (i = 0; i < bytesInRow; i++) {
+        U8CPU currByte = src[i];
+        for (int j = 0; j < 8; j++) {
+            dst[j] = (currByte >> (7 - j)) & 1;
+        }
+        dst += 8;
+    }
+
+    // Finish the remaining bits
+    width &= 7;
+    U8CPU currByte = src[i];
+    for (int j = 0; j < width; j++) {
+        dst[j] = ((currByte >> 7) & 1);
+        currByte <<= 1;
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
+static SkSwizzler::ResultAlpha swizzle_bit_to_n32(
+        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
+        int /*bitsPerPixel*/, const SkPMColor* /*ctable*/) {
+    SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
+
+    // Determine how many full bytes are in the row
+    int bytesInRow = width >> 3;
+    int i;
+    for (i = 0; i < bytesInRow; i++) {
+        U8CPU currByte = src[i];
+        for (int j = 0; j < 8; j++) {
+            dst[j] = ((currByte >> (7 - j)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+        }
+        dst += 8;
+    }
+
+    // Finish the remaining bits
+    width &= 7;
+    U8CPU currByte = src[i];
+    for (int j = 0; j < width; j++) {
+        dst[j] = ((currByte >> 7) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+        currByte <<= 1;
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
 // kIndex1, kIndex2, kIndex4
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int width,
         int bitsPerPixel, const SkPMColor ctable[]) {
 
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
     INIT_RESULT_ALPHA;
     const uint32_t pixelsPerByte = 8 / bitsPerPixel;
     const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
@@ skipping 245 matching lines @@
                                        SkCodec::ZeroInitialized zeroInit) {
     if (info.colorType() == kUnknown_SkColorType || kUnknown == sc) {
         return NULL;
     }
     if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
             && NULL == ctable) {
         return NULL;
     }
     RowProc proc = NULL;
     switch (sc) {
+        case kBit:
+            switch (info.colorType()) {
+                case kN32_SkColorType:
+                    proc = &swizzle_bit_to_n32;
+                    break;
+                case kIndex_8_SkColorType:
+                    proc = &swizzle_bit_to_index;
+                    break;
+                case kGray_8_SkColorType:
+                    proc = &swizzle_bit_to_grayscale;
+                    break;
+                default:
+                    break;
+            }
+            break;
         case kIndex1:
         case kIndex2:
         case kIndex4:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_small_index_to_n32;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_small_index_to_index;
                     break;
@@ skipping 181 matching lines @@
             // bits of SK_ColorBLACK are identical to the 565 representation
             // for black.
             memset(dstStartRow, (uint16_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }