Add 8888 fast SrcOver mode.

src/core/SkLinearBitmapPipeline.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkLinearBitmapPipeline.h"
 
 #include "SkPM4f.h"
@@ skipping 537 matching lines @@
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Specialized Samplers
 
 // RGBA8888UnitRepeatSrc - A sampler that takes advantage of the fact the the src and destination
 // are the same format and do not need in transformations in pixel space. Therefore, there is no
 // need to convert them to HiFi pixel format.
-class RGBA8888UnitRepeat final : public SkLinearBitmapPipeline::SampleProcessorInterface,
-                                 public SkLinearBitmapPipeline::DestinationInterface {
+class RGBA8888UnitRepeatSrc final : public SkLinearBitmapPipeline::SampleProcessorInterface,
+                                    public SkLinearBitmapPipeline::DestinationInterface {
 public:
-    RGBA8888UnitRepeat(const uint32_t* src, int32_t width)
+    RGBA8888UnitRepeatSrc(const uint32_t* src, int32_t width)
         : fSrc{src}, fWidth{width} { }
 
     void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         SkASSERT(fDest + n <= fEnd);
         // At this point xs and ys should be >= 0, so trunc is the same as floor.
         Sk4i iXs = SkNx_cast<int>(xs);
         Sk4i iYs = SkNx_cast<int>(ys);
 
         if (n >= 1) *fDest++ = *this->pixelAddress(iXs[0], iYs[0]);
         if (n >= 2) *fDest++ = *this->pixelAddress(iXs[1], iYs[1]);
@@ skipping 47 matching lines @@
 private:
     const uint32_t* pixelAddress(int32_t x, int32_t y) {
         return &fSrc[fWidth * y + x];
     }
     const uint32_t* const fSrc;
     const int32_t         fWidth;
     uint32_t*             fDest;
     uint32_t*             fEnd;
 };
 
+void lerp_pixel(const uint32_t* src, uint32_t* dst) {

[mtklein, 2016/04/27 16:10:04]

Let's not call this lerp.  Lerp is a function of three arguments.  This function
is called srcover.

We almost always write functions like this with dst as the first argument. 
(That's how memcpy works, it's how the registers are named, there's always a dst
but not necessarily a src, it's our convention, ...)

Probably no need to pass these things by pointer unless you're looping like
below.
   uint32_t srcover(uint32_t dst, uint32_t src)
should work out just the same.

+    Sk4b srcAsBytes = Sk4b::Load(src);

[mtklein, 2016/04/27 16:10:04]

I think this code would be more readable with fewer named intermediate values,
shorter names, and more visual parallelism to match the logical parallelism.

Sk4f s = ToLinear((1/255.0f) * SkNx_cast<float>(Sk4b::Load(src))),
     d = ToLinear((1/255.0f) * SkNx_cast<float>(Sk4b::Load(dst)));

d = s + d*(1 - s[3]);

SkNx_cast<uint8_t>(255 * ToSRGB(d)).store(dst);

+    Sk4f srcPixel = SkNx_cast<float>(srcAsBytes);
+    srcPixel = sRGBFast::sRGBToLinear(srcPixel / 255.0f);

[mtklein, 2016/04/27 16:10:04]

Try not to write "x / 255.0f". 
"x *(1/255.0f)" is faster.

(Parentheses matter.  "x * 1/255.0f" is even worse than "x / 255.0f". )

+    Sk4b dstAsBytes = Sk4b::Load(dst);
+    Sk4f dstPixel = SkNx_cast<float>(dstAsBytes);
+    dstPixel = sRGBFast::sRGBToLinear(dstPixel / 255.0f);
+    Sk4f invAlpha = 1.0f - Sk4f{srcPixel[3]};
+    dstPixel *= invAlpha;
+    dstPixel += srcPixel;
+    dstPixel = sRGBFast::LinearTosRGB(dstPixel);
+    dstPixel *= 255.0f;

[f(malita), 2016/04/27 15:51:17]

Can we avoid the 255 divs/mult and lerp in 255-space instead?  I think the 255
factor cancels out:

    invA = 1 - (As / 255);

    R = 255 * sqrt((Rs/255)^2 + (Rd/255)^2 * invA)
 => R = 255 * sqrt((Rs^2 + Rd^2 * invA)/255^2)
 => R = sqrt(Rs^2 + Rd^2 * invA)

[mtklein, 2016/04/27 16:10:04]

neat.

+    dstAsBytes = SkNx_cast<uint8_t>(dstPixel);
+    dstAsBytes.store(dst);
+}
+
+void lerp_pixels(const uint32_t* src, uint32_t* dst, size_t count) {
+
+    while (count --> 0) {
+        lerp_pixel(src, dst);
+        dst += 1;
+        src += 1;
+    }
+}
+
+uint8_t extract_alpha(const uint32_t* pixel) {
+    const uint8_t* bPixel = reinterpret_cast<const uint8_t*>(pixel);

[mtklein, 2016/04/27 16:10:04]

return *pixel >> 24;

?

+    return bPixel[3];
+}
+
+// RGBA8888UnitRepeatSrc - A sampler that takes advantage of the fact the the src and destination
+// are the same format and do not need in transformations in pixel space. Therefore, there is no
+// need to convert them to HiFi pixel format.
+class RGBA8888UnitRepeatSrcOver final : public SkLinearBitmapPipeline::SampleProcessorInterface,
+                                        public SkLinearBitmapPipeline::DestinationInterface {
+public:
+    RGBA8888UnitRepeatSrcOver(const uint32_t* src, int32_t width)
+        : fSrc{src}, fWidth{width} { }
+
+    void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
+        SkASSERT(fDest + n <= fEnd);
+        // At this point xs and ys should be >= 0, so trunc is the same as floor.
+        Sk4i iXs = SkNx_cast<int>(xs);
+        Sk4i iYs = SkNx_cast<int>(ys);
+
+        if (n >= 1) blendPixelAt(iXs[0], iYs[0]);
+        if (n >= 2) blendPixelAt(iXs[1], iYs[1]);
+        if (n >= 3) blendPixelAt(iXs[2], iYs[2]);
+    }
+
+    void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
+        SkASSERT(fDest + 4 <= fEnd);
+        Sk4i iXs = SkNx_cast<int>(xs);
+        Sk4i iYs = SkNx_cast<int>(ys);
+        blendPixelAt(iXs[0], iYs[0]);
+        blendPixelAt(iXs[1], iYs[1]);
+        blendPixelAt(iXs[2], iYs[2]);
+        blendPixelAt(iXs[3], iYs[3]);
+    }
+
+    void pointSpan(Span span) override {
+        if (span.length() != 0.0f) {
+            this->repeatSpan(span, 1);
+        }
+    }
+
+    void repeatSpan(Span span, int32_t repeatCount) override {
+        SkASSERT(fDest + span.count() * repeatCount <= fEnd);
+        SkASSERT(span.count() > 0);
+        SkASSERT(repeatCount > 0);
+
+        int32_t x = (int32_t)span.startX();
+        int32_t y = (int32_t)span.startY();
+        const uint32_t* beginSpan = this->pixelAddress(x, y);
+        const uint32_t* endSpan = beginSpan + span.count();
+
+        while (repeatCount-- > 0) {
+            const uint32_t* src = beginSpan;
+            do {
+                const uint32_t* startSegment = src;
+                uint8_t currentAlpha = extract_alpha(src);
+                switch (currentAlpha) {
+                    case 0x00:
+                        do {
+                            src += 1;
+                        } while (src < endSpan && extract_alpha(src) == 0x00);
+
+                        break;
+                    case 0xFF:
+                        do {
+                            src += 1;
+                        } while (src < endSpan && extract_alpha(src) == 0xFF);
+                        memmove(fDest, startSegment, (src - startSegment) * sizeof(uint32_t));
+                        break;
+                    default:
+                        do {
+                            src += 1;
+                        } while (src < endSpan
+                                 && extract_alpha(src) != 0xFF
+                                 && extract_alpha(src) != 0x00);
+                        lerp_pixels(startSegment, fDest, src - startSegment);
+                }
+                fDest += src - startSegment;
+            } while (src < endSpan);
+        }
+        SkASSERT(fDest <= fEnd);
+    }
+
+    void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override { SkFAIL("Not Implemented"); }
+
+    void bilerpSpan(Span span, SkScalar y) override { SkFAIL("Not Implemented"); }
+
+    void setDestination(void* dst, int count) override  {
+        SkASSERT(count > 0);
+        fDest = static_cast<uint32_t*>(dst);
+        fEnd = fDest + count;
+    }
+
+private:
+    const uint32_t* pixelAddress(int32_t x, int32_t y) {
+        return &fSrc[fWidth * y + x];
+    }
+
+    void blendPixelAt(int32_t x, int32_t y) {
+        const uint32_t* src = this->pixelAddress(x, y);
+        uint8_t alpha = extract_alpha(src);
+        if (alpha == 0xff) {
+            *fDest = *src;
+        } else if (alpha != 0x00) {
+            lerp_pixel(src, fDest);

[mtklein, 2016/04/27 16:10:04]

It might make things globally simpler to fuse lerp_pixel() into lerp_pixels()
and just call lerp_pixels(src, fDest, 1) here.

+        }
+        fDest += 1;
+    };
+
+    const uint32_t* const fSrc;
+    const int32_t         fWidth;
+    uint32_t*             fDest;
+    uint32_t*             fEnd;
+};
+
 using Blender = SkLinearBitmapPipeline::BlendProcessorInterface;
 
 template<template <typename, typename> class Sampler>
 static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
     Blender* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kRGBA_8888_SkColorType:
