diff options
Diffstat (limited to 'toolkit/Blur.cpp')
-rw-r--r-- | toolkit/Blur.cpp | 545 |
1 files changed, 545 insertions, 0 deletions
diff --git a/toolkit/Blur.cpp b/toolkit/Blur.cpp new file mode 100644 index 00000000..a95ff435 --- /dev/null +++ b/toolkit/Blur.cpp @@ -0,0 +1,545 @@ +/* + * Copyright (C) 2012 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <math.h> + +#include <cstdint> + +#include "RenderScriptToolkit.h" +#include "TaskProcessor.h" +#include "Utils.h" + +namespace android { +namespace renderscript { + +#define LOG_TAG "renderscript.toolkit.Blur" + +/** + * Blurs an image or a section of an image. + * + * Our algorithm does two passes: a vertical blur followed by an horizontal blur. + */ +class BlurTask : public Task { + // The image we're blurring. + const uchar* mIn; + // Where we store the blurred image. + uchar* outArray; + // The size of the kernel radius is limited to 25 in ScriptIntrinsicBlur.java. + // So, the max kernel size is 51 (= 2 * 25 + 1). + // Considering SSSE3 case, which requires the size is multiple of 4, + // at least 52 words are necessary. Values outside of the kernel should be 0. + float mFp[104]; + uint16_t mIp[104]; + + // Working area to store the result of the vertical blur, to be used by the horizontal pass. + // There's one area per thread. Since the needed working area may be too large to put on the + // stack, we are allocating it from the heap. To avoid paying the allocation cost for each + // tile, we cache the scratch area here. + std::vector<void*> mScratch; // Pointers to the scratch areas, one per thread. + std::vector<size_t> mScratchSize; // The size in bytes of the scratch areas, one per thread. + + // The radius of the blur, in floating point and integer format. + float mRadius; + int mIradius; + + void kernelU4(void* outPtr, uint32_t xstart, uint32_t xend, uint32_t currentY, + uint32_t threadIndex); + void kernelU1(void* outPtr, uint32_t xstart, uint32_t xend, uint32_t currentY); + void ComputeGaussianWeights(); + + // Process a 2D tile of the overall work. threadIndex identifies which thread does the work. + virtual void processData(int threadIndex, size_t startX, size_t startY, size_t endX, + size_t endY) override; + + public: + BlurTask(const uint8_t* in, uint8_t* out, size_t sizeX, size_t sizeY, size_t vectorSize, + uint32_t threadCount, float radius, const Restriction* restriction) + : Task{sizeX, sizeY, vectorSize, false, restriction}, + mIn{in}, + outArray{out}, + mScratch{threadCount}, + mScratchSize{threadCount}, + mRadius{std::min(25.0f, radius)} { + ComputeGaussianWeights(); + } + + ~BlurTask() { + for (size_t i = 0; i < mScratch.size(); i++) { + if (mScratch[i]) { + free(mScratch[i]); + } + } + } +}; + +void BlurTask::ComputeGaussianWeights() { + memset(mFp, 0, sizeof(mFp)); + memset(mIp, 0, sizeof(mIp)); + + // Compute gaussian weights for the blur + // e is the euler's number + float e = 2.718281828459045f; + float pi = 3.1415926535897932f; + // g(x) = (1 / (sqrt(2 * pi) * sigma)) * e ^ (-x^2 / (2 * sigma^2)) + // x is of the form [-radius .. 0 .. radius] + // and sigma varies with the radius. + // Based on some experimental radius values and sigmas, + // we approximately fit sigma = f(radius) as + // sigma = radius * 0.4 + 0.6 + // The larger the radius gets, the more our gaussian blur + // will resemble a box blur since with large sigma + // the gaussian curve begins to lose its shape + float sigma = 0.4f * mRadius + 0.6f; + + // Now compute the coefficients. We will store some redundant values to save + // some math during the blur calculations precompute some values + float coeff1 = 1.0f / (sqrtf(2.0f * pi) * sigma); + float coeff2 = - 1.0f / (2.0f * sigma * sigma); + + float normalizeFactor = 0.0f; + float floatR = 0.0f; + int r; + mIradius = (float)ceil(mRadius) + 0.5f; + for (r = -mIradius; r <= mIradius; r ++) { + floatR = (float)r; + mFp[r + mIradius] = coeff1 * powf(e, floatR * floatR * coeff2); + normalizeFactor += mFp[r + mIradius]; + } + + // Now we need to normalize the weights because all our coefficients need to add up to one + normalizeFactor = 1.0f / normalizeFactor; + for (r = -mIradius; r <= mIradius; r ++) { + mFp[r + mIradius] *= normalizeFactor; + mIp[r + mIradius] = (uint16_t)(mFp[r + mIradius] * 65536.0f + 0.5f); + } +} + +/** + * Vertical blur of a uchar4 line. + * + * @param sizeY Number of cells of the input array in the vertical direction. + * @param out Where to place the computed value. + * @param x Coordinate of the point we're blurring. + * @param y Coordinate of the point we're blurring. + * @param ptrIn Start of the input array. + * @param iStride The size in byte of a row of the input array. + * @param gPtr The gaussian coefficients. + * @param iradius The radius of the blur. + */ +static void OneVU4(uint32_t sizeY, float4* out, int32_t x, int32_t y, const uchar* ptrIn, + int iStride, const float* gPtr, int iradius) { + const uchar *pi = ptrIn + x*4; + + float4 blurredPixel = 0; + for (int r = -iradius; r <= iradius; r ++) { + int validY = std::max((y + r), 0); + validY = std::min(validY, (int)(sizeY - 1)); + const uchar4 *pvy = (const uchar4 *)&pi[validY * iStride]; + float4 pf = convert<float4>(pvy[0]); + blurredPixel += pf * gPtr[0]; + gPtr++; + } + + out[0] = blurredPixel; +} + +/** + * Vertical blur of a uchar1 line. + * + * @param sizeY Number of cells of the input array in the vertical direction. + * @param out Where to place the computed value. + * @param x Coordinate of the point we're blurring. + * @param y Coordinate of the point we're blurring. + * @param ptrIn Start of the input array. + * @param iStride The size in byte of a row of the input array. + * @param gPtr The gaussian coefficients. + * @param iradius The radius of the blur. + */ +static void OneVU1(uint32_t sizeY, float *out, int32_t x, int32_t y, + const uchar *ptrIn, int iStride, const float* gPtr, int iradius) { + + const uchar *pi = ptrIn + x; + + float blurredPixel = 0; + for (int r = -iradius; r <= iradius; r ++) { + int validY = std::max((y + r), 0); + validY = std::min(validY, (int)(sizeY - 1)); + float pf = (float)pi[validY * iStride]; + blurredPixel += pf * gPtr[0]; + gPtr++; + } + + out[0] = blurredPixel; +} + + +extern "C" void rsdIntrinsicBlurU1_K(uchar *out, uchar const *in, size_t w, size_t h, + size_t p, size_t x, size_t y, size_t count, size_t r, uint16_t const *tab); +extern "C" void rsdIntrinsicBlurU4_K(uchar4 *out, uchar4 const *in, size_t w, size_t h, + size_t p, size_t x, size_t y, size_t count, size_t r, uint16_t const *tab); + +#if defined(ARCH_X86_HAVE_SSSE3) +extern void rsdIntrinsicBlurVFU4_K(void *dst, const void *pin, int stride, const void *gptr, + int rct, int x1, int ct); +extern void rsdIntrinsicBlurHFU4_K(void *dst, const void *pin, const void *gptr, int rct, int x1, + int ct); +extern void rsdIntrinsicBlurHFU1_K(void *dst, const void *pin, const void *gptr, int rct, int x1, + int ct); +#endif + +/** + * Vertical blur of a line of RGBA, knowing that there's enough rows above and below us to avoid + * dealing with boundary conditions. + * + * @param out Where to store the results. This is the input to the horizontal blur. + * @param ptrIn The input data for this line. + * @param iStride The width of the input. + * @param gPtr The gaussian coefficients. + * @param ct The diameter of the blur. + * @param len How many cells to blur. + * @param usesSimd Whether this processor supports SIMD. + */ +static void OneVFU4(float4 *out, const uchar *ptrIn, int iStride, const float* gPtr, int ct, + int x2, bool usesSimd) { + int x1 = 0; +#if defined(ARCH_X86_HAVE_SSSE3) + if (usesSimd) { + int t = (x2 - x1); + t &= ~1; + if (t) { + rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, x1, x1 + t); + } + x1 += t; + out += t; + ptrIn += t << 2; + } +#else + (void) usesSimd; // Avoid unused parameter warning. +#endif + while(x2 > x1) { + const uchar *pi = ptrIn; + float4 blurredPixel = 0; + const float* gp = gPtr; + + for (int r = 0; r < ct; r++) { + float4 pf = convert<float4>(((const uchar4 *)pi)[0]); + blurredPixel += pf * gp[0]; + pi += iStride; + gp++; + } + out->xyzw = blurredPixel; + x1++; + out++; + ptrIn+=4; + } +} + +/** + * Vertical blur of a line of U_8, knowing that there's enough rows above and below us to avoid + * dealing with boundary conditions. + * + * @param out Where to store the results. This is the input to the horizontal blur. + * @param ptrIn The input data for this line. + * @param iStride The width of the input. + * @param gPtr The gaussian coefficients. + * @param ct The diameter of the blur. + * @param len How many cells to blur. + * @param usesSimd Whether this processor supports SIMD. + */ +static void OneVFU1(float* out, const uchar* ptrIn, int iStride, const float* gPtr, int ct, int len, + bool usesSimd) { + int x1 = 0; + + while((len > x1) && (((uintptr_t)ptrIn) & 0x3)) { + const uchar *pi = ptrIn; + float blurredPixel = 0; + const float* gp = gPtr; + + for (int r = 0; r < ct; r++) { + float pf = (float)pi[0]; + blurredPixel += pf * gp[0]; + pi += iStride; + gp++; + } + out[0] = blurredPixel; + x1++; + out++; + ptrIn++; + len--; + } +#if defined(ARCH_X86_HAVE_SSSE3) + if (usesSimd && (len > x1)) { + int t = (len - x1) >> 2; + t &= ~1; + if (t) { + rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, 0, t ); + len -= t << 2; + ptrIn += t << 2; + out += t << 2; + } + } +#else + (void) usesSimd; // Avoid unused parameter warning. +#endif + while(len > 0) { + const uchar *pi = ptrIn; + float blurredPixel = 0; + const float* gp = gPtr; + + for (int r = 0; r < ct; r++) { + float pf = (float)pi[0]; + blurredPixel += pf * gp[0]; + pi += iStride; + gp++; + } + out[0] = blurredPixel; + len--; + out++; + ptrIn++; + } +} + +/** + * Horizontal blur of a uchar4 line. + * + * @param sizeX Number of cells of the input array in the horizontal direction. + * @param out Where to place the computed value. + * @param x Coordinate of the point we're blurring. + * @param ptrIn The start of the input row from which we're indexing x. + * @param gPtr The gaussian coefficients. + * @param iradius The radius of the blur. + */ +static void OneHU4(uint32_t sizeX, uchar4* out, int32_t x, const float4* ptrIn, const float* gPtr, + int iradius) { + float4 blurredPixel = 0; + for (int r = -iradius; r <= iradius; r ++) { + int validX = std::max((x + r), 0); + validX = std::min(validX, (int)(sizeX - 1)); + float4 pf = ptrIn[validX]; + blurredPixel += pf * gPtr[0]; + gPtr++; + } + + out->xyzw = convert<uchar4>(blurredPixel); +} + +/** + * Horizontal blur of a uchar line. + * + * @param sizeX Number of cells of the input array in the horizontal direction. + * @param out Where to place the computed value. + * @param x Coordinate of the point we're blurring. + * @param ptrIn The start of the input row from which we're indexing x. + * @param gPtr The gaussian coefficients. + * @param iradius The radius of the blur. + */ +static void OneHU1(uint32_t sizeX, uchar* out, int32_t x, const float* ptrIn, const float* gPtr, + int iradius) { + float blurredPixel = 0; + for (int r = -iradius; r <= iradius; r ++) { + int validX = std::max((x + r), 0); + validX = std::min(validX, (int)(sizeX - 1)); + float pf = ptrIn[validX]; + blurredPixel += pf * gPtr[0]; + gPtr++; + } + + out[0] = (uchar)blurredPixel; +} + +/** + * Full blur of a line of RGBA data. + * + * @param outPtr Where to store the results + * @param xstart The index of the section we're starting to blur. + * @param xend The end index of the section. + * @param currentY The index of the line we're blurring. + * @param usesSimd Whether this processor supports SIMD. + */ +void BlurTask::kernelU4(void *outPtr, uint32_t xstart, uint32_t xend, uint32_t currentY, + uint32_t threadIndex) { + float4 stackbuf[2048]; + float4 *buf = &stackbuf[0]; + const uint32_t stride = mSizeX * mVectorSize; + + uchar4 *out = (uchar4 *)outPtr; + uint32_t x1 = xstart; + uint32_t x2 = xend; + +#if defined(ARCH_ARM_USE_INTRINSICS) + if (mUsesSimd && mSizeX >= 4) { + rsdIntrinsicBlurU4_K(out, (uchar4 const *)(mIn + stride * currentY), + mSizeX, mSizeY, + stride, x1, currentY, x2 - x1, mIradius, mIp + mIradius); + return; + } +#endif + + if (mSizeX > 2048) { + if ((mSizeX > mScratchSize[threadIndex]) || !mScratch[threadIndex]) { + // Pad the side of the allocation by one unit to allow alignment later + mScratch[threadIndex] = realloc(mScratch[threadIndex], (mSizeX + 1) * 16); + mScratchSize[threadIndex] = mSizeX; + } + // realloc only aligns to 8 bytes so we manually align to 16. + buf = (float4 *) ((((intptr_t)mScratch[threadIndex]) + 15) & ~0xf); + } + float4 *fout = (float4 *)buf; + int y = currentY; + if ((y > mIradius) && (y < ((int)mSizeY - mIradius))) { + const uchar *pi = mIn + (y - mIradius) * stride; + OneVFU4(fout, pi, stride, mFp, mIradius * 2 + 1, mSizeX, mUsesSimd); + } else { + x1 = 0; + while(mSizeX > x1) { + OneVU4(mSizeY, fout, x1, y, mIn, stride, mFp, mIradius); + fout++; + x1++; + } + } + + x1 = xstart; + while ((x1 < (uint32_t)mIradius) && (x1 < x2)) { + OneHU4(mSizeX, out, x1, buf, mFp, mIradius); + out++; + x1++; + } +#if defined(ARCH_X86_HAVE_SSSE3) + if (mUsesSimd) { + if ((x1 + mIradius) < x2) { + rsdIntrinsicBlurHFU4_K(out, buf - mIradius, mFp, + mIradius * 2 + 1, x1, x2 - mIradius); + out += (x2 - mIradius) - x1; + x1 = x2 - mIradius; + } + } +#endif + while(x2 > x1) { + OneHU4(mSizeX, out, x1, buf, mFp, mIradius); + out++; + x1++; + } +} + +/** + * Full blur of a line of U_8 data. + * + * @param outPtr Where to store the results + * @param xstart The index of the section we're starting to blur. + * @param xend The end index of the section. + * @param currentY The index of the line we're blurring. + */ +void BlurTask::kernelU1(void *outPtr, uint32_t xstart, uint32_t xend, uint32_t currentY) { + float buf[4 * 2048]; + const uint32_t stride = mSizeX * mVectorSize; + + uchar *out = (uchar *)outPtr; + uint32_t x1 = xstart; + uint32_t x2 = xend; + +#if defined(ARCH_ARM_USE_INTRINSICS) + if (mUsesSimd && mSizeX >= 16) { + // The specialisation for r<=8 has an awkward prefill case, which is + // fiddly to resolve, where starting close to the right edge can cause + // a read beyond the end of input. So avoid that case here. + if (mIradius > 8 || (mSizeX - std::max(0, (int32_t)x1 - 8)) >= 16) { + rsdIntrinsicBlurU1_K(out, mIn + stride * currentY, mSizeX, mSizeY, + stride, x1, currentY, x2 - x1, mIradius, mIp + mIradius); + return; + } + } +#endif + + float *fout = (float *)buf; + int y = currentY; + if ((y > mIradius) && (y < ((int)mSizeY - mIradius -1))) { + const uchar *pi = mIn + (y - mIradius) * stride; + OneVFU1(fout, pi, stride, mFp, mIradius * 2 + 1, mSizeX, mUsesSimd); + } else { + x1 = 0; + while(mSizeX > x1) { + OneVU1(mSizeY, fout, x1, y, mIn, stride, mFp, mIradius); + fout++; + x1++; + } + } + + x1 = xstart; + while ((x1 < x2) && + ((x1 < (uint32_t)mIradius) || (((uintptr_t)out) & 0x3))) { + OneHU1(mSizeX, out, x1, buf, mFp, mIradius); + out++; + x1++; + } +#if defined(ARCH_X86_HAVE_SSSE3) + if (mUsesSimd) { + if ((x1 + mIradius) < x2) { + uint32_t len = x2 - (x1 + mIradius); + len &= ~3; + + // rsdIntrinsicBlurHFU1_K() processes each four float values in |buf| at once, so it + // nees to ensure four more values can be accessed in order to avoid accessing + // uninitialized buffer. + if (len > 4) { + len -= 4; + rsdIntrinsicBlurHFU1_K(out, ((float *)buf) - mIradius, mFp, + mIradius * 2 + 1, x1, x1 + len); + out += len; + x1 += len; + } + } + } +#endif + while(x2 > x1) { + OneHU1(mSizeX, out, x1, buf, mFp, mIradius); + out++; + x1++; + } +} + +void BlurTask::processData(int threadIndex, size_t startX, size_t startY, size_t endX, + size_t endY) { + for (size_t y = startY; y < endY; y++) { + void* outPtr = outArray + (mSizeX * y + startX) * mVectorSize; + if (mVectorSize == 4) { + kernelU4(outPtr, startX, endX, y, threadIndex); + } else { + kernelU1(outPtr, startX, endX, y); + } + } +} + +void RenderScriptToolkit::blur(const uint8_t* in, uint8_t* out, size_t sizeX, size_t sizeY, + size_t vectorSize, int radius, const Restriction* restriction) { +#ifdef ANDROID_RENDERSCRIPT_TOOLKIT_VALIDATE + if (!validRestriction(LOG_TAG, sizeX, sizeY, restriction)) { + return; + } + if (radius <= 0 || radius > 25) { + ALOGE("The radius should be between 1 and 25. %d provided.", radius); + } + if (vectorSize != 1 && vectorSize != 4) { + ALOGE("The vectorSize should be 1 or 4. %zu provided.", vectorSize); + } +#endif + + BlurTask task(in, out, sizeX, sizeY, vectorSize, processor->getNumberOfThreads(), radius, + restriction); + processor->doTask(&task); +} + +} // namespace renderscript +} // namespace android |