rsCpuIntrinsicBlur.cpp revision 7079cd8ddb0874d431446aea305b8c3b10e4f0ba 
1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "rsCpuIntrinsic.h"
18#include "rsCpuIntrinsicInlines.h"
19
20using namespace android;
21using namespace android::renderscript;
22
23namespace android {
24namespace renderscript {
25
26
27class RsdCpuScriptIntrinsicBlur : public RsdCpuScriptIntrinsic {
28public:
29    virtual void populateScript(Script *);
30    virtual void invokeFreeChildren();
31
32    virtual void setGlobalVar(uint32_t slot, const void *data, size_t dataLength);
33    virtual void setGlobalObj(uint32_t slot, ObjectBase *data);
34
35    virtual ~RsdCpuScriptIntrinsicBlur();
36    RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx, const Script *s, const Element *e);
37
38protected:
39    float fp[104];
40    short ip[104];
41    float radius;
42    int iradius;
43    ObjectBaseRef<Allocation> alloc;
44
45    static void kernelU4(const RsForEachStubParamStruct *p,
46                         uint32_t xstart, uint32_t xend,
47                         uint32_t instep, uint32_t outstep);
48    static void kernelU1(const RsForEachStubParamStruct *p,
49                         uint32_t xstart, uint32_t xend,
50                         uint32_t instep, uint32_t outstep);
51    void ComputeGaussianWeights();
52};
53
54}
55}
56
57
58void RsdCpuScriptIntrinsicBlur::ComputeGaussianWeights() {
59    memset(fp, 0, sizeof(fp));
60    memset(ip, 0, sizeof(ip));
61
62    // Compute gaussian weights for the blur
63    // e is the euler's number
64    float e = 2.718281828459045f;
65    float pi = 3.1415926535897932f;
66    // g(x) = ( 1 / sqrt( 2 * pi ) * sigma) * e ^ ( -x^2 / 2 * sigma^2 )
67    // x is of the form [-radius .. 0 .. radius]
68    // and sigma varies with radius.
69    // Based on some experimental radius values and sigma's
70    // we approximately fit sigma = f(radius) as
71    // sigma = radius * 0.4  + 0.6
72    // The larger the radius gets, the more our gaussian blur
73    // will resemble a box blur since with large sigma
74    // the gaussian curve begins to lose its shape
75    float sigma = 0.4f * radius + 0.6f;
76
77    // Now compute the coefficients. We will store some redundant values to save
78    // some math during the blur calculations precompute some values
79    float coeff1 = 1.0f / (sqrtf(2.0f * pi) * sigma);
80    float coeff2 = - 1.0f / (2.0f * sigma * sigma);
81
82    float normalizeFactor = 0.0f;
83    float floatR = 0.0f;
84    int r;
85    iradius = (float)ceil(radius) + 0.5f;
86    for (r = -iradius; r <= iradius; r ++) {
87        floatR = (float)r;
88        fp[r + iradius] = coeff1 * powf(e, floatR * floatR * coeff2);
89        normalizeFactor += fp[r + iradius];
90    }
91
92    //Now we need to normalize the weights because all our coefficients need to add up to one
93    normalizeFactor = 1.0f / normalizeFactor;
94    for (r = -iradius; r <= iradius; r ++) {
95        fp[r + iradius] *= normalizeFactor;
96        ip[r + iradius] = (short)(ip[r + iradius] * 32768);
97    }
98}
99
100void RsdCpuScriptIntrinsicBlur::setGlobalObj(uint32_t slot, ObjectBase *data) {
101    rsAssert(slot == 1);
102    alloc.set(static_cast<Allocation *>(data));
103}
104
105void RsdCpuScriptIntrinsicBlur::setGlobalVar(uint32_t slot, const void *data, size_t dataLength) {
106    rsAssert(slot == 0);
107    radius = ((const float *)data)[0];
108    ComputeGaussianWeights();
109}
110
111
112
113static void OneVU4(const RsForEachStubParamStruct *p, float4 *out, int32_t x, int32_t y,
114                   const uchar *ptrIn, int iStride, const float* gPtr, int iradius) {
115
116    const uchar *pi = ptrIn + x*4;
117
118    float4 blurredPixel = 0;
119    for (int r = -iradius; r <= iradius; r ++) {
120        int validY = rsMax((y + r), 0);
121        validY = rsMin(validY, (int)(p->dimY - 1));
122        const uchar4 *pvy = (const uchar4 *)&pi[validY * iStride];
123        float4 pf = convert_float4(pvy[0]);
124        blurredPixel += pf * gPtr[0];
125        gPtr++;
126    }
127
128    out->xyzw = blurredPixel;
129}
130
131static void OneVU1(const RsForEachStubParamStruct *p, float *out, int32_t x, int32_t y,
132                   const uchar *ptrIn, int iStride, const float* gPtr, int iradius) {
133
134    const uchar *pi = ptrIn + x;
135
136    float blurredPixel = 0;
137    for (int r = -iradius; r <= iradius; r ++) {
138        int validY = rsMax((y + r), 0);
139        validY = rsMin(validY, (int)(p->dimY - 1));
140        float pf = (float)pi[validY * iStride];
141        blurredPixel += pf * gPtr[0];
142        gPtr++;
143    }
144
145    out[0] = blurredPixel;
146}
147
148extern "C" void rsdIntrinsicBlurVFU4_K(void *dst, const void *pin, int stride, const void *gptr, int rct, int x1, int ct);
149extern "C" void rsdIntrinsicBlurHFU4_K(void *dst, const void *pin, const void *gptr, int rct, int x1, int ct);
150extern "C" void rsdIntrinsicBlurHFU1_K(void *dst, const void *pin, const void *gptr, int rct, int x1, int ct);
151
152static void OneVFU4(float4 *out,
153                    const uchar *ptrIn, int iStride, const float* gPtr, int ct,
154                    int x1, int x2) {
155
156#if defined(ARCH_ARM_HAVE_NEON)
157    {
158        int t = (x2 - x1);
159        t &= ~1;
160        if(t) {
161            rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, x1, x1 + t);
162        }
163        x1 += t;
164    }
165#endif
166
167    while(x2 > x1) {
168        const uchar *pi = ptrIn;
169        float4 blurredPixel = 0;
170        const float* gp = gPtr;
171
172        for (int r = 0; r < ct; r++) {
173            float4 pf = convert_float4(((const uchar4 *)pi)[0]);
174            blurredPixel += pf * gp[0];
175            pi += iStride;
176            gp++;
177        }
178        out->xyzw = blurredPixel;
179        x1++;
180        out++;
181        ptrIn++;
182    }
183}
184
185static void OneVFU1(float *out,
186                    const uchar *ptrIn, int iStride, const float* gPtr, int ct, int len) {
187
188    while(len && (((int)ptrIn) & 0x3)) {
189        const uchar *pi = ptrIn;
190        float blurredPixel = 0;
191        const float* gp = gPtr;
192
193        for (int r = 0; r < ct; r++) {
194            float pf = (float)pi[0];
195            blurredPixel += pf * gp[0];
196            pi += iStride;
197            gp++;
198        }
199        out[0] = blurredPixel;
200        len--;
201        out++;
202        ptrIn++;
203    }
204
205#if defined(ARCH_ARM_HAVE_NEON)
206    {
207        int t = len >> 2;
208        t &= ~1;
209        if(t) {
210            rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, 0, t << 2);
211            len -= t << 2;
212            ptrIn += t << 2;
213            out += t << 2;
214        }
215    }
216#endif
217
218    while(len) {
219        const uchar *pi = ptrIn;
220        float blurredPixel = 0;
221        const float* gp = gPtr;
222
223        for (int r = 0; r < ct; r++) {
224            float pf = (float)pi[0];
225            blurredPixel += pf * gp[0];
226            pi += iStride;
227            gp++;
228        }
229        out[0] = blurredPixel;
230        len--;
231        out++;
232        ptrIn++;
233    }
234}
235
236static void OneHU4(const RsForEachStubParamStruct *p, uchar4 *out, int32_t x,
237                   const float4 *ptrIn, const float* gPtr, int iradius) {
238
239    float4 blurredPixel = 0;
240    for (int r = -iradius; r <= iradius; r ++) {
241        int validX = rsMax((x + r), 0);
242        validX = rsMin(validX, (int)(p->dimX - 1));
243        float4 pf = ptrIn[validX];
244        blurredPixel += pf * gPtr[0];
245        gPtr++;
246    }
247
248    out->xyzw = convert_uchar4(blurredPixel);
249}
250
251static void OneHU1(const RsForEachStubParamStruct *p, uchar *out, int32_t x,
252                   const float *ptrIn, const float* gPtr, int iradius) {
253
254    float blurredPixel = 0;
255    for (int r = -iradius; r <= iradius; r ++) {
256        int validX = rsMax((x + r), 0);
257        validX = rsMin(validX, (int)(p->dimX - 1));
258        float pf = ptrIn[validX];
259        blurredPixel += pf * gPtr[0];
260        gPtr++;
261    }
262
263    out[0] = (uchar)blurredPixel;
264}
265
266
267void RsdCpuScriptIntrinsicBlur::kernelU4(const RsForEachStubParamStruct *p,
268                                         uint32_t xstart, uint32_t xend,
269                                         uint32_t instep, uint32_t outstep) {
270    // fixme
271    float buf[4 * 2048];
272    RsdCpuScriptIntrinsicBlur *cp = (RsdCpuScriptIntrinsicBlur *)p->usr;
273    if (!cp->alloc.get()) {
274        ALOGE("Blur executed without input, skipping");
275        return;
276    }
277    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
278    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
279
280    uchar4 *out = (uchar4 *)p->out;
281    uint32_t x1 = xstart;
282    uint32_t x2 = xend;
283
284    float4 *fout = (float4 *)buf;
285    int y = p->y;
286    if ((y > cp->iradius) && (y < ((int)p->dimY - cp->iradius))) {
287        const uchar *pi = pin + (y - cp->iradius) * stride;
288        OneVFU4(fout, pi, stride, cp->fp, cp->iradius * 2 + 1, x1, x2);
289    } else {
290        while(x2 > x1) {
291            OneVU4(p, fout, x1, y, pin, stride, cp->fp, cp->iradius);
292            fout++;
293            x1++;
294        }
295    }
296
297    x1 = xstart;
298    while ((x1 < (uint32_t)cp->iradius) && (x1 < x2)) {
299        OneHU4(p, out, x1, (float4 *)buf, cp->fp, cp->iradius);
300        out++;
301        x1++;
302    }
303#if defined(ARCH_ARM_HAVE_NEON)
304    if ((x1 + cp->iradius) < x2) {
305        rsdIntrinsicBlurHFU4_K(out, ((float4 *)buf) - cp->iradius, cp->fp,
306                               cp->iradius * 2 + 1, x1, x2 - cp->iradius);
307        out += (x2 - cp->iradius) - x1;
308        x1 = x2 - cp->iradius;
309    }
310#endif
311    while(x2 > x1) {
312        OneHU4(p, out, x1, (float4 *)buf, cp->fp, cp->iradius);
313        out++;
314        x1++;
315    }
316}
317
318void RsdCpuScriptIntrinsicBlur::kernelU1(const RsForEachStubParamStruct *p,
319                                         uint32_t xstart, uint32_t xend,
320                                         uint32_t instep, uint32_t outstep) {
321    float buf[4 * 2048];
322    RsdCpuScriptIntrinsicBlur *cp = (RsdCpuScriptIntrinsicBlur *)p->usr;
323    if (!cp->alloc.get()) {
324        ALOGE("Blur executed without input, skipping");
325        return;
326    }
327    const uchar *pin = (const uchar *)cp->alloc->mHal.drvState.lod[0].mallocPtr;
328    const size_t stride = cp->alloc->mHal.drvState.lod[0].stride;
329
330    uchar *out = (uchar *)p->out;
331    uint32_t x1 = xstart;
332    uint32_t x2 = xend;
333
334    float *fout = (float *)buf;
335    int y = p->y;
336    if ((y > cp->iradius) && (y < ((int)p->dimY - cp->iradius))) {
337        const uchar *pi = pin + (y - cp->iradius) * stride;
338        OneVFU1(fout, pi, stride, cp->fp, cp->iradius * 2 + 1, x2-x1);
339    } else {
340        while(x2 > x1) {
341            OneVU1(p, fout, x1, y, pin, stride, cp->fp, cp->iradius);
342            fout++;
343            x1++;
344        }
345    }
346
347    x1 = xstart;
348    while ((x1 < x2) &&
349           ((x1 < (uint32_t)cp->iradius) || (((int)out) & 0x3))) {
350        OneHU1(p, out, x1, buf, cp->fp, cp->iradius);
351        out++;
352        x1++;
353    }
354#if defined(ARCH_ARM_HAVE_NEON)
355    if ((x1 + cp->iradius) < x2) {
356        uint32_t len = x2 - (x1 + cp->iradius);
357        len >>= 2;
358        rsdIntrinsicBlurHFU1_K(out, ((float4 *)buf) - cp->iradius, cp->fp,
359                               cp->iradius * 2 + 1, x1, x1+len);
360        out += len << 2;
361        x1 += len << 2;
362    }
363#endif
364    while(x2 > x1) {
365        OneHU1(p, out, x1, buf, cp->fp, cp->iradius);
366        out++;
367        x1++;
368    }
369}
370
371RsdCpuScriptIntrinsicBlur::RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx,
372                                                     const Script *s, const Element *e)
373            : RsdCpuScriptIntrinsic(ctx, s, e, RS_SCRIPT_INTRINSIC_ID_BLUR) {
374
375    mRootPtr = NULL;
376    if (e->getType() == RS_TYPE_UNSIGNED_8) {
377        switch (e->getVectorSize()) {
378        case 1:
379            mRootPtr = &kernelU1;
380            break;
381        case 4:
382            mRootPtr = &kernelU4;
383            break;
384        }
385    }
386    rsAssert(mRootPtr);
387    radius = 5;
388    ComputeGaussianWeights();
389}
390
391RsdCpuScriptIntrinsicBlur::~RsdCpuScriptIntrinsicBlur() {
392}
393
394void RsdCpuScriptIntrinsicBlur::populateScript(Script *s) {
395    s->mHal.info.exportedVariableCount = 2;
396}
397
398void RsdCpuScriptIntrinsicBlur::invokeFreeChildren() {
399    alloc.clear();
400}
401
402
403RsdCpuScriptImpl * rsdIntrinsic_Blur(RsdCpuReferenceImpl *ctx, const Script *s, const Element *e) {
404
405    return new RsdCpuScriptIntrinsicBlur(ctx, s, e);
406}
407
408
409