Use a faster repeat tiler when translate only matrix.

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 47 matching lines @@
     // 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 {
 public:
     virtual ~PixelPlacerInterface() { }
-    virtual void setDestination(SkPM4f* dst) = 0;
+    // 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;
 };
 
 namespace  {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // Matrix Stage
 // PointProcessor uses a strategy to help complete the work of the different stages. The strategy
 // must implement the following methods:
@@ skipping 152 matching lines @@
         this->bilerpPoint(xs[1], ys[1]);
         this->bilerpPoint(xs[2], ys[2]);
         this->bilerpPoint(xs[3], ys[3]);
     }
 
     struct Wrapper {
         void pointSpan(Span span) {
             processor->breakIntoEdges(span);
         }
 
+        void repeatSpan(Span span, int32_t repeatCount) {
+            while (repeatCount --> 0) {
+                processor->pointSpan(span);
+            }
+        }
+
         BilerpTileStage* processor;
     };
 
     // The span you pass must not be empty.
     void pointSpan(Span span) override {
         SkASSERT(!span.isEmpty());
 
         Wrapper wrapper = {this};
         if (!fXStrategy.maybeProcessSpan(span, &wrapper)) {
             span_fallback(span, this);
@@ skipping 106 matching lines @@
             break;
     }
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_tiler(
     SkLinearBitmapPipeline::SampleProcessorInterface* next,
     SkISize dimensions,
     SkShader::TileMode xMode,
     SkShader::TileMode yMode,
     SkFilterQuality filterQuality,
-    SkLinearBitmapPipeline::TileStage* tileStage) {
+    SkScalar dx,
+    SkLinearBitmapPipeline::TileStage* tileStage)
+{
     switch (xMode) {
         case SkShader::kClamp_TileMode:
             choose_tiler_ymode<XClampStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
         case SkShader::kRepeat_TileMode:
-            choose_tiler_ymode<XRepeatStrategy>(yMode, filterQuality, dimensions, next, tileStage);
+            if (dx == 1.0f && filterQuality == kNone_SkFilterQuality) {
+                choose_tiler_ymode<XRepeatUnitScaleStrategy>(
+                    yMode, kNone_SkFilterQuality, dimensions, next, tileStage);
+            } else {
+                choose_tiler_ymode<XRepeatStrategy>(
+                    yMode, filterQuality, dimensions, next, tileStage);
+            }
             break;
         case SkShader::kMirror_TileMode:
             choose_tiler_ymode<XMirrorStrategy>(yMode, filterQuality, dimensions, next, tileStage);
             break;
     }
 
     return tileStage->get();
 }
 
 
@@ skipping 11 matching lines @@
     }
 
     void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fSampler.nearestList4(xs, ys);
     }
 
     void pointSpan(Span span) override {
         fSampler.nearestSpan(span);
     }
 
-    virtual void repeatSpan(Span span, int32_t repeatCount) override {
+    void repeatSpan(Span span, int32_t repeatCount) override {
         while (repeatCount > 0) {
             fSampler.nearestSpan(span);
             repeatCount--;
         }
     }
 
     void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override {
         SkFAIL("Using nearest neighbor sampler, but calling a bilerpEdge.");
     }
 
-    virtual void bilerpSpan(Span span, SkScalar y) override {
+    void bilerpSpan(Span span, SkScalar y) override {
         SkFAIL("Using nearest neighbor sampler, but calling a bilerpSpan.");
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 template <typename SourceStrategy, typename Next>
 class BilerpSampler final : public SkLinearBitmapPipeline::SampleProcessorInterface {
 public:
     template <typename... Args>
     BilerpSampler(Next* next, Args&&... args)
         : fSampler{next, std::forward<Args>(args)...} { }
 
     void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) override {
         fSampler.bilerpListFew(n, xs, ys);
     }
 
     void VECTORCALL pointList4(Sk4s xs, Sk4s ys) override {
         fSampler.bilerpList4(xs, ys);
     }
 
     void pointSpan(Span span) override {
         fSampler.bilerpSpan(span);
     }
 
-    virtual void repeatSpan(Span span, int32_t repeatCount) override {
+    void repeatSpan(Span span, int32_t repeatCount) override {
         while (repeatCount > 0) {
             fSampler.bilerpSpan(span);
             repeatCount--;
         }
     }
 
     void VECTORCALL bilerpEdge(Sk4s xs, Sk4s ys) override {
         fSampler.bilerpEdge(xs, ys);
     }
 
-    virtual void bilerpSpan(Span span, SkScalar y) override {
+    void bilerpSpan(Span span, SkScalar y) override {
         fSampler.bilerpSpanWithY(span, y);
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 using Placer = SkLinearBitmapPipeline::PixelPlacerInterface;
 
 template<template <typename, typename> class Sampler>
@@ skipping 43 matching lines @@
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 // 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);
         PlacePixel(dst, p1, 1);
         PlacePixel(dst, p2, 2);
         PlacePixel(dst, p3, 3);
         fDst += 4;
     }
 
-    void setDestination(SkPM4f* dst) override {
-        fDst = dst;
+    void setDestination(void* dst, int count) override {
+        fDst = static_cast<SkPM4f*>(dst);
+        fEnd = fDst + count;
     }
 
 private:
     void VECTORCALL PlacePixel(SkPM4f* dst, Sk4f pixel, int index) {
         Sk4f newPixel = pixel;
         if (alphaType == kUnpremul_SkAlphaType) {
             newPixel = Premultiply(pixel);
         }
         newPixel = newPixel * fPostAlpha;
         newPixel.store(dst + index);
     }
     static Sk4f VECTORCALL Premultiply(Sk4f pixel) {
         float alpha = pixel[3];
         return pixel * Sk4f{alpha, alpha, alpha, 1.0f};
     }
 
     SkPM4f* fDst;
+    SkPM4f* fEnd;
     Sk4f fPostAlpha;
 };
 
 static SkLinearBitmapPipeline::PixelPlacerInterface* choose_pixel_placer(
     SkAlphaType alphaType,
     float postAlpha,
     SkLinearBitmapPipeline::PixelStage* placerStage) {
     if (alphaType == kUnpremul_SkAlphaType) {
         placerStage->Initialize<PlaceFPPixel<kUnpremul_SkAlphaType>>(postAlpha);
     } else {
         // kOpaque_SkAlphaType is treated the same as kPremul_SkAlphaType
         placerStage->Initialize<PlaceFPPixel<kPremul_SkAlphaType>>(postAlpha);
     }
     return placerStage->get();
 }
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 SkLinearBitmapPipeline::~SkLinearBitmapPipeline() {}
 
 SkLinearBitmapPipeline::SkLinearBitmapPipeline(
     const SkMatrix& inverse,
     SkFilterQuality filterQuality,
     SkShader::TileMode xTile, SkShader::TileMode yTile,
     float postAlpha,
-    const SkPixmap& srcPixmap) {
+    const SkPixmap& srcPixmap)
+{
     SkISize dimensions = srcPixmap.info().dimensions();
     const SkImageInfo& srcImageInfo = srcPixmap.info();
 
     SkMatrix adjustedInverse = inverse;
     if (filterQuality == kNone_SkFilterQuality) {
         if (inverse.getScaleX() >= 0.0f) {
             adjustedInverse.setTranslateX(
                 nextafterf(inverse.getTranslateX(), std::floor(inverse.getTranslateX())));
         }
         if (inverse.getScaleY() >= 0.0f) {
             adjustedInverse.setTranslateY(
                 nextafterf(inverse.getTranslateY(), std::floor(inverse.getTranslateY())));
         }
     }
 
+    SkScalar dx = adjustedInverse.getScaleX();
+
     // If it is an index 8 color type, the sampler converts to unpremul for better fidelity.
     SkAlphaType alphaType = srcImageInfo.alphaType();
     if (srcPixmap.colorType() == kIndex_8_SkColorType) {
         alphaType = kUnpremul_SkAlphaType;
     }
 
     // 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, &fTiler);
+                                       dimensions, xTile, yTile, filterQuality, dx, &fTiler);
     fFirstStage         = choose_matrix(tilerStage, adjustedInverse, &fMatrixStage);
 }
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
-    fPixelStage->setDestination(dst);
+    fPixelStage->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});
 }