Scanline decoding for bmp

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 "SkScaledCodec.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;
 }
 
 // samples the row. Does not do anything else but sampling
 static SkSwizzler::ResultAlpha sample565(void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src,
-        int width, int deltaSrc, int offset, const SkPMColor ctable[]){
+        int width, int bpp, int deltaSrc, int offset, const SkPMColor ctable[]){
 
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*) dstRow;
     for (int x = 0; x < width; x++) {
         dst[x] = src[1] << 8 | src[0];
         src += deltaSrc;
     }
     // 565 is always opaque
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kBit
 // These routines exclusively choose between white and black
 
 #define GRAYSCALE_BLACK 0
 #define GRAYSCALE_WHITE 0xFF
 
 
 // same as swizzle_bit_to_index and swizzle_bit_to_n32 except for value assigned to dst[x]
 static SkSwizzler::ResultAlpha swizzle_bit_to_grayscale(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
+        int bpp, int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
 
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
 
     // increment src by byte offset and bitIndex by bit offset
     src += offset / 8;
     int bitIndex = offset % 8;
     uint8_t currByte = *src;
 
     dst[0] = ((currByte >> (7-bitIndex)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
 
     for (int x = 1; x < dstWidth; x++) {
         int bitOffset = bitIndex + deltaSrc;
         bitIndex = bitOffset % 8;
         currByte = *(src += bitOffset / 8);
         dst[x] = ((currByte >> (7-bitIndex)) & 1) ? GRAYSCALE_WHITE : GRAYSCALE_BLACK;
     }
 
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 #undef GRAYSCALE_BLACK
 #undef GRAYSCALE_WHITE
 
 // same as swizzle_bit_to_grayscale and swizzle_bit_to_n32 except for value assigned to dst[x]
 static SkSwizzler::ResultAlpha swizzle_bit_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
+        int bpp, int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
 
     // increment src by byte offset and bitIndex by bit offset
     src += offset / 8;
     int bitIndex = offset % 8;
     uint8_t currByte = *src;
 
     dst[0] = ((currByte >> (7-bitIndex)) & 1);
 
     for (int x = 1; x < dstWidth; x++) {
         int bitOffset = bitIndex + deltaSrc;
         bitIndex = bitOffset % 8;
         currByte = *(src += bitOffset / 8);
         dst[x] = ((currByte >> (7-bitIndex)) & 1);
     }
 
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // same as swizzle_bit_to_grayscale and swizzle_bit_to_index except for value assigned to dst[x]
 static SkSwizzler::ResultAlpha swizzle_bit_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
+        int bpp, int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
     SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
 
     // increment src by byte offset and bitIndex by bit offset
     src += offset / 8;
     int bitIndex = offset % 8;
     uint8_t currByte = *src;
 
     dst[0] = ((currByte >> (7 - bitIndex)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
 
     for (int x = 1; x < dstWidth; x++) {
         int bitOffset = bitIndex + deltaSrc;
         bitIndex = bitOffset % 8;
         currByte = *(src += bitOffset / 8);
         dst[x] = ((currByte >> (7 - bitIndex)) & 1) ? SK_ColorWHITE : SK_ColorBLACK;
     }
 
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 #define RGB565_BLACK 0
 #define RGB565_WHITE 0xFFFF
 
 static SkSwizzler::ResultAlpha swizzle_bit_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
+        int bpp, int deltaSrc, int offset, const SkPMColor* /*ctable*/) {
     uint16_t* SK_RESTRICT dst = (uint16_t*) dstRow;
 
     // increment src by byte offset and bitIndex by bit offset
     src += offset / 8;
     int bitIndex = offset % 8;
     uint8_t currByte = *src;
 
     dst[0] = ((currByte >> (7 - bitIndex)) & 1) ? RGB565_WHITE : RGB565_BLACK;
 
     for (int x = 1; x < dstWidth; x++) {
         int bitOffset = bitIndex + deltaSrc;
         bitIndex = bitOffset % 8;
         currByte = *(src += bitOffset / 8);
         dst[x] = ((currByte >> (7 - bitIndex)) & 1) ? RGB565_WHITE : RGB565_BLACK;
     }
 
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 #undef RGB565_BLACK
 #undef RGB565_WHITE
 
 // kIndex1, kIndex2, kIndex4
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_index(

[msarett, 2015/08/19 14:22:40]

These functions use a similar strategy to the swizzle_bit functions.

[scroggo, 2015/08/26 22:40:09]

I'm not sure I understand the comment. Should this comment go in the code? Or
are you proposing merging them somehow?

[msarett, 2015/08/27 15:00:27]

I was just trying to provide some context for how I redesigned these in case it
helps with the review.

         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bitsPerPixel, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
-    src += offset;
-    uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
+    uint8_t* dst = (uint8_t*) dstRow;
     INIT_RESULT_ALPHA;
-    const uint32_t pixelsPerByte = 8 / bitsPerPixel;
-    const size_t rowBytes = compute_row_bytes_ppb(dstWidth, 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 < dstWidth; p++) {
-            uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
-            UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
-            dst[x] = index;
-            pixelData <<= bitsPerPixel;
-            x++;
-        }
+    src += offset / 8;
+    int bitIndex = offset % 8;
+    uint8_t currByte = *src;
+    const uint8_t mask = (1 << bpp) - 1;

[msarett, 2015/08/19 14:22:40]

Unfortunately, these functions need to know the bitsPerPixel.  We could
eliminate a parameter by passing sampleX instead of deltaSrc and offset, but
that would bring more math into these swizzling functions.  I think it's fine as
is, but am happy with it either way.

+    uint8_t index = (currByte >> (8 - bpp - bitIndex)) & mask;
+    dst[0] = index;
+    UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
+
+    for (int x = 1; x < dstWidth; x++) {
+        int bitOffset = bitIndex + deltaSrc;
+        bitIndex = bitOffset % 8;
+        currByte = *(src += bitOffset / 8);
+        index = (currByte >> (8 - bpp - bitIndex)) & mask;
+        dst[x] = index;
+        UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bitsPerPixel, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
-    src += offset;
-    uint16_t* SK_RESTRICT dst = (uint16_t*) dstRow;
-    const uint32_t pixelsPerByte = 8 / bitsPerPixel;
-    const size_t rowBytes = compute_row_bytes_ppb(dstWidth, 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 < dstWidth; p++) {
-            uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
-            uint16_t c = SkPixel32ToPixel16(ctable[index]);
-            dst[x] = c;
-            pixelData <<= bitsPerPixel;
-            x++;
-        }
+    uint16_t* dst = (uint16_t*) dstRow;
+    INIT_RESULT_ALPHA;
+    src += offset / 8;
+    int bitIndex = offset % 8;
+    uint8_t currByte = *src;
+    const uint8_t mask = (1 << bpp) - 1;
+    uint8_t index = (currByte >> (8 - bpp - bitIndex)) & mask;
+    dst[0] = SkPixel32ToPixel16(ctable[index]);
+
+    for (int x = 1; x < dstWidth; x++) {
+        int bitOffset = bitIndex + deltaSrc;
+        bitIndex = bitOffset % 8;
+        currByte = *(src += bitOffset / 8);
+        index = (currByte >> (8 - bpp - bitIndex)) & mask;
+        dst[x] = SkPixel32ToPixel16(ctable[index]);
     }
-    return SkSwizzler::kOpaque_ResultAlpha;
+    return SkAlphaType::kOpaque_SkAlphaType;
 }
 
 static SkSwizzler::ResultAlpha swizzle_small_index_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bitsPerPixel, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
-    src += offset;
-    SkPMColor* SK_RESTRICT dst = (SkPMColor*) dstRow;
+    SkPMColor* dst = (SkPMColor*) dstRow;
     INIT_RESULT_ALPHA;
-    const uint32_t pixelsPerByte = 8 / bitsPerPixel;
-    const size_t rowBytes = compute_row_bytes_ppb(dstWidth, 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 < dstWidth; p++) {
-            uint8_t index = (pixelData >> (8 - bitsPerPixel)) & mask;
-            SkPMColor c = ctable[index];
-            UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
-            dst[x] = c;
-            pixelData <<= bitsPerPixel;
-            x++;
-        }
+    src += offset / 8;
+    int bitIndex = offset % 8;
+    uint8_t currByte = *src;
+    const uint8_t mask = (1 << bpp) - 1;
+    uint8_t index = (currByte >> (8 - bpp - bitIndex)) & mask;
+    dst[0] = ctable[index];
+    UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
+
+    for (int x = 1; x < dstWidth; x++) {
+        int bitOffset = bitIndex + deltaSrc;
+        bitIndex = bitOffset % 8;
+        currByte = *(src += bitOffset / 8);
+        index = (currByte >> (8 - bpp - bitIndex)) & mask;
+        dst[x] = ctable[index];
+        UPDATE_RESULT_ALPHA(ctable[index] >> SK_A32_SHIFT);
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 // kIndex
 
 static SkSwizzler::ResultAlpha swizzle_index_to_index(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
     INIT_RESULT_ALPHA;
     // TODO (msarett): Should we skip the loop here and guess that the row is opaque/not opaque?
     //                 SkScaledBitmap sampler just guesses that it is opaque.  This is dangerous
     //                 and probably wrong since gif and bmp (rarely) may have alpha.
     if (1 == deltaSrc) {
         // A non-zero offset is only used when sampling, meaning that deltaSrc will be
         // greater than 1. The below loop relies on the fact that src remains unchanged.
         SkASSERT(0 == offset);
         memcpy(dst, src, dstWidth);
         for (int x = 0; x < dstWidth; x++) {
             UPDATE_RESULT_ALPHA(ctable[src[x]] >> SK_A32_SHIFT);
         }
     } else {
         for (int x = 0; x < dstWidth; x++) {
             dst[x] = *src;
             UPDATE_RESULT_ALPHA(ctable[*src] >> SK_A32_SHIFT);
             src += deltaSrc;
         }
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         SkPMColor c = ctable[*src];
         UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
         dst[x] = c;
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_n32_skipZ(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         SkPMColor c = ctable[*src];
         UPDATE_RESULT_ALPHA(c >> SK_A32_SHIFT);
         if (c != 0) {
             dst[x] = c;
         }
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_index_to_565(
       void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-      int bytesPerPixel, int offset, const SkPMColor ctable[]) {
+      int bytesPerPixel, int deltaSrc, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering? Requires knowing y, which I think is a bigger
     // change.
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPixel32ToPixel16(ctable[*src]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 
 #undef A32_MASK_IN_PLACE
 
 // kGray
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPackARGB32NoCheck(0xFF, *src, *src, *src);
         src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_gray(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint8_t* SK_RESTRICT dst = (uint8_t*) dstRow;
     if (1 == deltaSrc) {
         memcpy(dstRow, src, dstWidth);
     } else {
         for (int x = 0; x < dstWidth; x++) {
             dst[x] = src[0];
             src += deltaSrc;
         }
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_gray_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int bytesPerPixel, int offset, const SkPMColor ctable[]) {
+        int bytesPerPixel, int deltaSrc, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering?
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPack888ToRGB16(src[0], src[0], src[0]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kBGRX
 
 static SkSwizzler::ResultAlpha swizzle_bgrx_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPackARGB32NoCheck(0xFF, src[2], src[1], src[0]);
         src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_bgrx_to_565(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering?
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPack888ToRGB16(src[2], src[1], src[0]);
         src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 // kBGRA
 
 static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         uint8_t alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPackARGB32NoCheck(alpha, src[2], src[1], src[0]);
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_bgra_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         uint8_t alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPreMultiplyARGB(alpha, src[2], src[1], src[0]);
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 // kRGBX
 static SkSwizzler::ResultAlpha swizzle_rgbx_to_n32(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPackARGB32(0xFF, src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgbx_to_565(
        void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-       int bytesPerPixel, int offset, const SkPMColor ctable[]) {
+       int bytesPerPixel, int deltaSrc, int offset, const SkPMColor ctable[]) {
     // FIXME: Support dithering?
     src += offset;
     uint16_t* SK_RESTRICT dst = (uint16_t*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         dst[x] = SkPack888ToRGB16(src[0], src[1], src[2]);
-        src += bytesPerPixel;
+        src += deltaSrc;
     }
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
 
 // kRGBA
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
     }
     return COMPUTE_RESULT_ALPHA;
 }
 
 static SkSwizzler::ResultAlpha swizzle_rgba_to_n32_premul_skipZ(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
-        int deltaSrc, int offset, const SkPMColor ctable[]) {
+        int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     INIT_RESULT_ALPHA;
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
         UPDATE_RESULT_ALPHA(alpha);
         if (0 != alpha) {
             dst[x] = SkPreMultiplyARGB(alpha, src[0], src[1], src[2]);
         }
@@ skipping 212 matching lines @@
     return SkNEW_ARGS(SkSwizzler, (proc, ctable, deltaSrc, dstInfo, sampleX));
 }
 
 SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable,
                        int deltaSrc, const SkImageInfo& info, int sampleX)
     : fRowProc(proc)
     , fColorTable(ctable)
     , fDeltaSrc(deltaSrc)
     , fDstInfo(info)
     , fSampleX(sampleX)
-    , fX0(sampleX == 1 ? 0 : sampleX >> 1)
+    , fX0(SkScaledCodec::GetStartCoord(sampleX))
 {
     // check that fX0 is less than original width
     SkASSERT(fX0 >= 0 && fX0 < fDstInfo.width() * fSampleX);
 }
 
 SkSwizzler::ResultAlpha SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(NULL != dst && NULL != src);
-    return fRowProc(dst, src, fDstInfo.width(), fSampleX * fDeltaSrc, fX0 * fDeltaSrc, fColorTable);
+    return fRowProc(dst, src, fDstInfo.width(), fDeltaSrc, fSampleX * fDeltaSrc,
+            fX0 * fDeltaSrc, fColorTable);
 }
 
 void SkSwizzler::Fill(void* dstStartRow, const SkImageInfo& dstInfo, size_t dstRowBytes,

[msarett, 2015/08/19 14:22:40]

Sorry I didn't mean to put all of this refactoring of the Fill() function in
this CL.  There are incomplete bmps on the bots, so SkScaledCodec needs to
support filling.  I originally thought SkScaledCodec would call Fill(), but I've
actually implemented it so that is not necessary.

I think a follow up CL will need to test on incomplete images on all types.  I
suspect that we don't handle incomplete pngs gracefully.

-        uint32_t numRows, uint32_t colorOrIndex, const SkPMColor* colorTable) {
+        uint32_t numRows, uint32_t colorOrIndex, const SkPMColor* colorTable,
+        SkCodec::ZeroInitialized zeroInit) {
     SkASSERT(dstStartRow != NULL);
     SkASSERT(numRows <= (uint32_t) dstInfo.height());
 
     // Calculate bytes to fill.  We use getSafeSize since the last row may not be padded.
     const size_t bytesToFill = dstInfo.makeWH(dstInfo.width(), numRows).getSafeSize(dstRowBytes);
 
     // Use the proper memset routine to fill the remaining bytes
     switch(dstInfo.colorType()) {
         case kN32_SkColorType:
             // Assume input is an index if we have a color table
             uint32_t color;
             if (NULL != colorTable) {
-                SkASSERT(colorOrIndex == (uint8_t) colorOrIndex);
-                color = colorTable[colorOrIndex];
+                color = colorTable[(uint8_t) colorOrIndex];
             // Otherwise, assume the input is a color
             } else {
                 color = colorOrIndex;
             }
 
+            // If memory is zero initialized, we may not need to fill
+            if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == color) {

[msarett, 2015/08/19 14:22:40]

This fixes a bug.

We used to check if colorOrIndex was 0 instead of if color is 0.  When the
output color type is kN32, we really need to know if the actual color is 0.

When I follow up with a CL testing incomplete images, I'll add a test.

+                return;
+            }
+
             // We must fill row by row in the case of unaligned row bytes
             if (SkIsAlign4((size_t) dstStartRow) && SkIsAlign4(dstRowBytes)) {
                 sk_memset32((uint32_t*) dstStartRow, color,
                         (uint32_t) bytesToFill / sizeof(SkPMColor));
             } else {
                 // This is an unlikely, slow case
                 SkCodecPrintf("Warning: Strange number of row bytes, fill will be slow.\n");
                 uint32_t* dstRow = (uint32_t*) dstStartRow;
                 for (uint32_t row = 0; row < numRows; row++) {
                     for (int32_t col = 0; col < dstInfo.width(); col++) {
                         dstRow[col] = color;
                     }
                     dstRow = SkTAddOffset<uint32_t>(dstRow, dstRowBytes);
                 }
             }
             break;
-        // On an index destination color type, always assume the input is an index
-        case kIndex_8_SkColorType:
-            SkASSERT(colorOrIndex == (uint8_t) colorOrIndex);
-            memset(dstStartRow, colorOrIndex, bytesToFill);
-            break;
-        case kGray_8_SkColorType:
-            // If the destination is kGray, the caller passes in an 8-bit color.
-            // We will not assert that the high bits of colorOrIndex must be zeroed.
-            // This allows us to take advantage of the fact that the low 8 bits of an
-            // SKPMColor may be a valid a grayscale color.  For example, the low 8
-            // bits of SK_ColorBLACK are identical to the grayscale representation
-            // for black. 
-            memset(dstStartRow, (uint8_t) colorOrIndex, bytesToFill);
-            break;
         case kRGB_565_SkColorType:
             // If the destination is k565, the caller passes in a 16-bit color.
             // We will not assert that the high bits of colorOrIndex must be zeroed.
             // This allows us to take advantage of the fact that the low 16 bits of an
             // SKPMColor may be a valid a 565 color.  For example, the low 16
             // bits of SK_ColorBLACK are identical to the 565 representation
             // for black.
-            memset(dstStartRow, (uint16_t) colorOrIndex, bytesToFill);
+            // If we ever want to fill with colorOrIndex != 0, we will probably need
+            // to implement this with sk_memset16().
+            SkASSERT((uint16_t) colorOrIndex == (uint8_t) colorOrIndex);
+            // Fall through
+        case kIndex_8_SkColorType:
+            // On an index destination color type, always assume the input is an index.
+            // Fall through
+        case kGray_8_SkColorType:
+            // If the destination is kGray, the caller passes in an 8-bit color.
+            // We will not assert that the high bits of colorOrIndex must be zeroed.
+            // This allows us to take advantage of the fact that the low 8 bits of an
+            // SKPMColor may be a valid a grayscale color.  For example, the low 8
+            // bits of SK_ColorBLACK are identical to the grayscale representation
+            // for black.
+
+            // If memory is zero initialized, we may not need to fill
+            if (SkCodec::kYes_ZeroInitialized == zeroInit && 0 == (uint8_t) colorOrIndex) {

[msarett, 2015/08/19 14:22:40]

This fixes a bug.

Only the low 8-bits of colorOrIndex need to be 0 for this to qualify as a zero
fill.

+                return;
+            }
+
+            memset(dstStartRow, (uint8_t) colorOrIndex, bytesToFill);
             break;
         default:
             SkCodecPrintf("Error: Unsupported dst color type for fill().  Doing nothing.\n");
             SkASSERT(false);
             break;
     }
 }