f4790e6f9e
Remove all duplicate platform files, i.e development/ndk/platforms/android-N now only contains files that are introduced in API level 'N' and not found in level 'N-1' (This makes it easier to manage independent platform release branches, and makes platform additions trivial to examine and maintain). Move samples that depends on features of API level 'N' into platforms/android-N/samples + update tests/run-all.sh accordingly Change-Id: I04c4c67c6c674c1714d5812d461d0524a4f4cfd9
401 lines
11 KiB
C
401 lines
11 KiB
C
/*
|
|
* Copyright (C) 2010 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <jni.h>
|
|
#include <time.h>
|
|
#include <android/log.h>
|
|
#include <android/bitmap.h>
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
|
|
#define LOG_TAG "libplasma"
|
|
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
|
|
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
|
|
|
|
/* Set to 1 to enable debug log traces. */
|
|
#define DEBUG 0
|
|
|
|
/* Set to 1 to optimize memory stores when generating plasma. */
|
|
#define OPTIMIZE_WRITES 1
|
|
|
|
/* Return current time in milliseconds */
|
|
static double now_ms(void)
|
|
{
|
|
struct timeval tv;
|
|
gettimeofday(&tv, NULL);
|
|
return tv.tv_sec*1000. + tv.tv_usec/1000.;
|
|
}
|
|
|
|
/* We're going to perform computations for every pixel of the target
|
|
* bitmap. floating-point operations are very slow on ARMv5, and not
|
|
* too bad on ARMv7 with the exception of trigonometric functions.
|
|
*
|
|
* For better performance on all platforms, we're going to use fixed-point
|
|
* arithmetic and all kinds of tricks
|
|
*/
|
|
|
|
typedef int32_t Fixed;
|
|
|
|
#define FIXED_BITS 16
|
|
#define FIXED_ONE (1 << FIXED_BITS)
|
|
#define FIXED_AVERAGE(x,y) (((x) + (y)) >> 1)
|
|
|
|
#define FIXED_FROM_INT(x) ((x) << FIXED_BITS)
|
|
#define FIXED_TO_INT(x) ((x) >> FIXED_BITS)
|
|
|
|
#define FIXED_FROM_FLOAT(x) ((Fixed)((x)*FIXED_ONE))
|
|
#define FIXED_TO_FLOAT(x) ((x)/(1.*FIXED_ONE))
|
|
|
|
#define FIXED_MUL(x,y) (((int64_t)(x) * (y)) >> FIXED_BITS)
|
|
#define FIXED_DIV(x,y) (((int64_t)(x) * FIXED_ONE) / (y))
|
|
|
|
#define FIXED_DIV2(x) ((x) >> 1)
|
|
#define FIXED_AVERAGE(x,y) (((x) + (y)) >> 1)
|
|
|
|
#define FIXED_FRAC(x) ((x) & ((1 << FIXED_BITS)-1))
|
|
#define FIXED_TRUNC(x) ((x) & ~((1 << FIXED_BITS)-1))
|
|
|
|
#define FIXED_FROM_INT_FLOAT(x,f) (Fixed)((x)*(FIXED_ONE*(f)))
|
|
|
|
typedef int32_t Angle;
|
|
|
|
#define ANGLE_BITS 9
|
|
|
|
#if ANGLE_BITS < 8
|
|
# error ANGLE_BITS must be at least 8
|
|
#endif
|
|
|
|
#define ANGLE_2PI (1 << ANGLE_BITS)
|
|
#define ANGLE_PI (1 << (ANGLE_BITS-1))
|
|
#define ANGLE_PI2 (1 << (ANGLE_BITS-2))
|
|
#define ANGLE_PI4 (1 << (ANGLE_BITS-3))
|
|
|
|
#define ANGLE_FROM_FLOAT(x) (Angle)((x)*ANGLE_PI/M_PI)
|
|
#define ANGLE_TO_FLOAT(x) ((x)*M_PI/ANGLE_PI)
|
|
|
|
#if ANGLE_BITS <= FIXED_BITS
|
|
# define ANGLE_FROM_FIXED(x) (Angle)((x) >> (FIXED_BITS - ANGLE_BITS))
|
|
# define ANGLE_TO_FIXED(x) (Fixed)((x) << (FIXED_BITS - ANGLE_BITS))
|
|
#else
|
|
# define ANGLE_FROM_FIXED(x) (Angle)((x) << (ANGLE_BITS - FIXED_BITS))
|
|
# define ANGLE_TO_FIXED(x) (Fixed)((x) >> (ANGLE_BITS - FIXED_BITS))
|
|
#endif
|
|
|
|
static Fixed angle_sin_tab[ANGLE_2PI+1];
|
|
|
|
static void init_angles(void)
|
|
{
|
|
int nn;
|
|
for (nn = 0; nn < ANGLE_2PI+1; nn++) {
|
|
double radians = nn*M_PI/ANGLE_PI;
|
|
angle_sin_tab[nn] = FIXED_FROM_FLOAT(sin(radians));
|
|
}
|
|
}
|
|
|
|
static __inline__ Fixed angle_sin( Angle a )
|
|
{
|
|
return angle_sin_tab[(uint32_t)a & (ANGLE_2PI-1)];
|
|
}
|
|
|
|
static __inline__ Fixed angle_cos( Angle a )
|
|
{
|
|
return angle_sin(a + ANGLE_PI2);
|
|
}
|
|
|
|
static __inline__ Fixed fixed_sin( Fixed f )
|
|
{
|
|
return angle_sin(ANGLE_FROM_FIXED(f));
|
|
}
|
|
|
|
static __inline__ Fixed fixed_cos( Fixed f )
|
|
{
|
|
return angle_cos(ANGLE_FROM_FIXED(f));
|
|
}
|
|
|
|
/* Color palette used for rendering the plasma */
|
|
#define PALETTE_BITS 8
|
|
#define PALETTE_SIZE (1 << PALETTE_BITS)
|
|
|
|
#if PALETTE_BITS > FIXED_BITS
|
|
# error PALETTE_BITS must be smaller than FIXED_BITS
|
|
#endif
|
|
|
|
static uint16_t palette[PALETTE_SIZE];
|
|
|
|
static uint16_t make565(int red, int green, int blue)
|
|
{
|
|
return (uint16_t)( ((red << 8) & 0xf800) |
|
|
((green << 2) & 0x03e0) |
|
|
((blue >> 3) & 0x001f) );
|
|
}
|
|
|
|
static void init_palette(void)
|
|
{
|
|
int nn, mm = 0;
|
|
/* fun with colors */
|
|
for (nn = 0; nn < PALETTE_SIZE/4; nn++) {
|
|
int jj = (nn-mm)*4*255/PALETTE_SIZE;
|
|
palette[nn] = make565(255, jj, 255-jj);
|
|
}
|
|
|
|
for ( mm = nn; nn < PALETTE_SIZE/2; nn++ ) {
|
|
int jj = (nn-mm)*4*255/PALETTE_SIZE;
|
|
palette[nn] = make565(255-jj, 255, jj);
|
|
}
|
|
|
|
for ( mm = nn; nn < PALETTE_SIZE*3/4; nn++ ) {
|
|
int jj = (nn-mm)*4*255/PALETTE_SIZE;
|
|
palette[nn] = make565(0, 255-jj, 255);
|
|
}
|
|
|
|
for ( mm = nn; nn < PALETTE_SIZE; nn++ ) {
|
|
int jj = (nn-mm)*4*255/PALETTE_SIZE;
|
|
palette[nn] = make565(jj, 0, 255);
|
|
}
|
|
}
|
|
|
|
static __inline__ uint16_t palette_from_fixed( Fixed x )
|
|
{
|
|
if (x < 0) x = -x;
|
|
if (x >= FIXED_ONE) x = FIXED_ONE-1;
|
|
int idx = FIXED_FRAC(x) >> (FIXED_BITS - PALETTE_BITS);
|
|
return palette[idx & (PALETTE_SIZE-1)];
|
|
}
|
|
|
|
/* Angles expressed as fixed point radians */
|
|
|
|
static void init_tables(void)
|
|
{
|
|
init_palette();
|
|
init_angles();
|
|
}
|
|
|
|
static void fill_plasma( AndroidBitmapInfo* info, void* pixels, double t )
|
|
{
|
|
Fixed ft = FIXED_FROM_FLOAT(t/1000.);
|
|
Fixed yt1 = FIXED_FROM_FLOAT(t/1230.);
|
|
Fixed yt2 = yt1;
|
|
Fixed xt10 = FIXED_FROM_FLOAT(t/3000.);
|
|
Fixed xt20 = xt10;
|
|
|
|
#define YT1_INCR FIXED_FROM_FLOAT(1/100.)
|
|
#define YT2_INCR FIXED_FROM_FLOAT(1/163.)
|
|
|
|
int yy;
|
|
for (yy = 0; yy < info->height; yy++) {
|
|
uint16_t* line = (uint16_t*)pixels;
|
|
Fixed base = fixed_sin(yt1) + fixed_sin(yt2);
|
|
Fixed xt1 = xt10;
|
|
Fixed xt2 = xt20;
|
|
|
|
yt1 += YT1_INCR;
|
|
yt2 += YT2_INCR;
|
|
|
|
#define XT1_INCR FIXED_FROM_FLOAT(1/173.)
|
|
#define XT2_INCR FIXED_FROM_FLOAT(1/242.)
|
|
|
|
#if OPTIMIZE_WRITES
|
|
/* optimize memory writes by generating one aligned 32-bit store
|
|
* for every pair of pixels.
|
|
*/
|
|
uint16_t* line_end = line + info->width;
|
|
|
|
if (line < line_end) {
|
|
if (((uint32_t)line & 3) != 0) {
|
|
Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
|
|
|
|
xt1 += XT1_INCR;
|
|
xt2 += XT2_INCR;
|
|
|
|
line[0] = palette_from_fixed(ii >> 2);
|
|
line++;
|
|
}
|
|
|
|
while (line + 2 <= line_end) {
|
|
Fixed i1 = base + fixed_sin(xt1) + fixed_sin(xt2);
|
|
xt1 += XT1_INCR;
|
|
xt2 += XT2_INCR;
|
|
|
|
Fixed i2 = base + fixed_sin(xt1) + fixed_sin(xt2);
|
|
xt1 += XT1_INCR;
|
|
xt2 += XT2_INCR;
|
|
|
|
uint32_t pixel = ((uint32_t)palette_from_fixed(i1 >> 2) << 16) |
|
|
(uint32_t)palette_from_fixed(i2 >> 2);
|
|
|
|
((uint32_t*)line)[0] = pixel;
|
|
line += 2;
|
|
}
|
|
|
|
if (line < line_end) {
|
|
Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
|
|
line[0] = palette_from_fixed(ii >> 2);
|
|
line++;
|
|
}
|
|
}
|
|
#else /* !OPTIMIZE_WRITES */
|
|
int xx;
|
|
for (xx = 0; xx < info->width; xx++) {
|
|
|
|
Fixed ii = base + fixed_sin(xt1) + fixed_sin(xt2);
|
|
|
|
xt1 += XT1_INCR;
|
|
xt2 += XT2_INCR;
|
|
|
|
line[xx] = palette_from_fixed(ii / 4);
|
|
}
|
|
#endif /* !OPTIMIZE_WRITES */
|
|
|
|
// go to next line
|
|
pixels = (char*)pixels + info->stride;
|
|
}
|
|
}
|
|
|
|
/* simple stats management */
|
|
typedef struct {
|
|
double renderTime;
|
|
double frameTime;
|
|
} FrameStats;
|
|
|
|
#define MAX_FRAME_STATS 200
|
|
#define MAX_PERIOD_MS 1500
|
|
|
|
typedef struct {
|
|
double firstTime;
|
|
double lastTime;
|
|
double frameTime;
|
|
|
|
int firstFrame;
|
|
int numFrames;
|
|
FrameStats frames[ MAX_FRAME_STATS ];
|
|
} Stats;
|
|
|
|
static void
|
|
stats_init( Stats* s )
|
|
{
|
|
s->lastTime = now_ms();
|
|
s->firstTime = 0.;
|
|
s->firstFrame = 0;
|
|
s->numFrames = 0;
|
|
}
|
|
|
|
static void
|
|
stats_startFrame( Stats* s )
|
|
{
|
|
s->frameTime = now_ms();
|
|
}
|
|
|
|
static void
|
|
stats_endFrame( Stats* s )
|
|
{
|
|
double now = now_ms();
|
|
double renderTime = now - s->frameTime;
|
|
double frameTime = now - s->lastTime;
|
|
int nn;
|
|
|
|
if (now - s->firstTime >= MAX_PERIOD_MS) {
|
|
if (s->numFrames > 0) {
|
|
double minRender, maxRender, avgRender;
|
|
double minFrame, maxFrame, avgFrame;
|
|
int count;
|
|
|
|
nn = s->firstFrame;
|
|
minRender = maxRender = avgRender = s->frames[nn].renderTime;
|
|
minFrame = maxFrame = avgFrame = s->frames[nn].frameTime;
|
|
for (count = s->numFrames; count > 0; count-- ) {
|
|
nn += 1;
|
|
if (nn >= MAX_FRAME_STATS)
|
|
nn -= MAX_FRAME_STATS;
|
|
double render = s->frames[nn].renderTime;
|
|
if (render < minRender) minRender = render;
|
|
if (render > maxRender) maxRender = render;
|
|
double frame = s->frames[nn].frameTime;
|
|
if (frame < minFrame) minFrame = frame;
|
|
if (frame > maxFrame) maxFrame = frame;
|
|
avgRender += render;
|
|
avgFrame += frame;
|
|
}
|
|
avgRender /= s->numFrames;
|
|
avgFrame /= s->numFrames;
|
|
|
|
LOGI("frame/s (avg,min,max) = (%.1f,%.1f,%.1f) "
|
|
"render time ms (avg,min,max) = (%.1f,%.1f,%.1f)\n",
|
|
1000./avgFrame, 1000./maxFrame, 1000./minFrame,
|
|
avgRender, minRender, maxRender);
|
|
}
|
|
s->numFrames = 0;
|
|
s->firstFrame = 0;
|
|
s->firstTime = now;
|
|
}
|
|
|
|
nn = s->firstFrame + s->numFrames;
|
|
if (nn >= MAX_FRAME_STATS)
|
|
nn -= MAX_FRAME_STATS;
|
|
|
|
s->frames[nn].renderTime = renderTime;
|
|
s->frames[nn].frameTime = frameTime;
|
|
|
|
if (s->numFrames < MAX_FRAME_STATS) {
|
|
s->numFrames += 1;
|
|
} else {
|
|
s->firstFrame += 1;
|
|
if (s->firstFrame >= MAX_FRAME_STATS)
|
|
s->firstFrame -= MAX_FRAME_STATS;
|
|
}
|
|
|
|
s->lastTime = now;
|
|
}
|
|
|
|
JNIEXPORT void JNICALL Java_com_example_plasma_PlasmaView_renderPlasma(JNIEnv * env, jobject obj, jobject bitmap, jlong time_ms)
|
|
{
|
|
AndroidBitmapInfo info;
|
|
void* pixels;
|
|
int ret;
|
|
static Stats stats;
|
|
static int init;
|
|
|
|
if (!init) {
|
|
init_tables();
|
|
stats_init(&stats);
|
|
init = 1;
|
|
}
|
|
|
|
if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
|
|
LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
|
|
return;
|
|
}
|
|
|
|
if (info.format != ANDROID_BITMAP_FORMAT_RGB_565) {
|
|
LOGE("Bitmap format is not RGB_565 !");
|
|
return;
|
|
}
|
|
|
|
if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
|
|
LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
|
|
}
|
|
|
|
stats_startFrame(&stats);
|
|
|
|
/* Now fill the values with a nice little plasma */
|
|
fill_plasma(&info, pixels, time_ms );
|
|
|
|
AndroidBitmap_unlockPixels(env, bitmap);
|
|
|
|
stats_endFrame(&stats);
|
|
}
|