rsCpuIntrinsicBlur.cpp revision f6009df2e4daf9be15b41ac5b4b5d25ba956b0e2 
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    void populateScript(Script *) override;
30    void invokeFreeChildren() override;
31
32    void setGlobalVar(uint32_t slot, const void *data, size_t dataLength) override;
33    void setGlobalObj(uint32_t slot, ObjectBase *data) override;
34
35    ~RsdCpuScriptIntrinsicBlur() override;
36    RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx, const Script *s, const Element *e);
37
38protected:
39    // The size of the kernel radius is limited to 25 in ScriptIntrinsicBlur.java.
40    // So, the max kernel size is 51 (= 2 * 25 + 1).
41    // Considering SSSE3 case, which requires the size is multiple of 4,
42    // at least 52 words are necessary. Values outside of the kernel should be 0.
43    float mFp[104];
44    uint16_t mIp[104];
45    void **mScratch;
46    size_t *mScratchSize;
47    float mRadius;
48    int mIradius;
49    ObjectBaseRef<Allocation> mAlloc;
50
51    static void kernelU4(const RsExpandKernelDriverInfo *info,
52                         uint32_t xstart, uint32_t xend,
53                         uint32_t outstep);
54    static void kernelU1(const RsExpandKernelDriverInfo *info,
55                         uint32_t xstart, uint32_t xend,
56                         uint32_t outstep);
57    void ComputeGaussianWeights();
58};
59
60}
61}
62
63
64void RsdCpuScriptIntrinsicBlur::ComputeGaussianWeights() {
65    memset(mFp, 0, sizeof(mFp));
66    memset(mIp, 0, sizeof(mIp));
67
68    // Compute gaussian weights for the blur
69    // e is the euler's number
70    // TODO Define these constants only once
71    float e = 2.718281828459045f;
72    float pi = 3.1415926535897932f;
73    // g(x) = (1 / (sqrt(2 * pi) * sigma)) * e ^ (-x^2 / (2 * sigma^2))
74    // x is of the form [-radius .. 0 .. radius]
75    // and sigma varies with the radius.
76    // Based on some experimental radius values and sigmas,
77    // we approximately fit sigma = f(radius) as
78    // sigma = radius * 0.4  + 0.6
79    // The larger the radius gets, the more our gaussian blur
80    // will resemble a box blur since with large sigma
81    // the gaussian curve begins to lose its shape
82    float sigma = 0.4f * mRadius + 0.6f;
83
84    // Now compute the coefficients. We will store some redundant values to save
85    // some math during the blur calculations precompute some values
86    float coeff1 = 1.0f / (sqrtf(2.0f * pi) * sigma);
87    float coeff2 = - 1.0f / (2.0f * sigma * sigma);
88
89    float normalizeFactor = 0.0f;
90    float floatR = 0.0f;
91    int r;
92    mIradius = (float)ceil(mRadius) + 0.5f;
93    for (r = -mIradius; r <= mIradius; r ++) {
94        floatR = (float)r;
95        mFp[r + mIradius] = coeff1 * powf(e, floatR * floatR * coeff2);
96        normalizeFactor += mFp[r + mIradius];
97    }
98
99    // Now we need to normalize the weights because all our coefficients need to add up to one
100    normalizeFactor = 1.0f / normalizeFactor;
101    for (r = -mIradius; r <= mIradius; r ++) {
102        mFp[r + mIradius] *= normalizeFactor;
103        mIp[r + mIradius] = (uint16_t)(mFp[r + mIradius] * 65536.0f + 0.5f);
104    }
105}
106
107void RsdCpuScriptIntrinsicBlur::setGlobalObj(uint32_t slot, ObjectBase *data) {
108    rsAssert(slot == 1);
109    mAlloc.set(static_cast<Allocation *>(data));
110}
111
112void RsdCpuScriptIntrinsicBlur::setGlobalVar(uint32_t slot, const void *data, size_t dataLength) {
113    rsAssert(slot == 0);
114    mRadius = ((const float *)data)[0];
115    ComputeGaussianWeights();
116}
117
118
119
120static void OneVU4(const RsExpandKernelDriverInfo *info, float4 *out, int32_t x, int32_t y,
121                   const uchar *ptrIn, int iStride, const float* gPtr, int iradius) {
122
123    const uchar *pi = ptrIn + x*4;
124
125    float4 blurredPixel = 0;
126    for (int r = -iradius; r <= iradius; r ++) {
127        int validY = rsMax((y + r), 0);
128        validY = rsMin(validY, (int)(info->dim.y- 1));
129        const uchar4 *pvy = (const uchar4 *)&pi[validY * iStride];
130        float4 pf = convert_float4(pvy[0]);
131        blurredPixel += pf * gPtr[0];
132        gPtr++;
133    }
134
135    out[0] = blurredPixel;
136}
137
138static void OneVU1(const RsExpandKernelDriverInfo *info, float *out, int32_t x, int32_t y,
139                   const uchar *ptrIn, int iStride, const float* gPtr, int iradius) {
140
141    const uchar *pi = ptrIn + x;
142
143    float blurredPixel = 0;
144    for (int r = -iradius; r <= iradius; r ++) {
145        int validY = rsMax((y + r), 0);
146        validY = rsMin(validY, (int)(info->dim.y - 1));
147        float pf = (float)pi[validY * iStride];
148        blurredPixel += pf * gPtr[0];
149        gPtr++;
150    }
151
152    out[0] = blurredPixel;
153}
154
155
156extern "C" void rsdIntrinsicBlurU1_K(uchar *out, uchar const *in, size_t w, size_t h,
157                 size_t p, size_t x, size_t y, size_t count, size_t r, uint16_t const *tab);
158extern "C" void rsdIntrinsicBlurU4_K(uchar4 *out, uchar4 const *in, size_t w, size_t h,
159                 size_t p, size_t x, size_t y, size_t count, size_t r, uint16_t const *tab);
160
161#if defined(ARCH_X86_HAVE_SSSE3)
162extern void rsdIntrinsicBlurVFU4_K(void *dst, const void *pin, int stride, const void *gptr, int rct, int x1, int ct);
163extern void rsdIntrinsicBlurHFU4_K(void *dst, const void *pin, const void *gptr, int rct, int x1, int ct);
164extern void rsdIntrinsicBlurHFU1_K(void *dst, const void *pin, const void *gptr, int rct, int x1, int ct);
165#endif
166
167static void OneVFU4(float4 *out,
168                    const uchar *ptrIn, int iStride, const float* gPtr, int ct,
169                    int x1, int x2) {
170    out += x1;
171#if defined(ARCH_X86_HAVE_SSSE3)
172    if (gArchUseSIMD) {
173        int t = (x2 - x1);
174        t &= ~1;
175        if (t) {
176            rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, x1, x1 + t);
177        }
178        x1 += t;
179        out += t;
180        ptrIn += t << 2;
181    }
182#endif
183    while(x2 > x1) {
184        const uchar *pi = ptrIn;
185        float4 blurredPixel = 0;
186        const float* gp = gPtr;
187
188        for (int r = 0; r < ct; r++) {
189            float4 pf = convert_float4(((const uchar4 *)pi)[0]);
190            blurredPixel += pf * gp[0];
191            pi += iStride;
192            gp++;
193        }
194        out->xyzw = blurredPixel;
195        x1++;
196        out++;
197        ptrIn+=4;
198    }
199}
200
201static void OneVFU1(float *out,
202                    const uchar *ptrIn, int iStride, const float* gPtr, int ct, int x1, int x2) {
203
204    int len = x2 - x1;
205    out += x1;
206
207    while((x2 > x1) && (((uintptr_t)ptrIn) & 0x3)) {
208        const uchar *pi = ptrIn;
209        float blurredPixel = 0;
210        const float* gp = gPtr;
211
212        for (int r = 0; r < ct; r++) {
213            float pf = (float)pi[0];
214            blurredPixel += pf * gp[0];
215            pi += iStride;
216            gp++;
217        }
218        out[0] = blurredPixel;
219        x1++;
220        out++;
221        ptrIn++;
222        len--;
223    }
224#if defined(ARCH_X86_HAVE_SSSE3)
225    if (gArchUseSIMD && (x2 > x1)) {
226        int t = (x2 - x1) >> 2;
227        t &= ~1;
228        if (t) {
229            rsdIntrinsicBlurVFU4_K(out, ptrIn, iStride, gPtr, ct, 0, t );
230            len -= t << 2;
231            ptrIn += t << 2;
232            out += t << 2;
233        }
234    }
235#endif
236    while(len > 0) {
237        const uchar *pi = ptrIn;
238        float blurredPixel = 0;
239        const float* gp = gPtr;
240
241        for (int r = 0; r < ct; r++) {
242            float pf = (float)pi[0];
243            blurredPixel += pf * gp[0];
244            pi += iStride;
245            gp++;
246        }
247        out[0] = blurredPixel;
248        len--;
249        out++;
250        ptrIn++;
251    }
252}
253
254static void OneHU4(const RsExpandKernelDriverInfo *info, uchar4 *out, int32_t x,
255                   const float4 *ptrIn, const float* gPtr, int iradius) {
256
257    float4 blurredPixel = 0;
258    for (int r = -iradius; r <= iradius; r ++) {
259        int validX = rsMax((x + r), 0);
260        validX = rsMin(validX, (int)(info->dim.x - 1));
261        float4 pf = ptrIn[validX];
262        blurredPixel += pf * gPtr[0];
263        gPtr++;
264    }
265
266    out->xyzw = convert_uchar4(blurredPixel);
267}
268
269static void OneHU1(const RsExpandKernelDriverInfo *info, uchar *out, int32_t x,
270                   const float *ptrIn, const float* gPtr, int iradius) {
271
272    float blurredPixel = 0;
273    for (int r = -iradius; r <= iradius; r ++) {
274        int validX = rsMax((x + r), 0);
275        validX = rsMin(validX, (int)(info->dim.x - 1));
276        float pf = ptrIn[validX];
277        blurredPixel += pf * gPtr[0];
278        gPtr++;
279    }
280
281    out[0] = (uchar)blurredPixel;
282}
283
284
285void RsdCpuScriptIntrinsicBlur::kernelU4(const RsExpandKernelDriverInfo *info,
286                                         uint32_t xstart, uint32_t xend,
287                                         uint32_t outstep) {
288
289    float4 stackbuf[2048];
290    float4 *buf = &stackbuf[0];
291    RsdCpuScriptIntrinsicBlur *cp = (RsdCpuScriptIntrinsicBlur *)info->usr;
292    if (!cp->mAlloc.get()) {
293        ALOGE("Blur executed without input, skipping");
294        return;
295    }
296    const uchar *pin = (const uchar *)cp->mAlloc->mHal.drvState.lod[0].mallocPtr;
297    const size_t stride = cp->mAlloc->mHal.drvState.lod[0].stride;
298
299    uchar4 *out = (uchar4 *)info->outPtr[0];
300    uint32_t x1 = xstart;
301    uint32_t x2 = xend;
302
303#if defined(ARCH_ARM_USE_INTRINSICS)
304    if (gArchUseSIMD && info->dim.x >= 4) {
305      rsdIntrinsicBlurU4_K(out, (uchar4 const *)(pin + stride * info->current.y),
306                 info->dim.x, info->dim.y,
307                 stride, x1, info->current.y, x2 - x1, cp->mIradius, cp->mIp + cp->mIradius);
308        return;
309    }
310#endif
311
312    if (info->dim.x > 2048) {
313        if ((info->dim.x > cp->mScratchSize[info->lid]) || !cp->mScratch[info->lid]) {
314            // Pad the side of the allocation by one unit to allow alignment later
315            cp->mScratch[info->lid] = realloc(cp->mScratch[info->lid], (info->dim.x + 1) * 16);
316            cp->mScratchSize[info->lid] = info->dim.x;
317        }
318        // realloc only aligns to 8 bytes so we manually align to 16.
319        buf = (float4 *) ((((intptr_t)cp->mScratch[info->lid]) + 15) & ~0xf);
320    }
321    float4 *fout = (float4 *)buf;
322    int y = info->current.y;
323    if ((y > cp->mIradius) && (y < ((int)info->dim.y - cp->mIradius))) {
324        const uchar *pi = pin + (y - cp->mIradius) * stride;
325        OneVFU4(fout, pi, stride, cp->mFp, cp->mIradius * 2 + 1, 0, info->dim.x);
326    } else {
327        x1 = 0;
328        while(info->dim.x > x1) {
329            OneVU4(info, fout, x1, y, pin, stride, cp->mFp, cp->mIradius);
330            fout++;
331            x1++;
332        }
333    }
334
335    x1 = xstart;
336    while ((x1 < (uint32_t)cp->mIradius) && (x1 < x2)) {
337        OneHU4(info, out, x1, buf, cp->mFp, cp->mIradius);
338        out++;
339        x1++;
340    }
341#if defined(ARCH_X86_HAVE_SSSE3)
342    if (gArchUseSIMD) {
343        if ((x1 + cp->mIradius) < x2) {
344            rsdIntrinsicBlurHFU4_K(out, buf - cp->mIradius, cp->mFp,
345                                   cp->mIradius * 2 + 1, x1, x2 - cp->mIradius);
346            out += (x2 - cp->mIradius) - x1;
347            x1 = x2 - cp->mIradius;
348        }
349    }
350#endif
351    while(x2 > x1) {
352        OneHU4(info, out, x1, buf, cp->mFp, cp->mIradius);
353        out++;
354        x1++;
355    }
356}
357
358void RsdCpuScriptIntrinsicBlur::kernelU1(const RsExpandKernelDriverInfo *info,
359                                         uint32_t xstart, uint32_t xend,
360                                         uint32_t outstep) {
361    float buf[4 * 2048];
362    RsdCpuScriptIntrinsicBlur *cp = (RsdCpuScriptIntrinsicBlur *)info->usr;
363    if (!cp->mAlloc.get()) {
364        ALOGE("Blur executed without input, skipping");
365        return;
366    }
367    const uchar *pin = (const uchar *)cp->mAlloc->mHal.drvState.lod[0].mallocPtr;
368    const size_t stride = cp->mAlloc->mHal.drvState.lod[0].stride;
369
370    uchar *out = (uchar *)info->outPtr[0];
371    uint32_t x1 = xstart;
372    uint32_t x2 = xend;
373
374#if defined(ARCH_ARM_USE_INTRINSICS)
375    if (gArchUseSIMD && info->dim.x >= 16) {
376        // The specialisation for r<=8 has an awkward prefill case, which is
377        // fiddly to resolve, where starting close to the right edge can cause
378        // a read beyond the end of input.  So avoid that case here.
379        if (cp->mIradius > 8 || (info->dim.x - rsMax(0, (int32_t)x1 - 8)) >= 16) {
380            rsdIntrinsicBlurU1_K(out, pin + stride * info->current.y, info->dim.x, info->dim.y,
381                     stride, x1, info->current.y, x2 - x1, cp->mIradius, cp->mIp + cp->mIradius);
382            return;
383        }
384    }
385#endif
386
387    float *fout = (float *)buf;
388    int y = info->current.y;
389    if ((y > cp->mIradius) && (y < ((int)info->dim.y - cp->mIradius -1))) {
390        const uchar *pi = pin + (y - cp->mIradius) * stride;
391        OneVFU1(fout, pi, stride, cp->mFp, cp->mIradius * 2 + 1, 0, info->dim.x);
392    } else {
393        x1 = 0;
394        while(info->dim.x > x1) {
395            OneVU1(info, fout, x1, y, pin, stride, cp->mFp, cp->mIradius);
396            fout++;
397            x1++;
398        }
399    }
400
401    x1 = xstart;
402    while ((x1 < x2) &&
403           ((x1 < (uint32_t)cp->mIradius) || (((uintptr_t)out) & 0x3))) {
404        OneHU1(info, out, x1, buf, cp->mFp, cp->mIradius);
405        out++;
406        x1++;
407    }
408#if defined(ARCH_X86_HAVE_SSSE3)
409    if (gArchUseSIMD) {
410        if ((x1 + cp->mIradius) < x2) {
411            uint32_t len = x2 - (x1 + cp->mIradius);
412            len &= ~3;
413
414            // rsdIntrinsicBlurHFU1_K() processes each four float values in |buf| at once, so it
415            // nees to ensure four more values can be accessed in order to avoid accessing
416            // uninitialized buffer.
417            if (len > 4) {
418                len -= 4;
419                rsdIntrinsicBlurHFU1_K(out, ((float *)buf) - cp->mIradius, cp->mFp,
420                                       cp->mIradius * 2 + 1, x1, x1 + len);
421                out += len;
422                x1 += len;
423            }
424        }
425    }
426#endif
427    while(x2 > x1) {
428        OneHU1(info, out, x1, buf, cp->mFp, cp->mIradius);
429        out++;
430        x1++;
431    }
432}
433
434RsdCpuScriptIntrinsicBlur::RsdCpuScriptIntrinsicBlur(RsdCpuReferenceImpl *ctx,
435                                                     const Script *s, const Element *e)
436            : RsdCpuScriptIntrinsic(ctx, s, e, RS_SCRIPT_INTRINSIC_ID_BLUR) {
437
438    mRootPtr = nullptr;
439    if (e->getType() == RS_TYPE_UNSIGNED_8) {
440        switch (e->getVectorSize()) {
441        case 1:
442            mRootPtr = &kernelU1;
443            break;
444        case 4:
445            mRootPtr = &kernelU4;
446            break;
447        }
448    }
449    rsAssert(mRootPtr);
450    mRadius = 5;
451
452    mScratch = new void *[mCtx->getThreadCount()];
453    mScratchSize = new size_t[mCtx->getThreadCount()];
454    memset(mScratch, 0, sizeof(void *) * mCtx->getThreadCount());
455    memset(mScratchSize, 0, sizeof(size_t) * mCtx->getThreadCount());
456
457    ComputeGaussianWeights();
458}
459
460RsdCpuScriptIntrinsicBlur::~RsdCpuScriptIntrinsicBlur() {
461    uint32_t threads = mCtx->getThreadCount();
462    if (mScratch) {
463        for (size_t i = 0; i < threads; i++) {
464            if (mScratch[i]) {
465                free(mScratch[i]);
466            }
467        }
468        delete []mScratch;
469    }
470    if (mScratchSize) {
471        delete []mScratchSize;
472    }
473}
474
475void RsdCpuScriptIntrinsicBlur::populateScript(Script *s) {
476    s->mHal.info.exportedVariableCount = 2;
477}
478
479void RsdCpuScriptIntrinsicBlur::invokeFreeChildren() {
480    mAlloc.clear();
481}
482
483
484RsdCpuScriptImpl * rsdIntrinsic_Blur(RsdCpuReferenceImpl *ctx, const Script *s, const Element *e) {
485
486    return new RsdCpuScriptIntrinsicBlur(ctx, s, e);
487}
488