Use SkOpts routines 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"
 
 // samples the row. Does not do anything else but sampling
 static void sample565(void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src,
         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++) {
@@ skipping 340 matching lines @@
        int bytesPerPixel, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     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 += deltaSrc;
     }
 }
 
-
 // kRGBA
 static void swizzle_rgba_to_n32_premul(
         void* SK_RESTRICT dstRow, const uint8_t* SK_RESTRICT src, int dstWidth,
         int bpp, int deltaSrc, int offset, const SkPMColor ctable[]) {
 
     src += offset;
     SkPMColor* SK_RESTRICT dst = (SkPMColor*)dstRow;
     for (int x = 0; x < dstWidth; x++) {
         unsigned alpha = src[3];
         dst[x] = SkPremultiplyARGBInline(alpha, src[0], src[1], src[2]);
         src += deltaSrc;
     }
 }
 
+static void fast_swizzle_rgba_to_n32_premul(
+        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);
+
+#ifdef SK_PMCOLOR_IS_RGBA
+    SkOpts::premul_xxxa((uint32_t*) dst, (const uint32_t*) (src + offset), width);
+#else
+    SkOpts::premul_swaprb_xxxa((uint32_t*) dst, (const uint32_t*) (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 125 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;
     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;
@@ skipping 87 matching lines @@
                             break;
                         default:
                             break;
                     }
                     break;
                 default:
                     break;
             }
             break;
         case kRGBX:
-            // TODO: Support other swizzles.
             switch (dstInfo.colorType()) {
                 case kN32_SkColorType:
                     proc = &swizzle_rgbx_to_n32;
                     break;
                 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;
                     } else {
+                        fastProc = &fast_swizzle_rgba_to_n32_premul;
                         if (SkCodec::kYes_ZeroInitialized == zeroInit) {
                             proc = &swizzle_rgba_to_n32_premul_skipZ;
                         } else {
                             proc = &swizzle_rgba_to_n32_premul;
                         }
                     }
                     break;
                 default:
                     break;
             }
@@ skipping 24 matching lines @@
                 case kRGB_565_SkColorType:
                     proc = &swizzle_cmyk_to_565;
                     break;
                 default:
                     break;
             }
             break;
         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();
         dstWidth = srcWidth;
     } else if (frame) {
         dstOffset = frame->left();
         srcWidth = frame->width();
     }
 
-    return new SkSwizzler(proc, ctable, srcOffset, srcWidth, dstOffset, dstWidth, srcBPP, dstBPP);
+    return new SkSwizzler(fastProc, proc, ctable, srcOffset, srcWidth, dstOffset, dstWidth,
+            srcBPP, dstBPP);
 }
 
-SkSwizzler::SkSwizzler(RowProc proc, const SkPMColor* ctable, int srcOffset, int srcWidth,
-        int dstOffset, int dstWidth, int srcBPP, int dstBPP)
-    : fRowProc(proc)
+SkSwizzler::SkSwizzler(RowProc fastProc, RowProc proc, const SkPMColor* ctable, int srcOffset,
+        int srcWidth, int dstOffset, int dstWidth, int srcBPP, int dstBPP)
+    : fFastProc(fastProc)
+    , fProc(proc)
     , 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.
+    fFastProc = nullptr;
+
     return fAllocatedWidth;
 }
 
 void SkSwizzler::swizzle(void* dst, const uint8_t* SK_RESTRICT src) {
     SkASSERT(nullptr != dst && nullptr != src);
-    fRowProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
-            fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
+    if (fFastProc) {

[mtklein, 2016/01/11 21:07:21]

You might do

RowProc proc = fFastProc ? fFastProc : fProc;
proc(...)

[msarett, 2016/01/12 14:35:51]

Done.

+        fFastProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
+                fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);
+    } else {
+        fProc(SkTAddOffset<void>(dst, fDstOffsetBytes), src, fSwizzleWidth, fSrcBPP,
+                fSampleX * fSrcBPP, fSrcOffsetUnits, fColorTable);;
+    }
 }