Add specialized rgba8888 unit sampler.

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 44 matching lines @@
     // px00  px10  px01  px11
     virtual void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) = 0;
 
     // A span represents sample points that have been mapped from destination space to source
     // space. Each sample point is then expanded to the four bilerp points by add +/- 0.5. The
     // resulting Y values my be off the tile. When y +/- 0.5 are more than 1 apart because of
     // tiling, the second Y is used to denote the retiled Y value.
     virtual void bilerpSpan(Span span, SkScalar y) = 0;
 };
 
-class SkLinearBitmapPipeline::PixelPlacerInterface {
+class SkLinearBitmapPipeline::DestinationInterface {
+public:
+    virtual ~DestinationInterface() { }
+    virtual void setDestination(void* dst, int count) = 0;
+};
+
+class SkLinearBitmapPipeline::PixelPlacerInterface
+    : public SkLinearBitmapPipeline::DestinationInterface {
 public:
     virtual ~PixelPlacerInterface() { }
     // Count is normally not needed, but in these early stages of development it is useful to
     // check bounds.
     // TODO(herb): 4/6/2016 - remove count when code is stable.
     virtual void setDestination(void* dst, int count) = 0;
     virtual void VECTORCALL placePixel(Sk4f pixel0) = 0;
     virtual void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) = 0;
 };
 
@@ skipping 314 matching lines @@
             }
             break;
         case SkShader::kMirror_TileMode:
             choose_tiler_ymode<XMirrorStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
     }
 
     return tileStage->get();
 }
 
-
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Source Sampling Stage
 template <typename SourceStrategy, typename Next>
 class NearestNeighborSampler final : public SkLinearBitmapPipeline::SampleProcessorInterface {
 public:
     template <typename... Args>
     NearestNeighborSampler(Next* next, Args&&... args)
     : fSampler{next, std::forward<Args>(args)...} { }
 
     void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
@@ skipping 58 matching lines @@
     }
 
     void bilerpSpan(Span span, SkScalar y) override {
         fSampler.bilerpSpanWithY(span, y);
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
+// 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 {
+public:
+    RGBA8888UnitRepeat(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]);
+        if (n >= 3) *fDest++ = *this->pixelAddress(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);
+        *fDest++ = *this->pixelAddress(iXs[0], iYs[0]);
+        *fDest++ = *this->pixelAddress(iXs[1], iYs[1]);
+        *fDest++ = *this->pixelAddress(iXs[2], iYs[2]);
+        *fDest++ = *this->pixelAddress(iXs[3], iYs[3]);
+    }
+
+    void pointSpan(Span span) override {
+        SkASSERT(fDest + span.count() <= fEnd);
+        int32_t x = (int32_t)span.startX();
+        int32_t y = (int32_t)span.startY();
+        const uint32_t* src = this->pixelAddress(x, y);
+        memmove(fDest, src, span.count() * sizeof(uint32_t));
+        fDest += span.count();
+    }
+
+    void repeatSpan(Span span, int32_t repeatCount) override {
+        SkASSERT(fDest + span.count() * repeatCount <= fEnd);
+
+        int32_t x = (int32_t)span.startX();
+        int32_t y = (int32_t)span.startY();
+        const uint32_t* src = this->pixelAddress(x, y);
+        uint32_t* dest = fDest;
+        while (repeatCount --> 0) {
+            memmove(dest, src, span.count() * sizeof(uint32_t));
+            dest += span.count();
+        }
+        fDest = dest;
+    }
+
+    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  {
+        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];

[f(malita), 2016/04/08 12:58:12]

Do we need to worry about row padding here or rowbytes never comes into play?

[herb_g, 2016/04/08 13:48:59]

I talked with MikeR about this. RowBytes must always be a multiple of pixel
size, so just storing the with in pixels is all you need.

+    }
+    const uint32_t* const fSrc;
+    const int32_t         fWidth;
+    uint32_t*             fDest;
+    uint32_t*             fEnd;
+};
+
 using Placer = SkLinearBitmapPipeline::PixelPlacerInterface;
 
 template<template <typename, typename> class Sampler>
 static SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler_base(
     Placer* next,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     const SkImageInfo& imageInfo = srcPixmap.info();
     switch (imageInfo.colorType()) {
         case kRGBA_8888_SkColorType:
@@ skipping 35 matching lines @@
         return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, sampleStage);
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Pixel Placement Stage
 template <SkAlphaType alphaType>
 class PlaceFPPixel final : public SkLinearBitmapPipeline::PixelPlacerInterface {
 public:
     PlaceFPPixel(float postAlpha) : fPostAlpha{postAlpha} { }
+
     void VECTORCALL placePixel(Sk4f pixel) override {
         SkASSERT(fDst + 1 <= fEnd );
         PlacePixel(fDst, pixel, 0);
         fDst += 1;
     }
 
     void VECTORCALL place4Pixels(Sk4f p0, Sk4f p1, Sk4f p2, Sk4f p3) override {
         SkASSERT(fDst + 4 <= fEnd);
         SkPM4f* dst = fDst;
         PlacePixel(dst, p0, 0);
@@ skipping 75 matching lines @@
     }
 
     // As the stages are built, the chooser function may skip a stage. For example, with the
     // identity matrix, the matrix stage is skipped, and the tilerStage is the first stage.
     auto placementStage = choose_pixel_placer(alphaType, postAlpha, &fPixelStage);
     auto samplerStage   = choose_pixel_sampler(placementStage,
                                                filterQuality, srcPixmap, &fSampleStage);
     auto tilerStage     = choose_tiler(samplerStage,
                                        dimensions, xTile, yTile, filterQuality, dx, &fTiler);
     fFirstStage         = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
+    fLastStage          = placementStage;
+
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
-    fPixelStage->setDestination(dst, count);
+    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});
 }