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