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 <jni.h>
18 #include <time.h>
19 #include <android/log.h>
20 #include <android/bitmap.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <math.h>
25
26 #include "bcc/bcc.h"
27
28 #define LOG_TAG "libplasma"
29 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
30 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
31
32 /* Set to 1 to enable debug log traces. */
33 #define DEBUG 0
34
35 /* Set to 1 to optimize memory stores when generating plasma. */
36 #define OPTIMIZE_WRITES 1
37
38 /* Return current time in milliseconds */
now_ms(void)39 static double now_ms(void)
40 {
41 struct timeval tv;
42 gettimeofday(&tv, NULL);
43 return tv.tv_sec*1000. + tv.tv_usec/1000.;
44 }
45
46 /* We're going to perform computations for every pixel of the target
47 * bitmap. floating-point operations are very slow on ARMv5, and not
48 * too bad on ARMv7 with the exception of trigonometric functions.
49 *
50 * For better performance on all platforms, we're going to use fixed-point
51 * arithmetic and all kinds of tricks
52 */
53
54 typedef int32_t Fixed;
55
56 #define FIXED_BITS 16
57 #define FIXED_ONE (1 << FIXED_BITS)
58 #define FIXED_AVERAGE(x,y) (((x) + (y)) >> 1)
59
60 #define FIXED_FROM_INT(x) ((x) << FIXED_BITS)
61 #define FIXED_TO_INT(x) ((x) >> FIXED_BITS)
62
63 #define FIXED_FROM_FLOAT(x) ((Fixed)((x)*FIXED_ONE))
64 #define FIXED_TO_FLOAT(x) ((x)/(1.*FIXED_ONE))
65
66 #define FIXED_MUL(x,y) (((int64_t)(x) * (y)) >> FIXED_BITS)
67 #define FIXED_DIV(x,y) (((int64_t)(x) * FIXED_ONE) / (y))
68
69 #define FIXED_DIV2(x) ((x) >> 1)
70 #define FIXED_AVERAGE(x,y) (((x) + (y)) >> 1)
71
72 #define FIXED_FRAC(x) ((x) & ((1 << FIXED_BITS)-1))
73 #define FIXED_TRUNC(x) ((x) & ~((1 << FIXED_BITS)-1))
74
75 #define FIXED_FROM_INT_FLOAT(x,f) (Fixed)((x)*(FIXED_ONE*(f)))
76
77 typedef int32_t Angle;
78
79 #define ANGLE_BITS 9
80
81 #if ANGLE_BITS < 8
82 # error ANGLE_BITS must be at least 8
83 #endif
84
85 #define ANGLE_2PI (1 << ANGLE_BITS)
86 #define ANGLE_PI (1 << (ANGLE_BITS-1))
87 #define ANGLE_PI2 (1 << (ANGLE_BITS-2))
88 #define ANGLE_PI4 (1 << (ANGLE_BITS-3))
89
90 #define ANGLE_FROM_FLOAT(x) (Angle)((x)*ANGLE_PI/M_PI)
91 #define ANGLE_TO_FLOAT(x) ((x)*M_PI/ANGLE_PI)
92
93 #if ANGLE_BITS <= FIXED_BITS
94 # define ANGLE_FROM_FIXED(x) (Angle)((x) >> (FIXED_BITS - ANGLE_BITS))
95 # define ANGLE_TO_FIXED(x) (Fixed)((x) << (FIXED_BITS - ANGLE_BITS))
96 #else
97 # define ANGLE_FROM_FIXED(x) (Angle)((x) << (ANGLE_BITS - FIXED_BITS))
98 # define ANGLE_TO_FIXED(x) (Fixed)((x) >> (ANGLE_BITS - FIXED_BITS))
99 #endif
100
101 static Fixed angle_sin_tab[ANGLE_2PI+1];
102
init_angles(void)103 static void init_angles(void)
104 {
105 int nn;
106 for (nn = 0; nn < ANGLE_2PI+1; nn++) {
107 double radians = nn*M_PI/ANGLE_PI;
108 angle_sin_tab[nn] = FIXED_FROM_FLOAT(sin(radians));
109 }
110 }
111
angle_sin(Angle a)112 static __inline__ Fixed angle_sin( Angle a )
113 {
114 return angle_sin_tab[(uint32_t)a & (ANGLE_2PI-1)];
115 }
116
angle_cos(Angle a)117 static __inline__ Fixed angle_cos( Angle a )
118 {
119 return angle_sin(a + ANGLE_PI2);
120 }
121
fixed_sin(Fixed f)122 static __inline__ Fixed fixed_sin( Fixed f )
123 {
124 return angle_sin(ANGLE_FROM_FIXED(f));
125 }
126
fixed_cos(Fixed f)127 static __inline__ Fixed fixed_cos( Fixed f )
128 {
129 return angle_cos(ANGLE_FROM_FIXED(f));
130 }
131
132 /* Color palette used for rendering the plasma */
133 #define PALETTE_BITS 8
134 #define PALETTE_SIZE (1 << PALETTE_BITS)
135
136 #if PALETTE_BITS > FIXED_BITS
137 # error PALETTE_BITS must be smaller than FIXED_BITS
138 #endif
139
140 static uint16_t palette[PALETTE_SIZE];
141
make565(int red,int green,int blue)142 static uint16_t make565(int red, int green, int blue)
143 {
144 return (uint16_t)( ((red << 8) & 0xf800) |
145 ((green << 2) & 0x03e0) |
146 ((blue >> 3) & 0x001f) );
147 }
148
init_palette(void)149 static void init_palette(void)
150 {
151 int nn, mm = 0;
152 /* fun with colors */
153 for (nn = 0; nn < PALETTE_SIZE/4; nn++) {
154 int jj = (nn-mm)*4*255/PALETTE_SIZE;
155 palette[nn] = make565(255, jj, 255-jj);
156 }
157
158 for ( mm = nn; nn < PALETTE_SIZE/2; nn++ ) {
159 int jj = (nn-mm)*4*255/PALETTE_SIZE;
160 palette[nn] = make565(255-jj, 255, jj);
161 }
162
163 for ( mm = nn; nn < PALETTE_SIZE*3/4; nn++ ) {
164 int jj = (nn-mm)*4*255/PALETTE_SIZE;
165 palette[nn] = make565(0, 255-jj, 255);
166 }
167
168 for ( mm = nn; nn < PALETTE_SIZE; nn++ ) {
169 int jj = (nn-mm)*4*255/PALETTE_SIZE;
170 palette[nn] = make565(jj, 0, 255);
171 }
172 }
173
palette_from_fixed(Fixed x)174 static __inline__ uint16_t palette_from_fixed( Fixed x )
175 {
176 if (x < 0) x = -x;
177 if (x >= FIXED_ONE) x = FIXED_ONE-1;
178 int idx = FIXED_FRAC(x) >> (FIXED_BITS - PALETTE_BITS);
179 return palette[idx & (PALETTE_SIZE-1)];
180 }
181
182 /* Angles expressed as fixed point radians */
183
init_tables(void)184 static void init_tables(void)
185 {
186 init_palette();
187 init_angles();
188 }
189
fill_plasma(AndroidBitmapInfo * info,void * pixels,double t)190 static void fill_plasma( AndroidBitmapInfo* info, void* pixels, double t )
191 {
192 Fixed ft = FIXED_FROM_FLOAT(t/1000.);
193 Fixed yt1 = FIXED_FROM_FLOAT(t/1230.);
194 Fixed yt2 = yt1;
195 Fixed xt10 = FIXED_FROM_FLOAT(t/3000.);
196 Fixed xt20 = xt10;
197
198 #define YT1_INCR FIXED_FROM_FLOAT(1/100.)
199 #define YT2_INCR FIXED_FROM_FLOAT(1/163.)
200
201 int yy;
202 for (yy = 0; yy < info->height; yy++) {
203 uint16_t* line = (uint16_t*)pixels;
204 Fixed base = fixed_sin(yt1) + fixed_sin(yt2);
205 Fixed xt1 = xt10;
206 Fixed xt2 = xt20;
207
208 yt1 += YT1_INCR;
209 yt2 += YT2_INCR;
210
211 #define XT1_INCR FIXED_FROM_FLOAT(1/173.)
212 #define XT2_INCR FIXED_FROM_FLOAT(1/242.)
213
214 #if OPTIMIZE_WRITES
215 /* optimize memory writes by generating one aligned 32-bit store
216 * for every pair of pixels.
217 */
218 uint16_t* line_end = line + info->width;
219
220 if (line < line_end) {
221 if (((uint32_t)line & 3) != 0) {
222 Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
223
224 xt1 += XT1_INCR;
225 xt2 += XT2_INCR;
226
227 line[0] = palette_from_fixed(ii >> 2);
228 line++;
229 }
230
231 while (line + 2 <= line_end) {
232 Fixed i1 = base + fixed_sin(xt1) + fixed_sin(xt2);
233 xt1 += XT1_INCR;
234 xt2 += XT2_INCR;
235
236 Fixed i2 = base + fixed_sin(xt1) + fixed_sin(xt2);
237 xt1 += XT1_INCR;
238 xt2 += XT2_INCR;
239
240 uint32_t pixel = ((uint32_t)palette_from_fixed(i1 >> 2) << 16) |
241 (uint32_t)palette_from_fixed(i2 >> 2);
242
243 ((uint32_t*)line)[0] = pixel;
244 line += 2;
245 }
246
247 if (line < line_end) {
248 Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
249 line[0] = palette_from_fixed(ii >> 2);
250 line++;
251 }
252 }
253 #else /* !OPTIMIZE_WRITES */
254 int xx;
255 for (xx = 0; xx < info->width; xx++) {
256
257 Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
258
259 xt1 += XT1_INCR;
260 xt2 += XT2_INCR;
261
262 line[xx] = palette_from_fixed(ii / 4);
263 }
264 #endif /* !OPTIMIZE_WRITES */
265
266 // go to next line
267 pixels = (char*)pixels + info->stride;
268 }
269 }
270
271 /* simple stats management */
272 typedef struct {
273 double renderTime;
274 double frameTime;
275 } FrameStats;
276
277 #define MAX_FRAME_STATS 200
278 #define MAX_PERIOD_MS 1500
279
280 typedef struct {
281 double firstTime;
282 double lastTime;
283 double frameTime;
284
285 int firstFrame;
286 int numFrames;
287 FrameStats frames[ MAX_FRAME_STATS ];
288 } Stats;
289
290 static void
stats_init(Stats * s)291 stats_init( Stats* s )
292 {
293 s->lastTime = now_ms();
294 s->firstTime = 0.;
295 s->firstFrame = 0;
296 s->numFrames = 0;
297 }
298
299 static void
stats_startFrame(Stats * s)300 stats_startFrame( Stats* s )
301 {
302 s->frameTime = now_ms();
303 }
304
305 static void
stats_endFrame(Stats * s)306 stats_endFrame( Stats* s )
307 {
308 double now = now_ms();
309 double renderTime = now - s->frameTime;
310 double frameTime = now - s->lastTime;
311 int nn;
312
313 if (now - s->firstTime >= MAX_PERIOD_MS) {
314 if (s->numFrames > 0) {
315 double minRender, maxRender, avgRender;
316 double minFrame, maxFrame, avgFrame;
317 int count;
318
319 nn = s->firstFrame;
320 minRender = maxRender = avgRender = s->frames[nn].renderTime;
321 minFrame = maxFrame = avgFrame = s->frames[nn].frameTime;
322 for (count = s->numFrames; count > 0; count-- ) {
323 nn += 1;
324 if (nn >= MAX_FRAME_STATS)
325 nn -= MAX_FRAME_STATS;
326 double render = s->frames[nn].renderTime;
327 if (render < minRender) minRender = render;
328 if (render > maxRender) maxRender = render;
329 double frame = s->frames[nn].frameTime;
330 if (frame < minFrame) minFrame = frame;
331 if (frame > maxFrame) maxFrame = frame;
332 avgRender += render;
333 avgFrame += frame;
334 }
335 avgRender /= s->numFrames;
336 avgFrame /= s->numFrames;
337
338 LOGI("frame/s (avg,min,max) = (%.1f,%.1f,%.1f) "
339 "render time ms (avg,min,max) = (%.1f,%.1f,%.1f)\n",
340 1000./avgFrame, 1000./maxFrame, 1000./minFrame,
341 avgRender, minRender, maxRender);
342 }
343 s->numFrames = 0;
344 s->firstFrame = 0;
345 s->firstTime = now;
346 }
347
348 nn = s->firstFrame + s->numFrames;
349 if (nn >= MAX_FRAME_STATS)
350 nn -= MAX_FRAME_STATS;
351
352 s->frames[nn].renderTime = renderTime;
353 s->frames[nn].frameTime = frameTime;
354
355 if (s->numFrames < MAX_FRAME_STATS) {
356 s->numFrames += 1;
357 } else {
358 s->firstFrame += 1;
359 if (s->firstFrame >= MAX_FRAME_STATS)
360 s->firstFrame -= MAX_FRAME_STATS;
361 }
362
363 s->lastTime = now;
364 }
365
366 typedef void (*pPlasmaType)(uint32_t, uint32_t, uint32_t, double, uint16_t*, void*, void*);
367
Java_com_example_plasma_llvm_PlasmaView_nativeRenderPlasma(JNIEnv * env,jobject obj,jobject bitmap,jlong time_ms,jbyteArray scriptRef,jint length,jboolean use_llvm)368 extern "C" JNIEXPORT jint JNICALL Java_com_example_plasma_llvm_PlasmaView_nativeRenderPlasma
369 (JNIEnv * env, jobject obj,
370 jobject bitmap, jlong time_ms, jbyteArray scriptRef, jint length, jboolean use_llvm)
371 {
372 AndroidBitmapInfo info;
373 void* pixels;
374 int ret;
375 static Stats stats;
376 static int init;
377 static double time_sum = 0;
378 static int count = 0;
379 static bool last_mode = false;
380 static pPlasmaType native_function = NULL;
381 static BCCScriptRef script_ref;
382
383 if (last_mode != use_llvm)
384 count = 0, time_sum = 0;
385 last_mode = use_llvm;
386
387 if (!init) {
388 init_tables();
389 stats_init(&stats);
390 init = 1;
391 }
392
393 if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
394 LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
395 return -1;
396 }
397
398 if (info.format != ANDROID_BITMAP_FORMAT_RGB_565) {
399 LOGE("Bitmap format is not RGB_565 !");
400 return -1;
401 }
402
403 if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
404 LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
405 }
406
407
408 if (use_llvm) {
409 double start_jit = now_ms();
410
411 if (native_function == NULL) {
412 script_ref = bccCreateScript();
413
414 jbyte* script_ptr = (jbyte *)env->GetPrimitiveArrayCritical(scriptRef, (jboolean *)0);
415
416 LOGI("BCC Script Len: %d", length);
417 if(bccReadBC(script_ref, "libplasma_portable.bc", (const char*)script_ptr, length, 0)) {
418 LOGE("Error! Cannot bccReadBc");
419 return -1;
420 }
421 if (script_ptr) {
422 env->ReleasePrimitiveArrayCritical(scriptRef, script_ptr, 0);
423 }
424
425 if (bccLinkFile(script_ref, "/system/lib/libclcore.bc", 0)) {
426 LOGE("Error! Cannot bccLinkBC");
427 return -1;
428 }
429
430 if (bccPrepareExecutable(script_ref, "/data/data/com.example.plasma.llvm/", "plasmaLLVM", 0)) {
431 LOGE("Error! Cannot bccPrepareExecutable");
432 return -1;
433 }
434 native_function = (pPlasmaType)bccGetFuncAddr(script_ref, "root");
435 if (native_function == NULL) {
436 LOGE("Error! Cannot find fill_plasma()");
437 return -1;
438 }
439 }
440
441 double start_run = now_ms();
442 native_function(info.width, info.height, info.stride, time_ms, palette, pixels, angle_sin_tab);
443 double diff = now_ms()-start_run;
444 LOGI("LLVM Time JIT: %.2lf , Run: %.2lf, Avg: %.2lf", start_run-start_jit, diff, time_sum / count);
445 time_sum += diff + start_run - start_jit;
446 } else {
447 double start_run = now_ms();
448 fill_plasma(&info, pixels, time_ms );
449 double diff = now_ms()-start_run;
450 LOGI("GCC Time Run: %.2lf, Avg: %.2lf", diff, time_sum / count);
451 time_sum += diff;
452 }
453 count++;
454
455 AndroidBitmap_unlockPixels(env, bitmap);
456
457 return count * 1000.0 / time_sum;
458 }
459