Add repeatSpan and change interface name.

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 16 matching lines @@
     // to expand the bilerp filter around the point and sample using that filter.
     virtual void VECTORCALL pointListFew(int n, Sk4s xs, Sk4s ys) = 0;
     // Same as pointListFew, but n = 4.
     virtual void VECTORCALL pointList4(Sk4s xs, Sk4s ys) = 0;
     // A span is a compact form of sample points that are obtained by mapping points from
     // destination space to source space. This is used for horizontal lines only, and is mainly
     // used to take advantage of memory coherence for horizontal spans.
     virtual void pointSpan(Span span) = 0;
 };
 
-class SkLinearBitmapPipeline::BilerpProcessorInterface
+class SkLinearBitmapPipeline::SampleProcessorInterface
     : public SkLinearBitmapPipeline::PointProcessorInterface {
 public:
+    // Used for nearest neighbor when scale factor is 1.0. The span can just be repeated with no
+    // edge pixel alignment problems. This is for handling a very common case.
+    virtual void repeatSpan(Span span, int32_t repeatCount) = 0;
+
     // The x's and y's are setup in the following order:
     // +--------+--------+
     // |        |        |
     // |  px00  |  px10  |
     // |    0   |    1   |
     // +--------+--------+
     // |        |        |
     // |  px01  |  px11  |
     // |    2   |    3   |
     // +--------+--------+
@@ skipping 282 matching lines @@
     Next* next, SkLinearBitmapPipeline::TileStage* tileStage) {
     if (filterQuality == kNone_SkFilterQuality) {
         tileStage->Initialize<NearestTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
     } else {
         tileStage->Initialize<BilerpTileStage<XStrategy, YStrategy, Next>>(next, dimensions);
     }
 }
 template <typename XStrategy>
 void choose_tiler_ymode(
     SkShader::TileMode yMode, SkFilterQuality filterQuality, SkISize dimensions,
-    SkLinearBitmapPipeline::BilerpProcessorInterface* next,
+    SkLinearBitmapPipeline::SampleProcessorInterface* next,
     SkLinearBitmapPipeline::TileStage* tileStage) {
     switch (yMode) {
         case SkShader::kClamp_TileMode:
             make_tile_stage<XStrategy, YClampStrategy>(filterQuality, dimensions, next, tileStage);
             break;
         case SkShader::kRepeat_TileMode:
             make_tile_stage<XStrategy, YRepeatStrategy>(filterQuality, dimensions, next, tileStage);
             break;
         case SkShader::kMirror_TileMode:
             make_tile_stage<XStrategy, YMirrorStrategy>(filterQuality, dimensions, next, tileStage);
             break;
     }
 };
 
 static SkLinearBitmapPipeline::PointProcessorInterface* choose_tiler(
-    SkLinearBitmapPipeline::BilerpProcessorInterface* next,
+    SkLinearBitmapPipeline::SampleProcessorInterface* next,
     SkISize dimensions,
     SkShader::TileMode xMode,
     SkShader::TileMode yMode,
     SkFilterQuality filterQuality,
     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);
             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::BilerpProcessorInterface {
+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 {
         fSampler.nearestListFew(n, xs, ys);
     }
+
     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 {
+        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 {
         SkFAIL("Using nearest neighbor sampler, but calling a bilerpSpan.");
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 template <typename SourceStrategy, typename Next>
-class BilerpSampler final : public SkLinearBitmapPipeline::BilerpProcessorInterface {
+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 {
+        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 {
         fSampler.bilerpSpanWithY(span, y);
     }
 
 private:
     GeneralSampler<SourceStrategy, Next> fSampler;
 };
 
 using Placer = SkLinearBitmapPipeline::PixelPlacerInterface;
 
 template<template <typename, typename> class Sampler>
-static SkLinearBitmapPipeline::BilerpProcessorInterface* choose_pixel_sampler_base(
+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:
             if (imageInfo.profileType() == kSRGB_SkColorProfileType) {
                 sampleStage->Initialize<Sampler<Pixel8888SRGB, Placer>>(next, srcPixmap);
             } else {
                 sampleStage->Initialize<Sampler<Pixel8888LRGB, Placer>>(next, srcPixmap);
@@ skipping 13 matching lines @@
                 sampleStage->Initialize<Sampler<PixelIndex8LRGB, Placer>>(next, srcPixmap);
             }
             break;
         default:
             SkFAIL("Not implemented. Unsupported src");
             break;
     }
     return sampleStage->get();
 }
 
-SkLinearBitmapPipeline::BilerpProcessorInterface* choose_pixel_sampler(
+SkLinearBitmapPipeline::SampleProcessorInterface* choose_pixel_sampler(
     Placer* next,
     SkFilterQuality filterQuality,
     const SkPixmap& srcPixmap,
     SkLinearBitmapPipeline::SampleStage* sampleStage) {
     if (filterQuality == kNone_SkFilterQuality) {
         return choose_pixel_sampler_base<NearestNeighborSampler>(next, srcPixmap, sampleStage);
     } else {
         return choose_pixel_sampler_base<BilerpSampler>(next, srcPixmap, sampleStage);
     }
 }
@@ skipping 96 matching lines @@
 
 void SkLinearBitmapPipeline::shadeSpan4f(int x, int y, SkPM4f* dst, int count) {
     SkASSERT(count > 0);
     fPixelStage->setDestination(dst);
     // 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});
 }