1 /*
2 * Copyright (C) 2010 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 <android/bitmap.h>
18 #include <jni.h>
19
20 #include <cmath>
21 #include <cstdlib>
22
23 #include "utils.h"
24 #include "_jni.h"
25
26 using android::apps::photoeditor::utils::LockBitmaps;
27 using android::apps::photoeditor::utils::pixel32_t;
28 using android::apps::photoeditor::utils::UnlockBitmaps;
29
30 namespace {
31
32 const uint32_t kShiftBits = 10;
33 const uint32_t kShiftValue = (1 << kShiftBits);
34
35 /*
36 * Convolution matrix of distance 2 with fixed point of 'kShiftBits' bits
37 * shifted. Thus the sum of this matrix should be 'kShiftValue'. Entries of
38 * small values are not calculated to gain efficiency.
39 * The order ot pixels represented in this matrix is:
40 * 1 2 3
41 * 4 0 5
42 * 6 7 8
43 * and the matrix should be: {230, 56, 114, 56, 114, 114, 56, 114, 56}.
44 * However, since most of the valus are identical, we only use the first three
45 * entries and the entries corresponding to the pixels is:
46 * 1 2 1
47 * 2 0 2
48 * 1 2 1
49 */
50 const uint32_t convolution_matrix[3] = {230, 56, 114};
51
52 /*
53 * Generate a blurred random noise bitmap.
54 */
GenerateBlurredNoise(void * dst_pixels,AndroidBitmapInfo * dst_info,float noise_scale)55 void GenerateBlurredNoise(void* dst_pixels, AndroidBitmapInfo* dst_info,
56 float noise_scale) {
57 uint32_t fixed_noise_scale = noise_scale * kShiftValue;
58
59 // Clear dst bitmap to 0 for storing generated random noise.
60 memset(dst_pixels, 0, dst_info->stride * dst_info->height);
61
62 // 0.5 is a empirical value and could be tuned.
63 int random_threshold = RAND_MAX * 0.5;
64 for (uint32_t y = 0; y < dst_info->height; y++) {
65 uint32_t* dp_line = reinterpret_cast<uint32_t*>(
66 reinterpret_cast<char*>(dst_pixels) + y * dst_info->stride);
67
68 for (uint32_t x = 0; x < dst_info->width; x++) {
69 if (rand() < random_threshold) {
70 uint32_t* dp = dp_line + x;
71 uint32_t* dp_prev = (y == 0) ? dp : (dp - dst_info->width);
72 uint32_t* dp_next = (y == dst_info->height - 1) ? dp : (dp + dst_info->width);
73
74 /*
75 * 1 2 3
76 * 4 0 5
77 * 6 7 8
78 */
79 uint32_t* n[9];
80 n[0] = dp;
81 n[2] = dp_prev;
82 n[7] = dp_next;
83 if (x == 0) {
84 n[1] = n[2];
85 n[4] = n[0];
86 n[6] = n[7];
87 } else {
88 n[1] = n[2] - 1;
89 n[4] = n[0] - 1;
90 n[6] = n[7] - 1;
91 }
92 if (x == dst_info->width - 1) {
93 n[3] = n[2];
94 n[5] = n[0];
95 n[8] = n[7];
96 } else {
97 n[3] = n[2] + 1;
98 n[5] = n[0] + 1;
99 n[8] = n[7] + 1;
100 }
101
102 // noise randomness uniformly distributed between 0.5 to 1.5,
103 // 0.5 is an empirical value.
104 uint32_t random_noise_scale = fixed_noise_scale
105 * (static_cast<double>(rand()) / RAND_MAX + 0.5);
106
107 *n[0] = *n[0] + ((convolution_matrix[0] * random_noise_scale) >> kShiftBits);
108 // The value in convolution_matrix is identical (56) for indexes 1, 3, 6, 8.
109 uint32_t normal_scaled_noise = (convolution_matrix[1] * random_noise_scale) >> kShiftBits;
110 *n[1] += normal_scaled_noise;
111 *n[3] += normal_scaled_noise;
112 *n[6] += normal_scaled_noise;
113 *n[8] += normal_scaled_noise;
114 // Likewise, the computation could be saved for indexes 2, 4, 5, 7;
115 normal_scaled_noise = (convolution_matrix[2] * random_noise_scale) >> kShiftBits;
116 *n[2] += normal_scaled_noise;
117 *n[4] += normal_scaled_noise;
118 *n[5] += normal_scaled_noise;
119 *n[7] += normal_scaled_noise;
120 }
121 }
122 }
123 }
124
Java_com_android_photoeditor_filters_ImageUtils_nativeGrain(JNIEnv * env,jobject obj,jobject src_bitmap,jobject dst_bitmap,jfloat noise_scale)125 extern "C" JNIEXPORT void JNICALL Java_com_android_photoeditor_filters_ImageUtils_nativeGrain(
126 JNIEnv *env, jobject obj, jobject src_bitmap, jobject dst_bitmap, jfloat noise_scale) {
127 pGrainType f = (pGrainType)JNIFunc[JNI_Grain].func_ptr;
128 return f(env, obj, src_bitmap, dst_bitmap, noise_scale);
129 }
130
Grain(JNIEnv * env,jobject obj,jobject src_bitmap,jobject dst_bitmap,jfloat noise_scale)131 extern "C" void Grain(
132 JNIEnv *env, jobject obj, jobject src_bitmap, jobject dst_bitmap, jfloat noise_scale) {
133 AndroidBitmapInfo src_info;
134 AndroidBitmapInfo dst_info;
135 void* src_pixels;
136 void* dst_pixels;
137
138 int ret = LockBitmaps(
139 env, src_bitmap, dst_bitmap, &src_info, &dst_info, &src_pixels, &dst_pixels);
140 if (ret < 0) {
141 LOGE("LockBitmaps in grain failed, error=%d", ret);
142 return;
143 }
144
145 GenerateBlurredNoise(dst_pixels, &dst_info, noise_scale);
146
147 for (uint32_t scan_line = 0; scan_line < src_info.height; scan_line++) {
148 uint32_t* src = reinterpret_cast<uint32_t*>(
149 reinterpret_cast<char*>(src_pixels) + src_info.stride * scan_line);
150 uint32_t* dst = reinterpret_cast<uint32_t*>(
151 reinterpret_cast<char*>(dst_pixels) + dst_info.stride * scan_line);
152
153 uint32_t* src_line_end = src + src_info.width;
154 while (src < src_line_end) {
155 pixel32_t* sp = reinterpret_cast<pixel32_t*>(src);
156 pixel32_t* dp = reinterpret_cast<pixel32_t*>(dst);
157
158 // energy_mask is used to constrain the noise according to the energy
159 // level. Film grain appear more in dark part.
160 // The energy level (from 0 to 765) is square-rooted and should in the
161 // range from 0 to 27.659 (sqrt(765)), so 28 is used for normalization.
162 uint32_t energy_level = sp->rgba8[0] + sp->rgba8[1] + sp->rgba8[2];
163 uint32_t energy_mask = 28 - static_cast<uint32_t>(sqrtf(energy_level));
164
165 // The intensity of each channel of RGB is affected by the random
166 // noise previously produced and stored in dp->pixel.
167 // dp->pixel should be in the range of [1.3 * noise_scale * kShiftValue,
168 // 0]. Therefore 'scale' should be in the range of
169 // [kShiftValue, kShiftValue - 1.3 * noise_scale * kShiftValue]
170 uint32_t scale = (kShiftValue - dp->rgba32 * energy_mask / 28);
171 uint32_t red = (sp->rgba8[0] * scale) >> kShiftBits;
172 uint32_t green = (sp->rgba8[1] * scale) >> kShiftBits;
173 uint32_t blue = (sp->rgba8[2] * scale) >> kShiftBits;
174 dp->rgba32 = (sp->rgba8[3] << 24) | (blue << 16) | (green << 8) | red;
175
176 dst++;
177 src++;
178 }
179 }
180
181 UnlockBitmaps(env, src_bitmap, dst_bitmap);
182 }
183
184 } // namespace
185