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[]) {

[scroggo, 2015/07/29 17:47:12]

I believe these parameters are unused? I think we have some macros for
documenting/enforcing that, but I believe they are used sporadically.

Another approach would be to declare them like so:

int /* bitsPerPixel */, const SkPMColor* /* ctable */

[msarett, 2015/07/29 18:53:57]

Done.

+    uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
+    int bytes = width >> 3;
+    for (int i = 0; i < bytes; i++) {
+        U8CPU mask = *src++;

[scroggo, 2015/07/29 17:47:12]

I don't have an idea for a better name for this, but I feel like a "mask" is
something which does masking, whereas this is the thing being masked?

[msarett, 2015/07/29 18:53:57]

Yeah you're right.  Renaming to currByte.

+        for (int j = 0; j < 8; j++) {
+            dst[j] = ((mask >> (7 - j)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+        }
+        dst += 8;

[scroggo, 2015/07/29 17:47:12]

It seems a little odd that here you index dst and then add 8, but below you do
pointer arithmetic on dst. I suppose it's because here you happen to also need j
for other reasons?

[msarett, 2015/07/29 18:53:57]

There is no reason for this other than that is how it was done before.  Which is
not a good reason.

I prefer not using ptr arithmetic and have made changes.  Sorry I didn't really
look this routine over, I just borrowed it from SkCodec_wbmp.

[scroggo, 2015/07/29 21:49:16]

I do not have a problem with pointer arithmetic in general; my only confusion
reading the code was that one block used it, and the other used indices.

+    }
+    width &= 7;
+    if (width > 0) {
+        U8CPU mask = *src;
+        do {
+            *dst++ = ((mask >> 7) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+            mask <<= 1;
+        } while (--width != 0);
+    }
+    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;
+    int bytes = width >> 3;
+    for (int i = 0; i < bytes; i++) {
+        U8CPU mask = *src++;
+        for (int j = 0; j < 8; j++) {
+            dst[j] = (mask >> (7 - j)) & 1;
+        }
+        dst += 8;
+    }
+    width &= 7;
+    if (width > 0) {
+        U8CPU mask = *src;
+        do {
+            *dst++ = (mask >> 7) & 1;
+            mask <<= 1;
+        } while (--width != 0);
+    }
+    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;
+    int bytes = width >> 3;
+    for (int i = 0; i < bytes; i++) {
+        U8CPU mask = *src++;
+        for (int j = 0; j < 8; j++) {
+            dst[j] = ((mask >> (7 - j)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+        }
+        dst += 8;
+    }
+    width &= 7;
+    if (width > 0) {
+        U8CPU mask = *src;
+        do {
+            *dst++ = ((mask >> 7) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
+            mask <<= 1;
+        } while (--width != 0);
+    }
+    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 172 matching lines @@
             // bits of SK_ColorBLACK are identical to the grayscale representation
             // for black. 
             memset(dstStartRow, (uint8_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }