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);
+
+#ifdef SK_PMCOLOR_IS_RGBA
+    SkOpts::RGBA_to_rgbA_sample2((uint32_t*) dst, src + offset, width);

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

For sampling, whether or not to add "offset" here is an interesting question. 
"offset" is always non-zero if we are sampling (since we will skip the first x
pixels).

If we don't add offset, the opt functions must skip some pixels in src before
choosing the pixels we want.

If we do add offset, the opt functions must always keep the first pixel in src.

This leads to different implementations (I've done both, since I messed up the
first time :)).  I *think* this is the best way.

+#else
+    SkOpts::RGBA_to_bgrA_sample2((uint32_t*) dst, src + offset, width);
+#endif
+}
+
+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);
+
+#ifdef SK_PMCOLOR_IS_RGBA
+    SkOpts::RGBA_to_rgbA_sample4((uint32_t*) dst, src + offset, width);
+#else
+    SkOpts::RGBA_to_bgrA_sample4((uint32_t*) dst, src + offset, width);
+#endif
+}
+
+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);
+
+#ifdef SK_PMCOLOR_IS_RGBA
+    SkOpts::RGBA_to_rgbA_sample8((uint32_t*) dst, src + offset, width);
+#else
+    SkOpts::RGBA_to_bgrA_sample8((uint32_t*) dst, src + offset, width);
+#endif
+}
+
 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 150 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;
                     break;
                 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;
-                    fastProc = &fast_swizzle_cmyk_to_n32;
+                    fastProcs.fSampleSize1 = &fast_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;
-    } else {
+    // Choose an optimized swizzler function (if it exists).
+    fActualProc = nullptr;
+    switch (fSampleX) {
+        case 1:
+            fActualProc = fFastProcs.fSampleSize1;
+            break;
+        case 2:
+            fActualProc = fFastProcs.fSampleSize2;
+            break;
+        case 4:
+            fActualProc = fFastProcs.fSampleSize4;
+            break;
+        case 8:
+            fActualProc = fFastProcs.fSampleSize8;
+            break;
+        default:
+            break;
+    }
+
+    // Otherwise, use fSlowProc.
+    if (!fActualProc) {
         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);
 }