Handle spans in sampling.

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 727 matching lines @@
     void VECTORCALL get4Pixels(Sk4s xs, Sk4s ys, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
         Sk4i XIs = SkNx_cast<int, SkScalar>(xs);
         Sk4i YIs = SkNx_cast<int, SkScalar>(ys);
         Sk4i bufferLoc = YIs * fWidth + XIs;
         *px0 = this->getPixel(fSrc, bufferLoc[0]);
         *px1 = this->getPixel(fSrc, bufferLoc[1]);
         *px2 = this->getPixel(fSrc, bufferLoc[2]);
         *px3 = this->getPixel(fSrc, bufferLoc[3]);
     }
 
+    void get4Pixels(const uint32_t* src, int index, Sk4f* px0, Sk4f* px1, Sk4f* px2, Sk4f* px3) {
+        *px0 = this->getPixel(src, index + 0);
+        *px1 = this->getPixel(src, index + 1);
+        *px2 = this->getPixel(src, index + 2);
+        *px3 = this->getPixel(src, index + 3);
+    }
+
     Sk4f getPixel(const uint32_t* src, int index) {
         Sk4b bytePixel = Sk4b::Load((uint8_t *)(&src[index]));
         Sk4f pixel = SkNx_cast<float, uint8_t>(bytePixel);
         if (colorOrder == ColorOrder::kBGRA) {
             pixel = SkNx_shuffle<2, 1, 0, 3>(pixel);
         }
         pixel = pixel * Sk4f{1.0f/255.0f};
         if (colorProfile == kSRGB_SkColorProfileType) {
             pixel = sRGBFast::sRGBToLinear(pixel);
         }
@@ skipping 64 matching lines @@
     }
 
     void VECTORCALL bilerpList(Sk4s xs, Sk4s ys) override {
         Sk4f px00, px10, px01, px11;
         fStrategy.get4Pixels(xs, ys, &px00, &px10, &px01, &px11);
         Sk4f pixel = bilerp4(xs, ys, px00, px10, px01, px11);
         fNext->placePixel(pixel);
     }
 
     void pointSpan(Span span) override {
+        SkASSERT(!span.isEmpty());
+        SkPoint start; SkScalar length; int count;
+        std::tie(start, length, count) = span;
+        if (length < (count - 1)) {
+            pointSpanSlowRate(span);

[mtklein_C, 2016/03/01 18:53:05]

Please do a this-> pass.

[herb_g, 2016/03/01 20:57:06]

Done.

+        } else if (length == (count - 1)) {
+            pointSpanUnitRate(span);
+        } else {
+            pointSpanFastRate(span);
+        }
+    }
+
+
+private:
+    void pointSpanSlowRate(Span span) {

[mtklein_C, 2016/03/01 18:53:05]

// When moving through source space more slowly than dst space (zoomed in),
// we'll be sampling from the same source pixel more than once.

[herb_g, 2016/03/01 20:57:06]

Done.

+        SkPoint start; SkScalar length; int count;
+        std::tie(start, length, count) = span;
+        SkScalar x = X(start);
+        SkFixed fx = SkScalarToFixed(x);
+        SkScalar dx = length / (count - 1);
+        SkFixed fdx = SkScalarToFixed(dx);
+
+        const uint32_t* const row = fStrategy.row((int)std::floor(Y(start)));

[mtklein_C, 2016/03/01 18:53:05]

Seems like we can't logically write uint32_t here.  That's something that's only
true for the Pixel8888 strategy.  Other strategies will have different formats,
no?  Better either go to void* everywhere, or use enough auto to make this code
agnostic?

I'm on board if you want to change this when we add our first non-32 bit source
format.

[herb_g, 2016/03/01 20:57:07]

Done.

+        SkLinearBitmapPipeline::PixelPlacerInterface* const next = fNext;

[mtklein_C, 2016/03/01 18:53:06]

Just my opinion: I think marking pointers const usually just creates a
readability stumbling block, and only rarely conveys some important reassurance.

[herb_g, 2016/03/01 20:57:07]

Done.

+        int ix = SkFixedFloorToInt(fx);
+        int prevIX = ix;
+        Sk4f fpixel = fStrategy.getPixel(row, ix);
+        auto getNextPixel = [&]() {

[mtklein_C, 2016/03/01 18:53:05]

// As dx gets smaller, we take more and more samples from the same source pixel,
// so with a little extra bookkeeping (all the SkFixed) we can avoid reloading
// and re-format-converting each sample after the first.

[herb_g, 2016/03/01 20:57:06]

Done.

+            if (ix != prevIX) {
+                fpixel = fStrategy.getPixel(row, ix);
+                prevIX = ix;
+            }
+            fx += fdx;
+            ix = SkFixedFloorToInt(fx);
+            return fpixel;
+        };
+        while (count >= 4) {
+            Sk4f px0 = getNextPixel();
+            Sk4f px1 = getNextPixel();
+            Sk4f px2 = getNextPixel();
+            Sk4f px3 = getNextPixel();
+            next->place4Pixels(px0, px1, px2, px3);
+            count -= 4;
+        }
+        while (count > 0) {
+            next->placePixel(getNextPixel());
+            count -= 1;
+        }
+    }
+
+    void pointSpanUnitRate(Span span) {

[mtklein_C, 2016/03/01 18:53:05]

// We're moving through source space at a rate of 1 source pixel per 1 dst
pixel.
// We'll never re-use pixels, but we can at least load contiguous pixels.

[herb_g, 2016/03/01 20:57:06]

Done.

+        SkPoint start; SkScalar length; int count;
+        std::tie(start, length, count) = span;
+        const uint32_t* const row = fStrategy.row((int)std::floor(Y(start)));
+        int ix = SkScalarFloorToInt(X(start));
+        SkLinearBitmapPipeline::PixelPlacerInterface* const next = fNext;
+        while (count >= 4) {
+            Sk4f px0, px1, px2, px3;
+            fStrategy.get4Pixels(row, ix, &px0, &px1, &px2, &px3);
+            next->place4Pixels(px0, px1, px2, px3);
+            ix += 4;
+            count -= 4;
+        }
+        while (count > 0) {
+            next->placePixel(fStrategy.getPixel(row, ix));
+            ix += 1;
+            count -= 1;
+        }
+    }
+
+    void pointSpanFastRate(Span span) {

[mtklein_C, 2016/03/01 18:53:06]

// We're moving through source space faster than dst (zoomed out), 
// so we'll never reuse a source pixel or be able to do contiguous loads.

[herb_g, 2016/03/01 20:57:06]

Done.

         span_fallback(span, this);
     }
 
 private:
     SkLinearBitmapPipeline::PixelPlacerInterface* const fNext;
     SourceStrategy fStrategy;
 };
 
 using Pixel8888SRGB = Pixel8888<kSRGB_SkColorProfileType, ColorOrder::kRGBA>;
 using Pixel8888LRGB = Pixel8888<kLinear_SkColorProfileType, ColorOrder::kRGBA>;
@@ skipping 99 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{SkPoint{x + 0.5f, y + 0.5f}, count - 1.0f, count});
 }