NEON Optimized RGBA->PMColor sampling in SkSwizzler

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 "SkOpts.h"
 #include "SkSwizzler.h"
 #include "SkTemplates.h"
 
 static void copy(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
     // This function must not be called if we are sampling.  If we are not
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
     memcpy(dst, src + offset, width * bpp);
 }
 
-static void sample1(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
+static void sample_1bpp(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
     src += offset;
     uint8_t* dst8 = (uint8_t*) dst;
     for (int x = 0; x < width; x++) {
         dst8[x] = *src;
         src += deltaSrc;
     }
 }
 
-static void sample2(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
+static void sample_2bpp(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
     src += offset;
     uint16_t* dst16 = (uint16_t*) dst;
     for (int x = 0; x < width; x++) {
         dst16[x] = *((const uint16_t*) src);
         src += deltaSrc;
     }
 }
 
-static void sample4(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
+static void sample_4bpp(void* dst, const uint8_t* src, int width, int bpp, int deltaSrc, int offset,
         const SkPMColor ctable[]) {
     src += offset;
     uint32_t* dst32 = (uint32_t*) dst;
     for (int x = 0; x < width; x++) {
         dst32[x] = *((const uint32_t*) src);
         src += deltaSrc;
     }
 }
 
 // kBit
@@ skipping 442 matching lines @@
     // sampling, deltaSrc should equal bpp.
     SkASSERT(deltaSrc == bpp);
 
 #ifdef SK_PMCOLOR_IS_RGBA
     SkOpts::RGBA_to_rgbA((uint32_t*) dst, src + offset, width);
 #else
     SkOpts::RGBA_to_bgrA((uint32_t*) dst, src + offset, width);
 #endif
 }
 
+static void fast_sample2_rgba_to_n32_premul(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+        int offset, const SkPMColor ctable[]) {
+
+    // This function should only be called if the sampleSize is 2.
+    SkASSERT(deltaSrc == 2*bpp);
+
+    // TODO: Implementation.
+}
+
+static void fast_sample4_rgba_to_n32_premul(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+        int offset, const SkPMColor ctable[]) {
+
+    // This function should only be called if the sampleSize is 4.
+    SkASSERT(deltaSrc == 4*bpp);
+
+    // TODO: Implementation.
+}
+
+static void fast_sample8_rgba_to_n32_premul(
+        void* dst, const uint8_t* src, int width, int bpp, int deltaSrc,
+        int offset, const SkPMColor ctable[]) {
+
+    // This function should only be called if the sampleSize is 8.
+    SkASSERT(deltaSrc == 8*bpp);
+
+    // TODO: Implementation.
+}
+
 static void swizzle_rgba_to_n32_unpremul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     uint32_t* SK_RESTRICT dst = reinterpret_cast<uint32_t*>(dstRow);
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPackARGB32NoCheck(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
@@ skipping 135 matching lines @@
                                        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) {
         return nullptr;
     }
-    RowProc fastProc = nullptr;
+
     RowProc proc = nullptr;
+    FastProcs fastProcs;
     SkCodec::ZeroInitialized zeroInit = options.fZeroInitialized;
     switch (sc) {
         case kBit:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_bit_to_n32;
                     break;
                 case kIndex_8_SkColorType:
                     proc = &swizzle_bit_to_index;
                     break;
@@ skipping 33 matching lines @@
                         break;
                     } else {
                         proc = &swizzle_index_to_n32;
                         break;
                     }
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_index_to_565;
                     break;
                 case kIndex_8_SkColorType:
-                    proc = &sample1;
-                    fastProc = &copy;
+                    proc = &sample_1bpp;
+                    fastProcs.fSampleSize1 = &copy;
                     break;
                 default:
                     break;
             }
             break;
         case kGray:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_gray_to_n32;
-                    fastProc = &fast_swizzle_gray_to_n32;
+                    fastProcs.fSampleSize1 = &fast_swizzle_gray_to_n32;
                     break;
                 case kGray_8_SkColorType:
-                    proc = &sample1;
-                    fastProc = &copy;
+                    proc = &sample_1bpp;
+                    fastProcs.fSampleSize1 = &copy;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_gray_to_565;
                     break;
                 default:
                     break;
             }
             break;
         case kGrayAlpha:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeadingGrayAlphaZerosThen
                                     <swizzle_grayalpha_to_n32_unpremul>;
-                            fastProc = &SkipLeadingGrayAlphaZerosThen
+                            fastProcs.fSampleSize1 = &SkipLeadingGrayAlphaZerosThen
                                     <fast_swizzle_grayalpha_to_n32_unpremul>;
                         } else {
                             proc = &swizzle_grayalpha_to_n32_unpremul;
-                            fastProc = &fast_swizzle_grayalpha_to_n32_unpremul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_grayalpha_to_n32_unpremul;
                         }
                     } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeadingGrayAlphaZerosThen<swizzle_grayalpha_to_n32_premul>;
-                            fastProc = &SkipLeadingGrayAlphaZerosThen
+                            fastProcs.fSampleSize1 = &SkipLeadingGrayAlphaZerosThen
                                     <fast_swizzle_grayalpha_to_n32_premul>;
                         } else {
                             proc = &swizzle_grayalpha_to_n32_premul;
-                            fastProc = &fast_swizzle_grayalpha_to_n32_premul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_grayalpha_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kBGR:
         case kBGRX:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_bgrx_to_n32;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_bgrx_to_565;
                     break;
                 default:
                     break;
             }
             break;
         case kBGRA:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_unpremul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_unpremul>;
+                            fastProcs.fSampleSize1 = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_bgra_to_n32_unpremul>;
                         } else {
                             proc = &swizzle_bgra_to_n32_unpremul;
-                            fastProc = &fast_swizzle_bgra_to_n32_unpremul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_bgra_to_n32_unpremul;
                         }
                     } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeading8888ZerosThen<swizzle_bgra_to_n32_premul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_bgra_to_n32_premul>;
+                            fastProcs.fSampleSize1 = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_bgra_to_n32_premul>;
                         } else {
                             proc = &swizzle_bgra_to_n32_premul;
-                            fastProc = &fast_swizzle_bgra_to_n32_premul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_bgra_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kRGB:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgb_to_n32;
-                    fastProc = &fast_swizzle_rgb_to_n32;
+                    fastProcs.fSampleSize1 = &fast_swizzle_rgb_to_n32;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_rgb_to_565;
                 default:
                     break;
             }
             break;
         case kRGBA:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     if (dstInfo.alphaType() == kUnpremul_SkAlphaType) {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_unpremul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_unpremul>;
+                            fastProcs.fSampleSize1 = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_rgba_to_n32_unpremul>;
                         } else {
                             proc = &swizzle_rgba_to_n32_unpremul;
-                            fastProc = &fast_swizzle_rgba_to_n32_unpremul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_rgba_to_n32_unpremul;
                         }
                     } else {
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &SkipLeading8888ZerosThen<swizzle_rgba_to_n32_premul>;
-                            fastProc = &SkipLeading8888ZerosThen<fast_swizzle_rgba_to_n32_premul>;
+                            fastProcs.fSampleSize1 = &SkipLeading8888ZerosThen
+                                    <fast_swizzle_rgba_to_n32_premul>;
+                            fastProcs.fSampleSize2 = &SkipLeading8888ZerosThen
+                                    <fast_sample2_rgba_to_n32_premul>;
+                            fastProcs.fSampleSize4 = &SkipLeading8888ZerosThen
+                                    <fast_sample4_rgba_to_n32_premul>;
+                            fastProcs.fSampleSize8 = &SkipLeading8888ZerosThen
+                                    <fast_sample8_rgba_to_n32_premul>;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
-                            fastProc = &fast_swizzle_rgba_to_n32_premul;
+                            fastProcs.fSampleSize1 = &fast_swizzle_rgba_to_n32_premul;
+                            fastProcs.fSampleSize2 = &fast_sample2_rgba_to_n32_premul;
+                            fastProcs.fSampleSize4 = &fast_sample4_rgba_to_n32_premul;
+                            fastProcs.fSampleSize8 = &fast_sample8_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kCMYK:
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_cmyk_to_n32;
                     break;
                 case kRGB_565_SkColorType:
                     proc = &swizzle_cmyk_to_565;
                     break;
                 default:
                     break;
             }
             break;
         case kNoOp8:
-            proc = &sample1;
-            fastProc = &copy;
+            proc = &sample_1bpp;
+            fastProcs.fSampleSize1 = &copy;
             break;
         case kNoOp16:
-            proc = sample2;
-            fastProc = &copy;
+            proc = sample_2bpp;
+            fastProcs.fSampleSize1 = &copy;
             break;
         case kNoOp32:
-            proc = &sample4;
-            fastProc = &copy;
+            proc = &sample_4bpp;
+            fastProcs.fSampleSize1 = &copy;
             break;
         default:
             break;
     }
 
     // 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();
         dstWidth = srcWidth;
     } else if (frame) {
         dstOffset = frame->left();
         srcWidth = frame->width();
     }
 
-    return new SkSwizzler(fastProc, proc, ctable, srcOffset, srcWidth, dstOffset, dstWidth,
+    return new SkSwizzler(proc, fastProcs, ctable, srcOffset, srcWidth, dstOffset, dstWidth,
             srcBPP, dstBPP);
 }
 
-SkSwizzler::SkSwizzler(RowProc fastProc, RowProc proc, const SkPMColor* ctable, int srcOffset,
-        int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP)
-    : fFastProc(fastProc)
-    , fSlowProc(proc)
-    , fActualProc(fFastProc ? fFastProc : fSlowProc)
+SkSwizzler::SkSwizzler(RowProc proc, const FastProcs& fastProcs, const SkPMColor* ctable,
+        int srcOffset, int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP)
+    : fSlowProc(proc)
+    , fFastProcs(fastProcs)
+    , fActualProc(fFastProcs.fSampleSize1 ? fFastProcs.fSampleSize1 : fSlowProc)
     , fColorTable(ctable)
     , fSrcOffset(srcOffset)
     , fDstOffset(dstOffset)
     , fSrcOffsetUnits(srcOffset * srcBPP)
     , fDstOffsetBytes(dstOffset * dstBPP)
     , fSrcWidth(srcWidth)
     , fDstWidth(dstWidth)
     , fSwizzleWidth(srcWidth)
     , fAllocatedWidth(dstWidth)
     , fSampleX(1)
     , fSrcBPP(srcBPP)
     , fDstBPP(dstBPP)
 {}
 
 int SkSwizzler::onSetSampleX(int sampleX) {
     SkASSERT(sampleX > 0); // Surely there is an upper limit? Should there be
                            // way to report failure?
     fSampleX = sampleX;
     fSrcOffsetUnits = (get_start_coord(sampleX) + fSrcOffset) * fSrcBPP;
     fDstOffsetBytes = (fDstOffset / sampleX) * fDstBPP;
     fSwizzleWidth = get_scaled_dimension(fSrcWidth, sampleX);
     fAllocatedWidth = get_scaled_dimension(fDstWidth, sampleX);
 
-    // The optimized swizzler routines do not (yet) support sampling.
-    if (1 == fSampleX && fFastProc) {
-        fActualProc = fFastProc;
+    // Choose an optimized swizzler function (if it exists).
+    if (1 == fSampleX && fFastProcs.fSampleSize1) {

[scroggo, 2016/02/09 13:06:10]

Why not:

switch (fSampleX) {
  case 1:
    fActualProc = fFastProcs.fSampleSize;
    break;
  ...
}

if (!fActualProc) {
  fActualProc = fSlowProc;
}

(A little bit cleaner to me, but maybe a matter of preference.)

[msarett, 2016/02/10 00:36:19]

I agree this is nicer.  Done.

+        fActualProc = fFastProcs.fSampleSize1;
+    } else if (2 == fSampleX && fFastProcs.fSampleSize2) {
+        fActualProc = fFastProcs.fSampleSize2;
+    } else if (4 == fSampleX && fFastProcs.fSampleSize4) {
+        fActualProc = fFastProcs.fSampleSize4;
+    } else if (8 == fSampleX && fFastProcs.fSampleSize8) {
+        fActualProc = fFastProcs.fSampleSize8;
     } else {
         fActualProc = fSlowProc;
     }
 
     return fAllocatedWidth;
 }
 
 void SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(nullptr != dst && nullptr != src);
     fActualProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
             fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
 }