@@ skipping 151 matching lines @@
     const SkLinearBitmapPipeline& pipeline,
     SkMatrix::TypeMask matrixMask,
     SkShader::TileMode xTileMode,
     SkShader::TileMode yTileMode,
     SkFilterQuality filterQuality,
     const SkPixmap& srcPixmap,
     float finalAlpha,
     SkXfermode::Mode xferMode,
     const SkImageInfo& dstInfo)
 {
+    if (xferMode == SkXfermode::kSrcOver_Mode
+        && srcPixmap.info().alphaType() == kOpaque_SkAlphaType) {
+        xferMode = SkXfermode::kSrc_Mode;
+    }
+
     if (matrixMask & ~SkMatrix::kTranslate_Mask ) { return false; }
     if (filterQuality != SkFilterQuality::kNone_SkFilterQuality) { return false; }
     if (finalAlpha != 1.0f) { return false; }
     if (srcPixmap.info().colorType() != kRGBA_8888_SkColorType
         || dstInfo.colorType() != kRGBA_8888_SkColorType) { return false; }
 
-    if (srcPixmap.info().profileType() != dstInfo.profileType()) { return false; }
+    if (srcPixmap.info().profileType() != kSRGB_SkColorProfileType
+        || dstInfo.profileType() != kSRGB_SkColorProfileType) { return false; }
 
-    if (xTileMode != SkShader::kRepeat_TileMode || yTileMode != SkShader::kRepeat_TileMode) {
+    if (xferMode != SkXfermode::kSrc_Mode && xferMode != SkXfermode::kSrcOver_Mode) {
         return false;
     }
 
-    if (xferMode == SkXfermode::kSrcOver_Mode
-        && srcPixmap.info().alphaType() == kOpaque_SkAlphaType) {
-        xferMode = SkXfermode::kSrc_Mode;
-    }
-
-    if (xferMode != SkXfermode::kSrc_Mode) { return false; }
-
     new (blitterStorage) SkLinearBitmapPipeline(pipeline, srcPixmap, xferMode, dstInfo);
 
     return true;
 }
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkLinearBitmapPipeline& pipeline,
     const SkPixmap& srcPixmap,
     SkXfermode::Mode mode,
     const SkImageInfo& dstInfo)
 {
-    SkASSERT(mode == SkXfermode::kSrc_Mode);
+    SkASSERT(mode == SkXfermode::kSrc_Mode || mode == SkXfermode::kSrcOver_Mode);
     SkASSERT(srcPixmap.info().colorType() == dstInfo.colorType()
              && srcPixmap.info().colorType() == kRGBA_8888_SkColorType);
 
-    fSampleStage.initSink<RGBA8888UnitRepeat>(srcPixmap.writable_addr32(0, 0), srcPixmap.width());
+    if (mode == SkXfermode::kSrc_Mode) {
+        fSampleStage.initSink<RGBA8888UnitRepeatSrc>(
+            srcPixmap.writable_addr32(0, 0), srcPixmap.rowBytes() / 4);
+        fLastStage = fSampleStage.getInterface<DestinationInterface, RGBA8888UnitRepeatSrc>();
+    } else {
+        fSampleStage.initSink<RGBA8888UnitRepeatSrcOver>(
+            srcPixmap.writable_addr32(0, 0), srcPixmap.rowBytes() / 4);
+        fLastStage = fSampleStage.getInterface<DestinationInterface, RGBA8888UnitRepeatSrcOver>();
+    }
+
     auto sampleStage = fSampleStage.get();
     auto tilerStage = pipeline.fTileStage.cloneStageTo(sampleStage, &fTileStage);
     tilerStage = (tilerStage != nullptr) ? tilerStage : sampleStage;
     auto matrixStage = pipeline.fMatrixStage.cloneStageTo(tilerStage, &fMatrixStage);
     matrixStage = (matrixStage != nullptr) ? matrixStage : tilerStage;
     fFirstStage = matrixStage;
-    fLastStage = fSampleStage.getInterface<DestinationInterface, RGBA8888UnitRepeat>();
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     this->blitSpan(x, y, dst, count);
 }
 
 void SkLinearBitmapPipeline::blitSpan(int x, int y, void* dst, int count) {
     SkASSERT(count > 0);
     fLastStage->setDestination(dst, count);
 
     // The count and length arguments start out in a precise relation in order to keep the
     // math correct through the different stages. Count is the number of pixel to produce.
     // Since the code samples at pixel centers, length is the distance from the center of the
     // first pixel to the center of the last pixel. This implies that length is count-1.
     fFirstStage->pointSpan(Span{{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }