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;
 }
 
 // kIndex1, kIndex2, kIndex4
 
+#define GRAYSCALE_BLACK 0

[scroggo, 2015/07/28 14:03:34]

I'm kind of surprised we do not have these already defined somewhere.

[msarett, 2015/07/28 22:22:07]

Me too, but I looked a little harder and I actually can't find them.  They
aren't with the others in SkColor.h.  I could use SK_AlphaTRANSPARENT and
SK_AlphaOPAQUE but I think that would be confusing.  Also I could just put 0xFF
and 0x00 in the code.

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

No, I think what you've done here is perfect!

+#define GRAYSCALE_WHITE 0xFF
+
+// This routine is currently expected to be used exclusively by wbmp.

[scroggo, 2015/07/28 14:03:34]

What is wbmp-specific about it? I suppose just that it's the only class which
exclusively chooses between white and black? Maybe that would be a better
description?

[msarett, 2015/07/28 22:22:07]

Agreed.

+static SkSwizzler::ResultAlpha swizzle_small_index_to_gray(
+        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;

[scroggo, 2015/07/28 14:03:34]

It's too bad we have to have a divide for each row, especially since it does not
change for the whole image. Is there any way to factor this out and pass it to
the function?

Overall, do you know what the performance hit will be for switching to using the
swizzler? It would be nice to minimize it.

[msarett, 2015/07/28 22:22:07]

Yeah I wanted wbmp to share with small_index, but that has lead to annoying
color table code and a performance hit.  I am adding kBit config to the swizzler
and giving wbmp its own routines.  These are almost identical to the original.

+    const size_t rowBytes = compute_row_bytes_ppb(width, pixelsPerByte);
+    const uint8_t mask = (1 << bitsPerPixel) - 1;
+    int x = 0;
+    for (uint32_t byte = 0; byte < rowBytes; byte++) {
+        uint8_t pixelData = src[byte];
+        for (uint32_t p = 0; p < pixelsPerByte && x < width; p++) {
+            uint8_t bit = (pixelData >> (8 - bitsPerPixel)) & mask;
+            dst[x] = bit ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
+            pixelData <<= bitsPerPixel;
+            x++;
+        }
+    }
+    return SkSwizzler::kOpaque_ResultAlpha;
+}
+
+#undef GRAYSCALE_BLACK
+#undef GRAYSCALE_WHITE
+
 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);
     const uint8_t mask = (1 << bitsPerPixel) - 1;
     int x = 0;
@@ skipping 253 matching lines @@
         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;
+                case kGray_8_SkColorType:
+                    proc = &swizzle_small_index_to_gray;
                 default:
                     break;
             }
             break;
         case kIndex:
             switch (info.colorType()) {
                 case kN32_SkColorType:
                     // We assume the color premultiplied ctable (or not) as desired.
                     if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                         proc = &swizzle_index_to_n32_skipZ;
@@ skipping 162 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;
     }
 }