ADHOC/replicant-frameworks_native
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
bcef13b666
replicant-frameworks_native/libs/surfaceflinger/BootAnimation.cpp
The Android Open Source Project edbf3b6af7 auto import from //depot/cupcake/@135843
2009-03-03 19:31:44 -08:00

404 lines
13 KiB
C++
Raw Blame History

/*
* Copyright (C) 2007 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.
*/
#define LOG_TAG "BootAnimation"
#include <stdint.h>
#include <sys/types.h>
#include <math.h>
#include <fcntl.h>
#include <utils/misc.h>
#include <utils/threads.h>
#include <utils/Atomic.h>
#include <utils/Errors.h>
#include <utils/Log.h>
#include <utils/AssetManager.h>
#include <ui/PixelFormat.h>
#include <ui/Rect.h>
#include <ui/Region.h>
#include <ui/DisplayInfo.h>
#include <ui/ISurfaceComposer.h>
#include <ui/ISurfaceFlingerClient.h>
#include <ui/EGLNativeWindowSurface.h>
#include <core/SkBitmap.h>
#include <images/SkImageDecoder.h>
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <EGL/eglext.h>
#include "BootAnimation.h"
namespace android {
// ---------------------------------------------------------------------------
BootAnimation::BootAnimation(const sp<ISurfaceComposer>& composer) :
Thread(false) {
mSession = SurfaceComposerClient::clientForConnection(
composer->createConnection()->asBinder());
}
BootAnimation::~BootAnimation() {
}
void BootAnimation::onFirstRef() {
run("BootAnimation", PRIORITY_DISPLAY);
}
const sp<SurfaceComposerClient>& BootAnimation::session() const {
return mSession;
}
status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
const char* name) {
Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
if (!asset)
return NO_INIT;
SkBitmap bitmap;
SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
&bitmap, SkBitmap::kNo_Config, SkImageDecoder::kDecodePixels_Mode);
asset->close();
delete asset;
// ensure we can call getPixels(). No need to call unlock, since the
// bitmap will go out of scope when we return from this method.
bitmap.lockPixels();
const int w = bitmap.width();
const int h = bitmap.height();
const void* p = bitmap.getPixels();
GLint crop[4] = { 0, h, w, -h };
texture->w = w;
texture->h = h;
glGenTextures(1, &texture->name);
glBindTexture(GL_TEXTURE_2D, texture->name);
switch (bitmap.getConfig()) {
case SkBitmap::kA8_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
GL_UNSIGNED_BYTE, p);
break;
case SkBitmap::kARGB_4444_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
GL_UNSIGNED_SHORT_4_4_4_4, p);
break;
case SkBitmap::kARGB_8888_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
GL_UNSIGNED_BYTE, p);
break;
case SkBitmap::kRGB_565_Config:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
GL_UNSIGNED_SHORT_5_6_5, p);
break;
default:
break;
}
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
return NO_ERROR;
}
status_t BootAnimation::readyToRun() {
mAssets.addDefaultAssets();
DisplayInfo dinfo;
status_t status = session()->getDisplayInfo(0, &dinfo);
if (status)
return -1;
// create the native surface
sp<Surface> s = session()->createSurface(getpid(), 0, dinfo.w, dinfo.h,
PIXEL_FORMAT_RGB_565);
session()->openTransaction();
s->setLayer(0x40000000);
session()->closeTransaction();
// initialize opengl and egl
const EGLint attribs[] = { EGL_RED_SIZE, 5, EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5, EGL_DEPTH_SIZE, 0, EGL_NONE };
EGLint w, h, dummy;
EGLint numConfigs;
EGLConfig config;
EGLSurface surface;
EGLContext context;
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
mNativeWindowSurface = new EGLNativeWindowSurface(s);
surface = eglCreateWindowSurface(display, config,
mNativeWindowSurface.get(), NULL);
context = eglCreateContext(display, config, NULL, NULL);
eglQuerySurface(display, surface, EGL_WIDTH, &w);
eglQuerySurface(display, surface, EGL_HEIGHT, &h);
eglMakeCurrent(display, surface, surface, context);
mDisplay = display;
mContext = context;
mSurface = surface;
mWidth = w;
mHeight = h;
mFlingerSurface = s;
// initialize GL
glShadeModel(GL_FLAT);
glEnable(GL_DITHER);
glEnable(GL_TEXTURE_2D);
glEnable(GL_SCISSOR_TEST);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
return NO_ERROR;
}
void BootAnimation::requestExit() {
mBarrier.open();
Thread::requestExit();
}
bool BootAnimation::threadLoop() {
bool r = android();
eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
eglDestroyContext(mDisplay, mContext);
eglDestroySurface(mDisplay, mSurface);
mNativeWindowSurface.clear();
return r;
}
bool BootAnimation::android() {
initTexture(&mAndroid[0], mAssets, "images/android_320x480.png");
initTexture(&mAndroid[1], mAssets, "images/boot_robot.png");
initTexture(&mAndroid[2], mAssets, "images/boot_robot_glow.png");
// erase screen
glDisable(GL_SCISSOR_TEST);
glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);
// clear screen
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mDisplay, mSurface);
// wait ~1s
usleep(800000);
// fade in
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
const int steps = 8;
for (int i = 1; i < steps; i++) {
float fade = i / float(steps);
glColor4f(1, 1, 1, fade * fade);
glClear(GL_COLOR_BUFFER_BIT);
glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
eglSwapBuffers(mDisplay, mSurface);
}
// draw last frame
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDisable(GL_BLEND);
glDrawTexiOES(0, 0, 0, mAndroid[0].w, mAndroid[0].h);
eglSwapBuffers(mDisplay, mSurface);
// update rect for the robot
const int x = mWidth - mAndroid[1].w - 33;
const int y = (mHeight - mAndroid[1].h) / 2 - 1;
const Rect updateRect(x, y, x + mAndroid[1].w, y + mAndroid[1].h);
// draw and update only what we need
mNativeWindowSurface->setSwapRectangle(updateRect.left,
updateRect.top, updateRect.width(), updateRect.height());
glEnable(GL_SCISSOR_TEST);
glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
updateRect.height());
const nsecs_t startTime = systemTime();
do {
// glow speed and shape
nsecs_t time = systemTime() - startTime;
float t = ((4.0f / (360.0f * us2ns(16667))) * time);
t = t - floorf(t);
const float fade = 0.5f + 0.5f * sinf(t * 2 * M_PI);
// fade the glow in and out
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, mAndroid[2].name);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glColor4f(fade, fade, fade, fade);
glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
updateRect.width(), updateRect.height());
// draw the robot
glEnable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, mAndroid[1].name);
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glDrawTexiOES(updateRect.left, mHeight - updateRect.bottom, 0,
updateRect.width(), updateRect.height());
// make sure sleep a lot to not take too much CPU away from
// the boot process. With this "glow" animation there is no
// visible difference.
usleep(16667 * 4);
eglSwapBuffers(mDisplay, mSurface);
} while (!exitPending());
glDeleteTextures(1, &mAndroid[0].name);
glDeleteTextures(1, &mAndroid[1].name);
glDeleteTextures(1, &mAndroid[2].name);
return false;
}
bool BootAnimation::cylon() {
// initialize the textures...
initTexture(&mLeftTrail, mAssets, "images/cylon_left.png");
initTexture(&mRightTrail, mAssets, "images/cylon_right.png");
initTexture(&mBrightSpot, mAssets, "images/cylon_dot.png");
int w = mWidth;
int h = mHeight;
const Point c(w / 2, h / 2);
const GLint amplitude = 60;
const int scx = c.x - amplitude - mBrightSpot.w / 2;
const int scy = c.y - mBrightSpot.h / 2;
const int scw = amplitude * 2 + mBrightSpot.w;
const int sch = mBrightSpot.h;
const Rect updateRect(scx, h - scy - sch, scx + scw, h - scy);
// erase screen
glDisable(GL_SCISSOR_TEST);
glClear(GL_COLOR_BUFFER_BIT);
eglSwapBuffers(mDisplay, mSurface);
glClear(GL_COLOR_BUFFER_BIT);
mNativeWindowSurface->setSwapRectangle(updateRect.left,
updateRect.top, updateRect.width(), updateRect.height());
glEnable(GL_SCISSOR_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
// clear the screen to white
Point p;
float t = 0;
float alpha = 1.0f;
const nsecs_t startTime = systemTime();
nsecs_t fadeTime = 0;
do {
// Set scissor in interesting area
glScissor(scx, scy, scw, sch);
// erase screen
glClear(GL_COLOR_BUFFER_BIT);
// compute wave
const float a = (t * 2 * M_PI) - M_PI / 2;
const float sn = sinf(a);
const float cs = cosf(a);
GLint x = GLint(amplitude * sn);
float derivative = cs;
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (derivative > 0) {
// vanishing trail...
p.x = (-amplitude + c.x) - mBrightSpot.w / 2;
p.y = c.y - mLeftTrail.h / 2;
float fade = 2.0f * (0.5f - t);
//fade *= fade;
glColor4f(fade, fade, fade, fade);
glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);
// trail...
p.x = (x + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
p.y = c.y - mRightTrail.h / 2;
fade = t < 0.25f ? t * 4.0f : 1.0f;
fade *= fade;
glColor4f(fade, fade, fade, fade);
glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);
} else {
// vanishing trail..
p.x = (amplitude + c.x) - (mRightTrail.w + mBrightSpot.w / 2) + 16;
p.y = c.y - mRightTrail.h / 2;
float fade = 2.0f * (0.5f - (t - 0.5f));
//fade *= fade;
glColor4f(fade, fade, fade, fade);
glBindTexture(GL_TEXTURE_2D, mRightTrail.name);
glDrawTexiOES(p.x, p.y, 0, mRightTrail.w, mRightTrail.h);
// trail...
p.x = (x + c.x) - mBrightSpot.w / 2;
p.y = c.y - mLeftTrail.h / 2;
fade = t < 0.5f + 0.25f ? (t - 0.5f) * 4.0f : 1.0f;
fade *= fade;
glColor4f(fade, fade, fade, fade);
glBindTexture(GL_TEXTURE_2D, mLeftTrail.name);
glDrawTexiOES(p.x, p.y, 0, mLeftTrail.w, mLeftTrail.h);
}
const Point p(x + c.x - mBrightSpot.w / 2, c.y - mBrightSpot.h / 2);
glBindTexture(GL_TEXTURE_2D, mBrightSpot.name);
glColor4f(1, 0.5, 0.5, 1);
glDrawTexiOES(p.x, p.y, 0, mBrightSpot.w, mBrightSpot.h);
// update animation
nsecs_t time = systemTime() - startTime;
t = ((4.0f / (360.0f * us2ns(16667))) * time);
t = t - floorf(t);
eglSwapBuffers(mDisplay, mSurface);
if (exitPending()) {
if (fadeTime == 0) {
fadeTime = time;
}
time -= fadeTime;
alpha = 1.0f - ((float(time) * 6.0f) / float(s2ns(1)));
session()->openTransaction();
mFlingerSurface->setAlpha(alpha * alpha);
session()->closeTransaction();
}
} while (alpha > 0);
// cleanup
glFinish();
glDeleteTextures(1, &mLeftTrail.name);
glDeleteTextures(1, &mRightTrail.name);
glDeleteTextures(1, &mBrightSpot.name);
return false;
}
// ---------------------------------------------------------------------------
}
; // namespace android
Reference in New Issue View Git Blame Copy Permalink