SkSwizzler: Factor skipping zeros out into a helper function.

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"
@@ skipping 444 matching lines @@
     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(
+template <SkSwizzler::RowProc proc>
+SkSwizzler::ResultAlpha SkSwizzler::SkipLeading8888ZerosThen(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
+    SkASSERT(!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]);
-        }
-        src += deltaSrc;
+    auto src32 = (const uint32_t*)(src+offset);
+    auto dst32 = (uint32_t*)dstRow;
+
+    while (dstWidth > 0 && *src32 == 0) {

[scroggo, 2016/01/08 21:33:20]

FWIW, when we are premultiplying, we really only need to look at the alpha
value, since if the rest of them will be zero in the output whatever they are. I
don't know that that helps any, or that there are actually images encoded like
that.

+        dstWidth--;
+        dst32 += 1;
+        src32 += deltaSrc/4;
     }
-    return COMPUTE_RESULT_ALPHA;
+    return proc(dst32, (const uint8_t*)src32, dstWidth, bpp, deltaSrc, 0, ctable);
 }
 
 // kCMYK
 //
 // CMYK is stored as four bytes per pixel.
 //
 // We will implement a crude conversion from CMYK -> RGB using formulas
 // from easyrgb.com.
 //
 // CMYK -> CMY
@@ skipping 65 matching lines @@
         const uint8_t b = SkMulDiv255Round(src[2], src[3]);
 
         dst[x] = SkPack888ToRGB16(r, g, b);
         src += deltaSrc;
     }
 
     // CMYK is always opaque
     return SkSwizzler::kOpaque_ResultAlpha;
 }
 
-/**
-    FIXME: This was my idea to cheat in order to continue taking advantage of skipping zeroes.
-    This would be fine for drawing normally, but not for drawing with transfer modes. Being
-    honest means we can draw correctly with transfer modes, with the cost of not being able
-    to take advantage of Android's free unwritten pages. Something to keep in mind when we
-    decide whether to switch to unpremul default.
-static bool swizzle_rgba_to_n32_unpremul_skipZ(void* SK_RESTRICT dstRow,
-                                               const uint8_t* SK_RESTRICT src,
-                                               int dstWidth, int bitsPerPixel, int offset,
-                                               const SkPMColor[]) {
-    src += offset;
-    SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
-    unsigned alphaMask = 0xFF;
-    for (int x = 0; x < dstWidth; x++) {
-        unsigned alpha = src[3];
-        // NOTE: We cheat here. The caller requested unpremul and skip zeroes. It's possible
-        // the color components are not zero, but we skip them anyway, meaning they'll remain
-        // zero (implied by the request to skip zeroes).
-        if (0 != alpha) {
-            dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
-        }
-        src += deltaSrc;
-        alphaMask &= alpha;
-    }
-    return alphaMask != 0xFF;
-}
-*/
-
 SkSwizzler* SkSwizzler::CreateSwizzler(SkSwizzler::SrcConfig sc,
                                        const SkPMColor* ctable,
                                        const SkImageInfo& dstInfo,
                                        const SkCodec::Options& options,
                                        const SkIRect* frame) {
     if (dstInfo.colorType() == kUnknown_SkColorType || kUnknown == sc) {
         return nullptr;
     }
     if ((kIndex == sc || kIndex4 == sc || kIndex2 == sc || kIndex1 == sc)
             && nullptr == ctable) {
@@ skipping 114 matching lines @@
                 case kRGB_565_SkColorType:
                     proc = &swizzle_rgbx_to_565;
                 default:
                     break;
             }
             break;
         case kRGBA:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
-                        // Respect zeroInit?
-                        proc = &swizzle_rgba_to_n32_unpremul;
+                        if (SkCodec::kYes_ZeroInitialized == zeroInit) {
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
+                        } else {
+                            proc = &swizzle_rgba_to_n32_unpremul;
+                        }
                     } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
-                            proc = &swizzle_rgba_to_n32_premul_skipZ;
+                            proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_premul>;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kRGB:
@@ skipping 29 matching lines @@
         default:
             break;
     }
     if (nullptr == proc) {
         return nullptr;
     }
 
     // Store bpp in bytes if it is an even multiple, otherwise use bits
     int srcBPP = SkIsAlign8(BitsPerPixel(sc)) ? BytesPerPixel(sc) : BitsPerPixel(sc);
     int dstBPP = SkColorTypeBytesPerPixel(dstInfo.colorType());
-    
+
     int srcOffset = 0;
     int srcWidth = dstInfo.width();
     int dstOffset = 0;
     int dstWidth = srcWidth;
     if (options.fSubset) {
         // We do not currently support subset decodes for image types that may have
         // frames (gif).
         SkASSERT(!frame);
         srcOffset = options.fSubset->left();
         srcWidth = options.fSubset->width();
@@ skipping 33 matching lines @@
     fAllocatedWidth = get_scaled_dimension(fDstWidth, sampleX);
 
     return fAllocatedWidth;
 }
 
 SkSwizzler::ResultAlpha SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(nullptr != dst && nullptr != src);
     return fRowProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
             fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
 }