1/*
2 * Copyright (C) 2013 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#define LOG_TAG "OpenGLRenderer"
18
19#include <math.h>
20
21#include "Blur.h"
22
23namespace android {
24namespace uirenderer {
25
26void Blur::generateGaussianWeights(float* weights, int32_t radius) {
27    // Compute gaussian weights for the blur
28    // e is the euler's number
29    static float e = 2.718281828459045f;
30    static float pi = 3.1415926535897932f;
31    // g(x) = ( 1 / sqrt( 2 * pi ) * sigma) * e ^ ( -x^2 / 2 * sigma^2 )
32    // x is of the form [-radius .. 0 .. radius]
33    // and sigma varies with radius.
34    // Based on some experimental radius values and sigma's
35    // we approximately fit sigma = f(radius) as
36    // sigma = radius * 0.3  + 0.6
37    // The larger the radius gets, the more our gaussian blur
38    // will resemble a box blur since with large sigma
39    // the gaussian curve begins to lose its shape
40    float sigma = 0.3f * (float) radius + 0.6f;
41
42    // Now compute the coefficints
43    // We will store some redundant values to save some math during
44    // the blur calculations
45    // precompute some values
46    float coeff1 = 1.0f / (sqrt(2.0f * pi) * sigma);
47    float coeff2 = - 1.0f / (2.0f * sigma * sigma);
48
49    float normalizeFactor = 0.0f;
50    for (int32_t r = -radius; r <= radius; r ++) {
51        float floatR = (float) r;
52        weights[r + radius] = coeff1 * pow(e, floatR * floatR * coeff2);
53        normalizeFactor += weights[r + radius];
54    }
55
56    //Now we need to normalize the weights because all our coefficients need to add up to one
57    normalizeFactor = 1.0f / normalizeFactor;
58    for (int32_t r = -radius; r <= radius; r ++) {
59        weights[r + radius] *= normalizeFactor;
60    }
61}
62
63void Blur::horizontal(float* weights, int32_t radius,
64        const uint8_t* source, uint8_t* dest, int32_t width, int32_t height) {
65    float blurredPixel = 0.0f;
66    float currentPixel = 0.0f;
67
68    for (int32_t y = 0; y < height; y ++) {
69
70        const uint8_t* input = source + y * width;
71        uint8_t* output = dest + y * width;
72
73        for (int32_t x = 0; x < width; x ++) {
74            blurredPixel = 0.0f;
75            const float* gPtr = weights;
76            // Optimization for non-border pixels
77            if (x > radius && x < (width - radius)) {
78                const uint8_t *i = input + (x - radius);
79                for (int r = -radius; r <= radius; r ++) {
80                    currentPixel = (float) (*i);
81                    blurredPixel += currentPixel * gPtr[0];
82                    gPtr++;
83                    i++;
84                }
85            } else {
86                for (int32_t r = -radius; r <= radius; r ++) {
87                    // Stepping left and right away from the pixel
88                    int validW = x + r;
89                    if (validW < 0) {
90                        validW = 0;
91                    }
92                    if (validW > width - 1) {
93                        validW = width - 1;
94                    }
95
96                    currentPixel = (float) input[validW];
97                    blurredPixel += currentPixel * gPtr[0];
98                    gPtr++;
99                }
100            }
101            *output = (uint8_t)blurredPixel;
102            output ++;
103        }
104    }
105}
106
107void Blur::vertical(float* weights, int32_t radius,
108        const uint8_t* source, uint8_t* dest, int32_t width, int32_t height) {
109    float blurredPixel = 0.0f;
110    float currentPixel = 0.0f;
111
112    for (int32_t y = 0; y < height; y ++) {
113        uint8_t* output = dest + y * width;
114
115        for (int32_t x = 0; x < width; x ++) {
116            blurredPixel = 0.0f;
117            const float* gPtr = weights;
118            const uint8_t* input = source + x;
119            // Optimization for non-border pixels
120            if (y > radius && y < (height - radius)) {
121                const uint8_t *i = input + ((y - radius) * width);
122                for (int32_t r = -radius; r <= radius; r ++) {
123                    currentPixel = (float) (*i);
124                    blurredPixel += currentPixel * gPtr[0];
125                    gPtr++;
126                    i += width;
127                }
128            } else {
129                for (int32_t r = -radius; r <= radius; r ++) {
130                    int validH = y + r;
131                    // Clamp to zero and width
132                    if (validH < 0) {
133                        validH = 0;
134                    }
135                    if (validH > height - 1) {
136                        validH = height - 1;
137                    }
138
139                    const uint8_t *i = input + validH * width;
140                    currentPixel = (float) (*i);
141                    blurredPixel += currentPixel * gPtr[0];
142                    gPtr++;
143                }
144            }
145            *output = (uint8_t) blurredPixel;
146            output++;
147        }
148    }
149}
150
151}; // namespace uirenderer
152}; // namespace android
153