546 lines
18 KiB
C++
546 lines
18 KiB
C++
/*
|
|
* 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
|