| /* |
| * Copyright 2017 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkMaskBlurFilter.h" |
| |
| #include <cmath> |
| #include <climits> |
| |
| #include "SkArenaAlloc.h" |
| #include "SkGaussFilter.h" |
| #include "SkNx.h" |
| #include "SkSafeMath.h" |
| |
| static const double kPi = 3.14159265358979323846264338327950288; |
| |
| static constexpr double kSmallSigma = 2.0; |
| |
| class BlurScanInterface { |
| public: |
| virtual ~BlurScanInterface() = default; |
| virtual void blur(const uint8_t* src, size_t srcStride, const uint8_t* srcEnd, |
| uint8_t* dst, size_t dstStride, uint8_t* dstEnd) const = 0; |
| virtual bool canBlur4() { return false; } |
| virtual void blur4Transpose( |
| const uint8_t* src, size_t srcStride, const uint8_t* srcEnd, |
| uint8_t* dst, size_t dstStride, uint8_t* dstEnd) const { |
| SK_ABORT("This should not be called."); |
| } |
| }; |
| |
| class PlanningInterface { |
| public: |
| virtual ~PlanningInterface() = default; |
| virtual size_t bufferSize() const = 0; |
| virtual size_t border() const = 0; |
| virtual bool needsBlur() const = 0; |
| virtual BlurScanInterface* makeBlurScan( |
| SkArenaAlloc* alloc, size_t width, uint32_t* buffer) const = 0; |
| }; |
| |
| class None final : public PlanningInterface { |
| public: |
| None() = default; |
| size_t bufferSize() const override { return 0; } |
| size_t border() const override { return 0; } |
| bool needsBlur() const override { return false; } |
| BlurScanInterface* makeBlurScan( |
| SkArenaAlloc* alloc, size_t width, uint32_t* buffer) const override { |
| SK_ABORT("Should never be called."); |
| return nullptr; |
| } |
| }; |
| |
| class PlanBox final : public PlanningInterface { |
| public: |
| explicit PlanBox(double sigma) { |
| // Calculate the radius from sigma. Taken from the old code until something better is |
| // figured out. |
| auto possibleRadius = 1.5 * sigma - 0.5; |
| auto radius = std::max(std::numeric_limits<double>::epsilon(), possibleRadius); |
| auto outerRadius = std::ceil(radius); |
| auto outerWindow = 2 * outerRadius + 1; |
| auto outerFactor = (1 - (outerRadius - radius)) / outerWindow; |
| fOuterWeight = static_cast<uint32_t>(round(outerFactor * (1ull << 24))); |
| |
| auto innerRadius = outerRadius - 1; |
| auto innerWindow = 2 * innerRadius + 1; |
| auto innerFactor = (1 - (radius - innerRadius)) / innerWindow; |
| fInnerWeight = static_cast<uint32_t>(round(innerFactor * (1ull << 24))); |
| |
| // Sliding window is defined by the relationship between the outer and inner widows. |
| // In the single window case, you add the element on the right, and subtract the element on |
| // the left. But, because two windows are used, this relationship is more complicated; an |
| // element is added from the right of the outer window, and subtracted from the left of the |
| // inner window. Because innerWindow = outerWindow - 2, the distance between |
| // the left and right in the two window case is outerWindow - 1. |
| fSlidingWindow = static_cast<size_t>(outerWindow - 1); |
| } |
| |
| size_t bufferSize() const override { |
| return fSlidingWindow * (sizeof(Sk4u) / sizeof(uint32_t)); |
| } |
| |
| // Remember that sliding window = window - 1. Therefore, radius = sliding window / 2. |
| size_t border() const override { return fSlidingWindow / 2; } |
| |
| bool needsBlur() const override { return true; } |
| |
| BlurScanInterface* makeBlurScan( |
| SkArenaAlloc* alloc, size_t width, uint32_t* buffer) const override |
| { |
| size_t noChangeCount; |
| size_t trailingEdgeZeroCount; |
| |
| // The relation between the slidingWindow and the width dictates two operating modes. |
| // * width >= slidingWindow - both sides of the window are contained in the image while |
| // scanning. Therefore, we assume that slidingWindow zeros are consumed on the trailing |
| // edge of the window. After this count, then both edges are traversing the image. |
| // * slidingWindow > width - both sides of the window are off the image while scanning |
| // the middle. The front edge of the window can only travel width until it falls off the |
| // image. At this point, both edges of the window are off the image consuming zeros |
| // and therefore, the destination value does not change. The scan produces unchanged |
| // values until the trailing edge of the window enters the image. This count is |
| // slidingWindow - width. |
| if (width >= fSlidingWindow) { |
| noChangeCount = 0; |
| trailingEdgeZeroCount = fSlidingWindow; |
| } else { |
| noChangeCount = fSlidingWindow - width; |
| trailingEdgeZeroCount = width; |
| } |
| |
| Sk4u* sk4uBuffer = reinterpret_cast<Sk4u*>(buffer); |
| return alloc->make<Box>(fOuterWeight, fInnerWeight, noChangeCount, trailingEdgeZeroCount, |
| sk4uBuffer, sk4uBuffer + fSlidingWindow); |
| } |
| |
| private: |
| class Box final : public BlurScanInterface { |
| public: |
| Box(uint32_t outerWeight, uint32_t innerWeight, |
| size_t noChangeCount, size_t trailingEdgeZeroCount, |
| Sk4u* buffer, Sk4u* bufferEnd) |
| : fOuterWeight{outerWeight} |
| , fInnerWeight{innerWeight} |
| , fNoChangeCount{noChangeCount} |
| , fTrailingEdgeZeroCount{trailingEdgeZeroCount} |
| , fBuffer{buffer} |
| , fBufferEnd{bufferEnd} { } |
| |
| void blur(const uint8_t* src, size_t srcStride, const uint8_t* srcEnd, |
| uint8_t* dst, size_t dstStride, uint8_t* dstEnd) const override { |
| auto rightOuter = src; |
| auto dstCursor = dst; |
| |
| auto interpolateSums = [this](uint32_t outerSum, uint32_t innerSum) { |
| return SkTo<uint8_t>( |
| (fOuterWeight * outerSum + fInnerWeight * innerSum + kHalf) >> 24); |
| }; |
| |
| uint32_t outerSum = 0; |
| uint32_t innerSum = 0; |
| for (size_t i = 0; i < fTrailingEdgeZeroCount; i++) { |
| innerSum = outerSum; |
| outerSum += *rightOuter; |
| *dstCursor = interpolateSums(outerSum, innerSum); |
| |
| rightOuter += srcStride; |
| dstCursor += dstStride; |
| } |
| |
| // slidingWindow > width |
| for (size_t i = 0; i < fNoChangeCount; i++) { |
| *dstCursor = interpolateSums(outerSum, innerSum);; |
| dstCursor += dstStride; |
| } |
| |
| // width > slidingWindow |
| auto leftInner = src; |
| while (rightOuter < srcEnd) { |
| innerSum = outerSum - *leftInner; |
| outerSum += *rightOuter; |
| *dstCursor = interpolateSums(outerSum, innerSum); |
| outerSum -= *leftInner; |
| |
| rightOuter += srcStride; |
| leftInner += srcStride; |
| dstCursor += dstStride; |
| } |
| |
| auto leftOuter = srcEnd; |
| dstCursor = dstEnd; |
| outerSum = 0; |
| for (size_t i = 0; i < fTrailingEdgeZeroCount; i++) { |
| leftOuter -= srcStride; |
| dstCursor -= dstStride; |
| |
| innerSum = outerSum; |
| outerSum += *leftOuter; |
| *dstCursor = interpolateSums(outerSum, innerSum); |
| } |
| } |
| |
| bool canBlur4() override { return true; } |
| |
| // NB this is a transposing scan. The next src is src+1, and the next down is |
| // src+srcStride. |
| void blur4Transpose( |
| const uint8_t* src, size_t srcStride, const uint8_t* srcEnd, |
| uint8_t* dst, size_t dstStride, uint8_t* dstEnd) const override { |
| auto rightOuter = src; |
| auto dstCursor = dst; |
| |
| Sk4u* const bufferStart = fBuffer; |
| Sk4u* bufferCursor = bufferStart; |
| Sk4u* const bufferEnd = fBufferEnd; |
| |
| const Sk4u outerWeight(SkTo<uint32_t>(fOuterWeight)); |
| const Sk4u innerWeight(SkTo<uint32_t>(fInnerWeight)); |
| |
| auto load = [](const uint8_t* cursor, size_t stride) -> Sk4u { |
| return Sk4u(cursor[0*stride], cursor[1*stride], cursor[2*stride], cursor[3*stride]); |
| }; |
| |
| auto interpolateSums = [&] (const Sk4u& outerSum, const Sk4u& innerSum) { |
| return |
| SkNx_cast<uint8_t>( |
| (outerSum * outerWeight + innerSum * innerWeight + kHalf) >> 24); |
| }; |
| |
| Sk4u outerSum = 0; |
| Sk4u innerSum = 0; |
| for (size_t i = 0; i < fTrailingEdgeZeroCount; i++) { |
| innerSum = outerSum; |
| |
| Sk4u leadingEdge = load(rightOuter, srcStride); |
| outerSum += leadingEdge; |
| Sk4b blurred = interpolateSums(outerSum, innerSum); |
| blurred.store(dstCursor); |
| |
| leadingEdge.store(bufferCursor); |
| bufferCursor = (bufferCursor + 1) < bufferEnd ? bufferCursor + 1 : bufferStart; |
| |
| rightOuter += 1; |
| dstCursor += dstStride; |
| } |
| |
| // slidingWindow > width |
| for (size_t i = 0; i < fNoChangeCount; i++) { |
| Sk4b blurred = interpolateSums(outerSum, innerSum); |
| blurred.store(dstCursor); |
| dstCursor += dstStride; |
| } |
| |
| // width > slidingWindow |
| auto leftInner = src; |
| while (rightOuter < srcEnd) { |
| Sk4u trailEdge = Sk4u::Load(bufferCursor); |
| Sk4u leadingEdge = load(rightOuter, srcStride); |
| innerSum = outerSum - trailEdge; |
| outerSum += leadingEdge; |
| |
| Sk4b blurred = interpolateSums(outerSum, innerSum); |
| blurred.store(dstCursor); |
| |
| outerSum -= trailEdge; |
| leadingEdge.store(bufferCursor); |
| bufferCursor = (bufferCursor + 1) < bufferEnd ? bufferCursor + 1 : bufferStart; |
| |
| rightOuter += 1; |
| leftInner += 1; |
| dstCursor += dstStride; |
| } |
| |
| auto leftOuter = srcEnd; |
| dstCursor = dstEnd; |
| outerSum = 0; |
| for (size_t i = 0; i < fTrailingEdgeZeroCount; i++) { |
| leftOuter -= 1; |
| dstCursor -= dstStride; |
| |
| innerSum = outerSum; |
| outerSum += load(leftOuter, srcStride); |
| Sk4b blurred = interpolateSums(outerSum, innerSum); |
| blurred.store(dstCursor); |
| } |
| } |
| |
| private: |
| static constexpr uint32_t kHalf = static_cast<uint32_t>(1) << 23; |
| |
| const uint32_t fOuterWeight; |
| const uint32_t fInnerWeight; |
| const size_t fNoChangeCount; |
| const size_t fTrailingEdgeZeroCount; |
| Sk4u* const fBuffer; |
| Sk4u* const fBufferEnd; |
| }; |
| private: |
| uint32_t fOuterWeight; |
| uint32_t fInnerWeight; |
| size_t fSlidingWindow; |
| }; |
| |
| class PlanGauss final : public PlanningInterface { |
| public: |
| explicit PlanGauss(double sigma) { |
| auto possibleWindow = static_cast<size_t>(floor(sigma * 3 * sqrt(2 * kPi) / 4 + 0.5)); |
| auto window = std::max(static_cast<size_t>(1), possibleWindow); |
| |
| fPass0Size = window - 1; |
| fPass1Size = window - 1; |
| fPass2Size = (window & 1) == 1 ? window - 1 : window; |
| |
| // Calculating the border is tricky. I will go through the odd case which is simpler, and |
| // then through the even case. Given a stack of filters seven wide for the odd case of |
| // three passes. |
| // |
| // S |
| // aaaAaaa |
| // bbbBbbb |
| // cccCccc |
| // D |
| // |
| // The furthest changed pixel is when the filters are in the following configuration. |
| // |
| // S |
| // aaaAaaa |
| // bbbBbbb |
| // cccCccc |
| // D |
| // |
| // The A pixel is calculated using the value S, the B uses A, and the C uses B, and |
| // finally D is C. So, with a window size of seven the border is nine. In general, the |
| // border is 3*((window - 1)/2). |
| // |
| // For even cases the filter stack is more complicated. The spec specifies two passes |
| // of even filters and a final pass of odd filters. A stack for a width of six looks like |
| // this. |
| // |
| // S |
| // aaaAaa |
| // bbBbbb |
| // cccCccc |
| // D |
| // |
| // The furthest pixel looks like this. |
| // |
| // S |
| // aaaAaa |
| // bbBbbb |
| // cccCccc |
| // D |
| // |
| // For a window of size, the border value is seven. In general the border is 3 * |
| // (window/2) -1. |
| fBorder = (window & 1) == 1 ? 3 * ((window - 1) / 2) : 3 * (window / 2) - 1; |
| fSlidingWindow = 2 * fBorder + 1; |
| |
| // If the window is odd then the divisor is just window ^ 3 otherwise, |
| // it is window * window * (window + 1) = window ^ 2 + window ^ 3; |
| auto window2 = window * window; |
| auto window3 = window2 * window; |
| auto divisor = (window & 1) == 1 ? window3 : window3 + window2; |
| |
| fWeight = static_cast<uint64_t>(round(1.0 / divisor * (1ull << 32))); |
| } |
| |
| size_t bufferSize() const override { return fPass0Size + fPass1Size + fPass2Size; } |
| |
| size_t border() const override { return fBorder; } |
| |
| bool needsBlur() const override { return true; } |
| |
| BlurScanInterface* makeBlurScan( |
| SkArenaAlloc* alloc, size_t width, uint32_t* buffer) const override |
| { |
| uint32_t* buffer0, *buffer0End, *buffer1, *buffer1End, *buffer2, *buffer2End; |
| buffer0 = buffer; |
| buffer0End = buffer1 = buffer0 + fPass0Size; |
| buffer1End = buffer2 = buffer1 + fPass1Size; |
| buffer2End = buffer2 + fPass2Size; |
| size_t noChangeCount = fSlidingWindow > width ? fSlidingWindow - width : 0; |
| |
| return alloc->make<Gauss>( |
| fWeight, noChangeCount, |
| buffer0, buffer0End, |
| buffer1, buffer1End, |
| buffer2, buffer2End); |
| } |
| |
| public: |
| class Gauss final : public BlurScanInterface { |
| public: |
| Gauss(uint64_t weight, size_t noChangeCount, |
| uint32_t* buffer0, uint32_t* buffer0End, |
| uint32_t* buffer1, uint32_t* buffer1End, |
| uint32_t* buffer2, uint32_t* buffer2End) |
| : fWeight{weight} |
| , fNoChangeCount{noChangeCount} |
| , fBuffer0{buffer0} |
| , fBuffer0End{buffer0End} |
| , fBuffer1{buffer1} |
| , fBuffer1End{buffer1End} |
| , fBuffer2{buffer2} |
| , fBuffer2End{buffer2End} |
| { } |
| |
| void blur(const uint8_t* src, size_t srcStride, const uint8_t* srcEnd, |
| uint8_t* dst, size_t dstStride, uint8_t* dstEnd) const override { |
| auto buffer0Cursor = fBuffer0; |
| auto buffer1Cursor = fBuffer1; |
| auto buffer2Cursor = fBuffer2; |
| |
| std::memset(fBuffer0, 0x00, (fBuffer2End - fBuffer0) * sizeof(*fBuffer0)); |
| |
| uint32_t sum0 = 0; |
| uint32_t sum1 = 0; |
| uint32_t sum2 = 0; |
| |
| // Consume the source generating pixels. |
| for (auto srcCursor = src; |
| srcCursor < srcEnd; dst += dstStride, srcCursor += srcStride) { |
| uint32_t leadingEdge = *srcCursor; |
| sum0 += leadingEdge; |
| sum1 += sum0; |
| sum2 += sum1; |
| |
| *dst = this->finalScale(sum2); |
| |
| sum2 -= *buffer2Cursor; |
| *buffer2Cursor = sum1; |
| buffer2Cursor = (buffer2Cursor + 1) < fBuffer2End ? buffer2Cursor + 1 : fBuffer2; |
| |
| sum1 -= *buffer1Cursor; |
| *buffer1Cursor = sum0; |
| buffer1Cursor = (buffer1Cursor + 1) < fBuffer1End ? buffer1Cursor + 1 : fBuffer1; |
| |
| sum0 -= *buffer0Cursor; |
| *buffer0Cursor = leadingEdge; |
| buffer0Cursor = (buffer0Cursor + 1) < fBuffer0End ? buffer0Cursor + 1 : fBuffer0; |
| } |
| |
| // The leading edge is off the right side of the mask. |
| for (size_t i = 0; i < fNoChangeCount; i++) { |
| uint32_t leadingEdge = 0; |
| sum0 += leadingEdge; |
| sum1 += sum0; |
| sum2 += sum1; |
| |
| *dst = this->finalScale(sum2); |
| |
| sum2 -= *buffer2Cursor; |
| *buffer2Cursor = sum1; |
| buffer2Cursor = (buffer2Cursor + 1) < fBuffer2End ? buffer2Cursor + 1 : fBuffer2; |
| |
| sum1 -= *buffer1Cursor; |
| *buffer1Cursor = sum0; |
| buffer1Cursor = (buffer1Cursor + 1) < fBuffer1End ? buffer1Cursor + 1 : fBuffer1; |
| |
| sum0 -= *buffer0Cursor; |
| *buffer0Cursor = leadingEdge; |
| buffer0Cursor = (buffer0Cursor + 1) < fBuffer0End ? buffer0Cursor + 1 : fBuffer0; |
| |
| dst += dstStride; |
| } |
| |
| // Starting from the right, fill in the rest of the buffer. |
| std::memset(fBuffer0, 0, (fBuffer2End - fBuffer0) * sizeof(*fBuffer0)); |
| |
| sum0 = sum1 = sum2 = 0; |
| |
| uint8_t* dstCursor = dstEnd; |
| const uint8_t* srcCursor = srcEnd; |
| while (dstCursor > dst) { |
| dstCursor -= dstStride; |
| srcCursor -= srcStride; |
| uint32_t leadingEdge = *srcCursor; |
| sum0 += leadingEdge; |
| sum1 += sum0; |
| sum2 += sum1; |
| |
| *dstCursor = this->finalScale(sum2); |
| |
| sum2 -= *buffer2Cursor; |
| *buffer2Cursor = sum1; |
| buffer2Cursor = (buffer2Cursor + 1) < fBuffer2End ? buffer2Cursor + 1 : fBuffer2; |
| |
| sum1 -= *buffer1Cursor; |
| *buffer1Cursor = sum0; |
| buffer1Cursor = (buffer1Cursor + 1) < fBuffer1End ? buffer1Cursor + 1 : fBuffer1; |
| |
| sum0 -= *buffer0Cursor; |
| *buffer0Cursor = leadingEdge; |
| buffer0Cursor = (buffer0Cursor + 1) < fBuffer0End ? buffer0Cursor + 1 : fBuffer0; |
| } |
| } |
| |
| private: |
| static constexpr uint64_t kHalf = static_cast<uint64_t>(1) << 31; |
| |
| uint8_t finalScale(uint32_t sum) const { |
| return SkTo<uint8_t>((fWeight * sum + kHalf) >> 32); |
| } |
| |
| uint64_t fWeight; |
| size_t fNoChangeCount; |
| uint32_t* fBuffer0; |
| uint32_t* fBuffer0End; |
| uint32_t* fBuffer1; |
| uint32_t* fBuffer1End; |
| uint32_t* fBuffer2; |
| uint32_t* fBuffer2End; |
| }; |
| |
| uint64_t fWeight; |
| size_t fBorder; |
| size_t fSlidingWindow; |
| size_t fPass0Size; |
| size_t fPass1Size; |
| size_t fPass2Size; |
| }; |
| |
| static PlanningInterface* make_plan(SkArenaAlloc* alloc, double sigma) { |
| PlanningInterface* plan = nullptr; |
| |
| if (3 * sigma <= 1) { |
| plan = alloc->make<None>(); |
| } else if (sigma < kSmallSigma) { |
| plan = alloc->make<PlanBox>(sigma); |
| } else { |
| plan = alloc->make<PlanGauss>(sigma); |
| } |
| |
| return plan; |
| }; |
| |
| // NB 136 is the largest sigma that will not cause a buffer full of 255 mask values to overflow |
| // using the Gauss filter. It also limits the size of buffers used hold intermediate values. |
| // Explanation of maximums: |
| // sum0 = window * 255 |
| // sum1 = window * sum0 -> window * window * 255 |
| // sum2 = window * sum1 -> window * window * window * 255 -> window^3 * 255 |
| // |
| // The value window^3 * 255 must fit in a uint32_t. So, |
| // window^3 < 2^32. window = 255. |
| // |
| // window = floor(sigma * 3 * sqrt(2 * kPi) / 4 + 0.5) |
| // For window <= 255, the largest value for sigma is 136. |
| SkMaskBlurFilter::SkMaskBlurFilter(double sigmaW, double sigmaH) |
| : fSigmaW{SkTPin(sigmaW, 0.0, 136.0)} |
| , fSigmaH{SkTPin(sigmaH, 0.0, 136.0)} |
| { |
| SkASSERT(sigmaW >= 0); |
| SkASSERT(sigmaH >= 0); |
| } |
| |
| bool SkMaskBlurFilter::hasNoBlur() const { |
| return (3 * fSigmaW <= 1) && (3 * fSigmaH <= 1); |
| } |
| |
| static SkMask prepare_destination(int radiusX, int radiusY, const SkMask& src) { |
| SkSafeMath safe; |
| |
| SkMask dst; |
| // dstW = srcW + 2 * radiusX; |
| int dstW = safe.add(src.fBounds.width(), safe.add(radiusX, radiusX)); |
| // dstH = srcH + 2 * radiusY; |
| int dstH = safe.add(src.fBounds.height(), safe.add(radiusY, radiusY)); |
| |
| dst.fBounds.set(0, 0, dstW, dstH); |
| dst.fBounds.offset(src.fBounds.x(), src.fBounds.y()); |
| dst.fBounds.offset(-SkTo<int32_t>(radiusX), -SkTo<int32_t>(radiusY)); |
| |
| dst.fImage = nullptr; |
| dst.fRowBytes = SkTo<uint32_t>(dstW); |
| dst.fFormat = SkMask::kA8_Format; |
| |
| size_t toAlloc = safe.mul(dstW, dstH); |
| |
| if (safe && src.fImage != nullptr) { |
| dst.fImage = SkMask::AllocImage(toAlloc); |
| } |
| |
| return dst; |
| } |
| |
| #if !defined(SK_USE_LEGACY_INTERP_BLUR) |
| static constexpr uint16_t _____ = 0u; |
| static constexpr uint16_t kHalf = 0x80u; |
| |
| static SK_ALWAYS_INLINE Sk8h load(const uint8_t* from, int width) { |
| uint8_t buffer[8]; |
| if (width < 8) { |
| sk_bzero(buffer, sizeof(buffer)); |
| for (int i = 0; i < width; i++) { |
| buffer[i] = from[i]; |
| } |
| from = buffer; |
| } |
| auto v = SkNx_cast<uint16_t>(Sk8b::Load(from)); |
| // Convert from 0-255 to 8.8 encoding. |
| return v << 8; |
| }; |
| |
| static SK_ALWAYS_INLINE void store(uint8_t* to, const Sk8h& v, int width) { |
| Sk8b b = SkNx_cast<uint8_t>(v >> 8); |
| if (width == 8) { |
| b.store(to); |
| } else { |
| uint8_t buffer[8]; |
| b.store(buffer); |
| for (int i = 0; i < width; i++) { |
| to[i] = buffer[i]; |
| } |
| } |
| }; |
| |
| // In all the blur_x_radius_N and blur_y_radius_N functions the gaussian values are encoded |
| // in 0.16 format, none of the values is greater than one. The incoming mask values are in 8.8 |
| // format. The resulting multiply has a 8.24 format, by the mulhi truncates the lower 16 bits |
| // resulting in a 8.8 format. |
| // |
| // The blur_x_radius_N function below blur along a row of pixels using a kernel with radius N. This |
| // system is setup to minimize the number of multiplies needed. |
| // |
| // Explanation: |
| // Blurring a specific mask value is given by the following equation where D_n is the resulting |
| // mask value and S_n is the source value. The example below is for a filter with a radius of 1 |
| // and a width of 3 (radius == (width-1)/2). The indexes for the source and destination are |
| // aligned. The filter is given by G_n where n is the symmetric filter value. |
| // |
| // D[n] = S[n-1]*G[1] + S[n]*G[0] + S[n+1]*G[1]. |
| // |
| // We can start the source index at an offset relative to the destination separated by the |
| // radius. This results in a non-traditional restating of the above filter. |
| // |
| // D[n] = S[n]*G[1] + S[n+1]*G[0] + S[n+2]*G[1] |
| // |
| // If we look at three specific consecutive destinations the following equations result: |
| // |
| // D[5] = S[5]*G[1] + S[6]*G[0] + S[7]*G[1] |
| // D[7] = S[6]*G[1] + S[7]*G[0] + S[8]*G[1] |
| // D[8] = S[7]*G[1] + S[8]*G[0] + S[9]*G[1]. |
| // |
| // In the above equations, notice that S[7] is used in all three. In particular, two values are |
| // used: S[7]*G[0] and S[7]*G[1]. So, S[7] is only multiplied twice, but used in D[5], D[6] and |
| // D[7]. |
| // |
| // From the point of view of a source value we end up with the following three equations. |
| // |
| // Given S[7]: |
| // D[5] += S[7]*G[1] |
| // D[6] += S[7]*G[0] |
| // D[7] += S[7]*G[1] |
| // |
| // In General: |
| // D[n] += S[n]*G[1] |
| // D[n+1] += S[n]*G[0] |
| // D[n+2] += S[n]*G[1] |
| // |
| // Now these equations can be ganged using SIMD to form: |
| // D[n..n+7] += S[n..n+7]*G[1] |
| // D[n+1..n+8] += S[n..n+7]*G[0] |
| // D[n+2..n+9] += S[n..n+7]*G[1] |
| // The next set of values becomes. |
| // D[n+8..n+15] += S[n+8..n+15]*G[1] |
| // D[n+9..n+16] += S[n+8..n+15]*G[0] |
| // D[n+10..n+17] += S[n+8..n+15]*G[1] |
| // You can see that the D[n+8] and D[n+9] values overlap the two sets, using parts of both |
| // S[n..7] and S[n+8..n+15]. |
| // |
| // Just one more transformation allows the code to maintain all working values in |
| // registers. I introduce the notation {0, S[n..n+7] * G[k]} to mean that the value where 0 is |
| // prepended to the array of values to form {0, S[n] * G[k], ..., S[n+7]*G[k]}. |
| // |
| // D[n..n+7] += S[n..n+7] * G[1] |
| // D[n..n+8] += {0, S[n..n+7] * G[0]} |
| // D[n..n+9] += {0, 0, S[n..n+7] * G[1]} |
| // |
| // Now we can encode D[n..n+7] in a single Sk8h register called d0, and D[n+8..n+15] in a |
| // register d8. In addition, S[0..n+7] becomes s0. |
| // |
| // The translation of the {0, S[n..n+7] * G[k]} is translated in the following way below. |
| // |
| // Sk8h v0 = s0*G[0] |
| // Sk8h v1 = s0*G[1] |
| // /* D[n..n+7] += S[n..n+7] * G[1] */ |
| // d0 += v1; |
| // /* D[n..n+8] += {0, S[n..n+7] * G[0]} */ |
| // d0 += {_____, v0[0], v0[1], v0[2], v0[3], v0[4], v0[5], v0[6]} |
| // d1 += {v0[7], _____, _____, _____, _____, _____, _____, _____} |
| // /* D[n..n+9] += {0, 0, S[n..n+7] * G[1]} */ |
| // d0 += {_____, _____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5]} |
| // d1 += {v1[6], v1[7], _____, _____, _____, _____, _____, _____} |
| // Where we rely on the compiler to generate efficient code for the {____, n, ....} notation. |
| |
| static SK_ALWAYS_INLINE void blur_x_radius_1( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h&, const Sk8h&, const Sk8h&, |
| Sk8h* d0, Sk8h* d8) { |
| |
| auto v1 = s0.mulHi(g1); |
| auto v0 = s0.mulHi(g0); |
| |
| // D[n..n+7] += S[n..n+7] * G[1] |
| *d0 += v1; |
| |
| //D[n..n+8] += {0, S[n..n+7] * G[0]} |
| *d0 += Sk8h{_____, v0[0], v0[1], v0[2], v0[3], v0[4], v0[5], v0[6]}; |
| *d8 += Sk8h{v0[7], _____, _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+9] += {0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5]}; |
| *d8 += Sk8h{v1[6], v1[7], _____, _____, _____, _____, _____, _____}; |
| |
| } |
| |
| static SK_ALWAYS_INLINE void blur_x_radius_2( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h&, const Sk8h&, |
| Sk8h* d0, Sk8h* d8) { |
| auto v0 = s0.mulHi(g0); |
| auto v1 = s0.mulHi(g1); |
| auto v2 = s0.mulHi(g2); |
| |
| // D[n..n+7] += S[n..n+7] * G[2] |
| *d0 += v2; |
| |
| // D[n..n+8] += {0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5], v1[6]}; |
| *d8 += Sk8h{v1[7], _____, _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+9] += {0, 0, S[n..n+7] * G[0]} |
| *d0 += Sk8h{_____, _____, v0[0], v0[1], v0[2], v0[3], v0[4], v0[5]}; |
| *d8 += Sk8h{v0[6], v0[7], _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+10] += {0, 0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, _____, v1[0], v1[1], v1[2], v1[3], v1[4]}; |
| *d8 += Sk8h{v1[5], v1[6], v1[7], _____, _____, _____, _____, _____}; |
| |
| // D[n..n+11] += {0, 0, 0, 0, S[n..n+7] * G[2]} |
| *d0 += Sk8h{_____, _____, _____, _____, v2[0], v2[1], v2[2], v2[3]}; |
| *d8 += Sk8h{v2[4], v2[5], v2[6], v2[7], _____, _____, _____, _____}; |
| } |
| |
| static SK_ALWAYS_INLINE void blur_x_radius_3( |
| const Sk8h& s0, |
| const Sk8h& gauss0, const Sk8h& gauss1, const Sk8h& gauss2, const Sk8h& gauss3, const Sk8h&, |
| Sk8h* d0, Sk8h* d8) { |
| auto v0 = s0.mulHi(gauss0); |
| auto v1 = s0.mulHi(gauss1); |
| auto v2 = s0.mulHi(gauss2); |
| auto v3 = s0.mulHi(gauss3); |
| |
| // D[n..n+7] += S[n..n+7] * G[3] |
| *d0 += v3; |
| |
| // D[n..n+8] += {0, S[n..n+7] * G[2]} |
| *d0 += Sk8h{_____, v2[0], v2[1], v2[2], v2[3], v2[4], v2[5], v2[6]}; |
| *d8 += Sk8h{v2[7], _____, _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+9] += {0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, v1[0], v1[1], v1[2], v1[3], v1[4], v1[5]}; |
| *d8 += Sk8h{v1[6], v1[7], _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+10] += {0, 0, 0, S[n..n+7] * G[0]} |
| *d0 += Sk8h{_____, _____, _____, v0[0], v0[1], v0[2], v0[3], v0[4]}; |
| *d8 += Sk8h{v0[5], v0[6], v0[7], _____, _____, _____, _____, _____}; |
| |
| // D[n..n+11] += {0, 0, 0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, _____, _____, v1[0], v1[1], v1[2], v1[3]}; |
| *d8 += Sk8h{v1[4], v1[5], v1[6], v1[7], _____, _____, _____, _____}; |
| |
| // D[n..n+12] += {0, 0, 0, 0, 0, S[n..n+7] * G[2]} |
| *d0 += Sk8h{_____, _____, _____, _____, _____, v2[0], v2[1], v2[2]}; |
| *d8 += Sk8h{v2[3], v2[4], v2[5], v2[6], v2[7], _____, _____, _____}; |
| |
| // D[n..n+13] += {0, 0, 0, 0, 0, 0, S[n..n+7] * G[3]} |
| *d0 += Sk8h{_____, _____, _____, _____, _____, _____, v3[0], v3[1]}; |
| *d8 += Sk8h{v3[2], v3[3], v3[4], v3[5], v3[6], v3[7], _____, _____}; |
| } |
| |
| static SK_ALWAYS_INLINE void blur_x_radius_4( |
| const Sk8h& s0, |
| const Sk8h& gauss0, |
| const Sk8h& gauss1, |
| const Sk8h& gauss2, |
| const Sk8h& gauss3, |
| const Sk8h& gauss4, |
| Sk8h* d0, Sk8h* d8) { |
| auto v0 = s0.mulHi(gauss0); |
| auto v1 = s0.mulHi(gauss1); |
| auto v2 = s0.mulHi(gauss2); |
| auto v3 = s0.mulHi(gauss3); |
| auto v4 = s0.mulHi(gauss4); |
| |
| // D[n..n+7] += S[n..n+7] * G[4] |
| *d0 += v4; |
| |
| // D[n..n+8] += {0, S[n..n+7] * G[3]} |
| *d0 += Sk8h{_____, v3[0], v3[1], v3[2], v3[3], v3[4], v3[5], v3[6]}; |
| *d8 += Sk8h{v3[7], _____, _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+9] += {0, 0, S[n..n+7] * G[2]} |
| *d0 += Sk8h{_____, _____, v2[0], v2[1], v2[2], v2[3], v2[4], v2[5]}; |
| *d8 += Sk8h{v2[6], v2[7], _____, _____, _____, _____, _____, _____}; |
| |
| // D[n..n+10] += {0, 0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, _____, v1[0], v1[1], v1[2], v1[3], v1[4]}; |
| *d8 += Sk8h{v1[5], v1[6], v1[7], _____, _____, _____, _____, _____}; |
| |
| // D[n..n+11] += {0, 0, 0, 0, S[n..n+7] * G[0]} |
| *d0 += Sk8h{_____, _____, _____, _____, v0[0], v0[1], v0[2], v0[3]}; |
| *d8 += Sk8h{v0[4], v0[5], v0[6], v0[7], _____, _____, _____, _____}; |
| |
| // D[n..n+12] += {0, 0, 0, 0, 0, S[n..n+7] * G[1]} |
| *d0 += Sk8h{_____, _____, _____, _____, _____, v1[0], v1[1], v1[2]}; |
| *d8 += Sk8h{v1[3], v1[4], v1[5], v1[6], v1[7], _____, _____, _____}; |
| |
| // D[n..n+13] += {0, 0, 0, 0, 0, 0, S[n..n+7] * G[2]} |
| *d0 += Sk8h{_____, _____, _____, _____, _____, _____, v2[0], v2[1]}; |
| *d8 += Sk8h{v2[2], v2[3], v2[4], v2[5], v2[6], v2[7], _____, _____}; |
| |
| // D[n..n+14] += {0, 0, 0, 0, 0, 0, 0, S[n..n+7] * G[3]} |
| *d0 += Sk8h{_____, _____, _____, _____, _____, _____, _____, v3[0]}; |
| *d8 += Sk8h{v3[1], v3[2], v3[3], v3[4], v3[5], v3[6], v3[7], _____}; |
| |
| // D[n..n+15] += {0, 0, 0, 0, 0, 0, 0, 0, S[n..n+7] * G[4]} |
| *d8 += v4; |
| } |
| |
| using BlurX = decltype(blur_x_radius_1); |
| |
| // BlurX will only be one of the functions blur_x_radius_(1|2|3|4). |
| static SK_ALWAYS_INLINE void blur_row( |
| BlurX blur, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h& g3, const Sk8h& g4, |
| const uint8_t* src, int srcW, |
| uint8_t* dst, int dstW) { |
| // Clear the buffer to handle summing wider than source. |
| Sk8h d0{kHalf}, d8{kHalf}; |
| |
| // Go by multiples of 8 in src. |
| int x = 0; |
| for (; x <= srcW - 8; x += 8) { |
| blur(load(src, 8), g0, g1, g2, g3, g4, &d0, &d8); |
| |
| store(dst, d0, 8); |
| |
| d0 = d8; |
| d8 = Sk8h{kHalf}; |
| |
| src += 8; |
| dst += 8; |
| } |
| |
| // There are src values left, but the remainder of src values is not a multiple of 8. |
| int srcTail = srcW - x; |
| if (srcTail > 0) { |
| |
| blur(load(src, srcTail), g0, g1, g2, g3, g4, &d0, &d8); |
| |
| int dstTail = std::min(8, dstW - x); |
| store(dst, d0, dstTail); |
| |
| d0 = d8; |
| dst += dstTail; |
| x += dstTail; |
| } |
| |
| // There are dst mask values to complete. |
| int dstTail = dstW - x; |
| if (dstTail > 0) { |
| store(dst, d0, dstTail); |
| } |
| } |
| |
| // BlurX will only be one of the functions blur_x_radius_(1|2|3|4). |
| static SK_ALWAYS_INLINE void blur_x_rect( |
| BlurX blur, |
| uint16_t* gauss, |
| const uint8_t* src, size_t srcStride, int srcW, |
| uint8_t* dst, size_t dstStride, int dstW, int dstH) { |
| |
| Sk8h g0{gauss[0]}, |
| g1{gauss[1]}, |
| g2{gauss[2]}, |
| g3{gauss[3]}, |
| g4{gauss[4]}; |
| |
| // Blur *ALL* the rows. |
| for (int y = 0; y < dstH; y++) { |
| blur_row(blur, g0, g1, g2, g3, g4, src, srcW, dst, dstW); |
| src += srcStride; |
| dst += dstStride; |
| } |
| } |
| |
| SK_ATTRIBUTE(noinline) static void direct_blur_x( |
| int radius, uint16_t* gauss, |
| const uint8_t* src, size_t srcStride, int srcW, |
| uint8_t* dst, size_t dstStride, int dstW, int dstH) { |
| |
| switch (radius) { |
| case 1: |
| blur_x_rect(blur_x_radius_1, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH); |
| break; |
| |
| case 2: |
| blur_x_rect(blur_x_radius_2, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH); |
| break; |
| |
| case 3: |
| blur_x_rect(blur_x_radius_3, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH); |
| break; |
| |
| case 4: |
| blur_x_rect(blur_x_radius_4, gauss, src, srcStride, srcW, dst, dstStride, dstW, dstH); |
| break; |
| |
| default: |
| SkASSERTF(false, "The radius %d is not handled\n", radius); |
| } |
| } |
| |
| // The operations of the blur_y_radius_N functions work on a theme similar to the blur_x_radius_N |
| // functions, but end up being simpler because there is no complicated shift of registers. We |
| // start with the non-traditional form of the gaussian filter. In the following r is the value |
| // when added generates the next value in the column. |
| // |
| // D[n+0r] = S[n+0r]*G[1] |
| // + S[n+1r]*G[0] |
| // + S[n+2r]*G[1] |
| // |
| // Expanding out in a way similar to blur_x_radius_N for specific values of n. |
| // |
| // D[n+0r] = S[n-2r]*G[1] + S[n-1r]*G[0] + S[n+0r]*G[1] |
| // D[n+1r] = S[n-1r]*G[1] + S[n+0r]*G[0] + S[n+1r]*G[1] |
| // D[n+2r] = S[n+0r]*G[1] + S[n+1r]*G[0] + S[n+2r]*G[1] |
| // |
| // We can see that S[n+0r] is in all three D[] equations, but is only multiplied twice. Now we |
| // can look at the calculation form the point of view of a source value. |
| // |
| // Given S[n+0r]: |
| // D[n+0r] += S[n+0r]*G[1]; |
| // /* D[n+0r] is done and can be stored now. */ |
| // D[n+1r] += S[n+0r]*G[0]; |
| // D[n+2r] = S[n+0r]*G[1]; |
| // |
| // Remember, by induction, that D[n+0r] == S[n-2r]*G[1] + S[n-1r]*G[0] before adding in |
| // S[n+0r]*G[1]. So, after the addition D[n+0r] has finished calculation and can be stored. Also, |
| // notice that D[n+2r] is receiving its first value from S[n+0r]*G[1] and is not added in. Notice |
| // how values flow in the following two iterations in source. |
| // |
| // D[n+0r] += S[n+0r]*G[1] |
| // D[n+1r] += S[n+0r]*G[0] |
| // D[n+2r] = S[n+0r]*G[1] |
| // /* ------- */ |
| // D[n+1r] += S[n+1r]*G[1] |
| // D[n+2r] += S[n+1r]*G[0] |
| // D[n+3r] = S[n+1r]*G[1] |
| // |
| // Instead of using memory we can introduce temporaries d01 and d12. The update step changes |
| // to the following. |
| // |
| // answer = d01 + S[n+0r]*G[1] |
| // d01 = d12 + S[n+0r]*G[0] |
| // d12 = S[n+0r]*G[1] |
| // return answer |
| // |
| // Finally, this can be ganged into SIMD style. |
| // answer[0..7] = d01[0..7] + S[n+0r..n+0r+7]*G[1] |
| // d01[0..7] = d12[0..7] + S[n+0r..n+0r+7]*G[0] |
| // d12[0..7] = S[n+0r..n+0r+7]*G[1] |
| // return answer[0..7] |
| static SK_ALWAYS_INLINE Sk8h blur_y_radius_1( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h&, const Sk8h&, const Sk8h&, |
| Sk8h* d01, Sk8h* d12, Sk8h*, Sk8h*, Sk8h*, Sk8h*, Sk8h*, Sk8h*) { |
| auto v0 = s0.mulHi(g0); |
| auto v1 = s0.mulHi(g1); |
| |
| Sk8h answer = *d01 + v1; |
| *d01 = *d12 + v0; |
| *d12 = v1 + kHalf; |
| |
| return answer; |
| } |
| |
| static SK_ALWAYS_INLINE Sk8h blur_y_radius_2( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h&, const Sk8h&, |
| Sk8h* d01, Sk8h* d12, Sk8h* d23, Sk8h* d34, Sk8h*, Sk8h*, Sk8h*, Sk8h*) { |
| auto v0 = s0.mulHi(g0); |
| auto v1 = s0.mulHi(g1); |
| auto v2 = s0.mulHi(g2); |
| |
| Sk8h answer = *d01 + v2; |
| *d01 = *d12 + v1; |
| *d12 = *d23 + v0; |
| *d23 = *d34 + v1; |
| *d34 = v2 + kHalf; |
| |
| return answer; |
| } |
| |
| static SK_ALWAYS_INLINE Sk8h blur_y_radius_3( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h& g3, const Sk8h&, |
| Sk8h* d01, Sk8h* d12, Sk8h* d23, Sk8h* d34, Sk8h* d45, Sk8h* d56, Sk8h*, Sk8h*) { |
| auto v0 = s0.mulHi(g0); |
| auto v1 = s0.mulHi(g1); |
| auto v2 = s0.mulHi(g2); |
| auto v3 = s0.mulHi(g3); |
| |
| Sk8h answer = *d01 + v3; |
| *d01 = *d12 + v2; |
| *d12 = *d23 + v1; |
| *d23 = *d34 + v0; |
| *d34 = *d45 + v1; |
| *d45 = *d56 + v2; |
| *d56 = v3 + kHalf; |
| |
| return answer; |
| } |
| |
| static SK_ALWAYS_INLINE Sk8h blur_y_radius_4( |
| const Sk8h& s0, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h& g3, const Sk8h& g4, |
| Sk8h* d01, Sk8h* d12, Sk8h* d23, Sk8h* d34, Sk8h* d45, Sk8h* d56, Sk8h* d67, Sk8h* d78) { |
| auto v0 = s0.mulHi(g0); |
| auto v1 = s0.mulHi(g1); |
| auto v2 = s0.mulHi(g2); |
| auto v3 = s0.mulHi(g3); |
| auto v4 = s0.mulHi(g4); |
| |
| Sk8h answer = *d01 + v4; |
| *d01 = *d12 + v3; |
| *d12 = *d23 + v2; |
| *d23 = *d34 + v1; |
| *d34 = *d45 + v0; |
| *d45 = *d56 + v1; |
| *d56 = *d67 + v2; |
| *d67 = *d78 + v3; |
| *d78 = v4 + kHalf; |
| |
| return answer; |
| } |
| |
| using BlurY = decltype(blur_y_radius_1); |
| |
| // BlurY will be one of blur_y_radius_(1|2|3|4). |
| static SK_ALWAYS_INLINE void blur_column( |
| BlurY blur, int radius, int width, |
| const Sk8h& g0, const Sk8h& g1, const Sk8h& g2, const Sk8h& g3, const Sk8h& g4, |
| const uint8_t* src, size_t srcStride, int srcH, |
| uint8_t* dst, size_t dstStride) { |
| Sk8h d01{kHalf}, d12{kHalf}, d23{kHalf}, d34{kHalf}, |
| d45{kHalf}, d56{kHalf}, d67{kHalf}, d78{kHalf}; |
| |
| auto flush = [&](uint8_t* to, const Sk8h& v0, const Sk8h& v1) { |
| store(to, v0, width); |
| to += dstStride; |
| store(to, v1, width); |
| return to + dstStride; |
| }; |
| |
| for (int y = 0; y < srcH; y += 1) { |
| auto s = load(src, width); |
| auto b = blur(s, |
| g0, g1, g2, g3, g4, |
| &d01, &d12, &d23, &d34, &d45, &d56, &d67, &d78); |
| store(dst, b, width); |
| src += srcStride; |
| dst += dstStride; |
| } |
| |
| if (radius >= 1) { |
| dst = flush(dst, d01, d12); |
| } |
| if (radius >= 2) { |
| dst = flush(dst, d23, d34); |
| } |
| if (radius >= 3) { |
| dst = flush(dst, d45, d56); |
| } |
| if (radius >= 4) { |
| flush(dst, d67, d78); |
| } |
| } |
| |
| // BlurY will be one of blur_y_radius_(1|2|3|4). |
| static SK_ALWAYS_INLINE void blur_y_rect( |
| BlurY blur, int radius, uint16_t *gauss, |
| const uint8_t *src, size_t srcStride, int srcW, int srcH, |
| uint8_t *dst, size_t dstStride) { |
| |
| Sk8h g0{gauss[0]}, |
| g1{gauss[1]}, |
| g2{gauss[2]}, |
| g3{gauss[3]}, |
| g4{gauss[4]}; |
| |
| int x = 0; |
| for (; x <= srcW - 8; x += 8) { |
| blur_column(blur, radius, 8, |
| g0, g1, g2, g3, g4, |
| src, srcStride, srcH, |
| dst, dstStride); |
| src += 8; |
| dst += 8; |
| } |
| |
| int xTail = srcW - x; |
| if (xTail > 0) { |
| blur_column(blur, radius, xTail, |
| g0, g1, g2, g3, g4, |
| src, srcStride, srcH, |
| dst, dstStride); |
| } |
| } |
| |
| SK_ATTRIBUTE(noinline) static void direct_blur_y( |
| int radius, uint16_t* gauss, |
| const uint8_t* src, size_t srcStride, int srcW, int srcH, |
| uint8_t* dst, size_t dstStride) { |
| |
| switch (radius) { |
| case 1: |
| blur_y_rect(blur_y_radius_1, 1, gauss, |
| src, srcStride, srcW, srcH, |
| dst, dstStride); |
| break; |
| |
| case 2: |
| blur_y_rect(blur_y_radius_2, 2, gauss, |
| src, srcStride, srcW, srcH, |
| dst, dstStride); |
| break; |
| |
| case 3: |
| blur_y_rect(blur_y_radius_3, 3, gauss, |
| src, srcStride, srcW, srcH, |
| dst, dstStride); |
| break; |
| |
| case 4: |
| blur_y_rect(blur_y_radius_4, 4, gauss, |
| src, srcStride, srcW, srcH, |
| dst, dstStride); |
| break; |
| |
| default: |
| SkASSERTF(false, "The radius %d is not handled\n", radius); |
| } |
| } |
| |
| static SkIPoint small_blur(double sigmaX, double sigmaY, const SkMask& src, SkMask* dst) { |
| SkASSERT(0 <= sigmaX && sigmaX < 2); |
| SkASSERT(0 <= sigmaY && sigmaY < 2); |
| |
| SkGaussFilter filterX{sigmaX, SkGaussFilter::Type::Bessel}, |
| filterY{sigmaY, SkGaussFilter::Type::Bessel}; |
| |
| int radiusX = filterX.radius(), |
| radiusY = filterY.radius(); |
| |
| SkASSERT(radiusX <= 4 && radiusY <= 4); |
| |
| auto prepareGauss = [](const SkGaussFilter& filter, uint16_t* factors) { |
| int i = 0; |
| for (double d : filter) { |
| factors[i++] = static_cast<uint16_t>(round(d * (1 << 16))); |
| } |
| }; |
| |
| uint16_t gaussFactorsX[5], |
| gaussFactorsY[5]; |
| |
| prepareGauss(filterX, gaussFactorsX); |
| prepareGauss(filterY, gaussFactorsY); |
| |
| *dst = prepare_destination(radiusX, radiusY, src); |
| if (src.fImage == nullptr) { |
| return {SkTo<int32_t>(radiusX), SkTo<int32_t>(radiusY)}; |
| } |
| if (dst->fImage == nullptr) { |
| dst->fBounds.setEmpty(); |
| return {0, 0}; |
| } |
| |
| int srcW = src.fBounds.width(), |
| srcH = src.fBounds.height(); |
| |
| int dstW = dst->fBounds.width(), |
| dstH = dst->fBounds.height(); |
| |
| size_t srcStride = src.fRowBytes, |
| dstStride = dst->fRowBytes; |
| |
| //TODO: handle bluring in only one direction. |
| |
| // Blur vertically and copy to destination. |
| direct_blur_y(radiusY, gaussFactorsY, |
| src.fImage, srcStride, srcW, srcH, |
| dst->fImage + radiusX, dstStride); |
| |
| // Blur horizontally in place. |
| direct_blur_x(radiusX, gaussFactorsX, |
| dst->fImage + radiusX, dstStride, srcW, |
| dst->fImage, dstStride, dstW, dstH); |
| |
| return {radiusX, radiusY}; |
| } |
| #endif // SK_USE_LEGACY_INTERP_BLUR |
| |
| SkIPoint SkMaskBlurFilter::blur(const SkMask& src, SkMask* dst) const { |
| |
| #if !defined(SK_USE_LEGACY_INTERP_BLUR) |
| if (fSigmaW < 2.0 && fSigmaH < 2.0) { |
| return small_blur(fSigmaW, fSigmaH, src, dst); |
| } |
| #endif |
| |
| // 1024 is a place holder guess until more analysis can be done. |
| SkSTArenaAlloc<1024> alloc; |
| |
| PlanningInterface* planW = make_plan(&alloc, fSigmaW); |
| PlanningInterface* planH = make_plan(&alloc, fSigmaH); |
| |
| size_t borderW = planW->border(), |
| borderH = planH->border(); |
| |
| *dst = prepare_destination(borderW, borderH, src); |
| if (src.fImage == nullptr) { |
| return {SkTo<int32_t>(borderW), SkTo<int32_t>(borderH)}; |
| } |
| if (dst->fImage == nullptr) { |
| dst->fBounds.setEmpty(); |
| return {0, 0}; |
| } |
| |
| auto srcW = SkTo<size_t>(src.fBounds.width()); |
| auto srcH = SkTo<size_t>(src.fBounds.height()); |
| |
| size_t dstW = dst->fBounds.width(), |
| dstH = dst->fBounds.height(); |
| |
| auto bufferSize = std::max(planW->bufferSize(), planH->bufferSize()); |
| auto buffer = alloc.makeArrayDefault<uint32_t>(bufferSize); |
| |
| if (planW->needsBlur() && planH->needsBlur()) { |
| // Blur both directions. |
| size_t tmpW = srcH; |
| size_t tmpH = dstW; |
| |
| auto tmp = alloc.makeArrayDefault<uint8_t>(tmpW * tmpH); |
| |
| // Blur horizontally, and transpose. |
| auto scanW = planW->makeBlurScan(&alloc, srcW, buffer); |
| size_t y = 0; |
| if (scanW->canBlur4() && srcH > 4) { |
| for (;y + 4 <= srcH; y += 4) { |
| auto srcStart = &src.fImage[y * src.fRowBytes]; |
| auto tmpStart = &tmp[y]; |
| scanW->blur4Transpose(srcStart, src.fRowBytes, srcStart + srcW, |
| tmpStart, tmpW, tmpStart + tmpW * tmpH); |
| } |
| } |
| |
| for (;y < srcH; y++) { |
| auto srcStart = &src.fImage[y * src.fRowBytes]; |
| auto tmpStart = &tmp[y]; |
| scanW->blur(srcStart, 1, srcStart + srcW, |
| tmpStart, tmpW, tmpStart + tmpW * tmpH); |
| } |
| |
| // Blur vertically (scan in memory order because of the transposition), |
| // and transpose back to the original orientation. |
| auto scanH = planH->makeBlurScan(&alloc, tmpW, buffer); |
| y = 0; |
| if (scanH->canBlur4() && tmpH > 4) { |
| for (;y + 4 <= tmpH; y += 4) { |
| auto tmpStart = &tmp[y * tmpW]; |
| auto dstStart = &dst->fImage[y]; |
| |
| scanH->blur4Transpose( |
| tmpStart, tmpW, tmpStart + tmpW, |
| dstStart, dst->fRowBytes, dstStart + dst->fRowBytes * dstH); |
| } |
| } |
| for (;y < tmpH; y++) { |
| auto tmpStart = &tmp[y * tmpW]; |
| auto dstStart = &dst->fImage[y]; |
| |
| scanH->blur(tmpStart, 1, tmpStart + tmpW, |
| dstStart, dst->fRowBytes, dstStart + dst->fRowBytes * dstH); |
| } |
| } else if (planW->needsBlur()) { |
| // Blur only horizontally. |
| |
| auto scanW = planW->makeBlurScan(&alloc, srcW, buffer); |
| for (size_t y = 0; y < srcH; y++) { |
| auto srcStart = &src.fImage[y * src.fRowBytes]; |
| auto dstStart = &dst->fImage[y * dst->fRowBytes]; |
| scanW->blur(srcStart, 1, srcStart + srcW, |
| dstStart, 1, dstStart + dstW); |
| |
| } |
| } else if (planH->needsBlur()) { |
| // Blur only vertically. |
| |
| auto srcEnd = &src.fImage[src.fRowBytes * srcH]; |
| auto dstEnd = &dst->fImage[dst->fRowBytes * dstH]; |
| auto scanH = planH->makeBlurScan(&alloc, srcH, buffer); |
| for (size_t x = 0; x < srcW; x++) { |
| auto srcStart = &src.fImage[x]; |
| auto dstStart = &dst->fImage[x]; |
| scanH->blur(srcStart, src.fRowBytes, srcEnd, |
| dstStart, dst->fRowBytes, dstEnd); |
| } |
| } else { |
| // Copy to dst. No Blur. |
| SkASSERT(false); // should not get here |
| for (size_t y = 0; y < srcH; y++) { |
| std::memcpy(&dst->fImage[y * dst->fRowBytes], &src.fImage[y * src.fRowBytes], dstW); |
| } |
| } |
| |
| return {SkTo<int32_t>(borderW), SkTo<int32_t>(borderH)}; |
| } |