323 lines
8.8 KiB
C++
323 lines
8.8 KiB
C++
/*
|
|
* 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_NDEBUG 0
|
|
#define LOG_TAG "BootAnimation"
|
|
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
#include <math.h>
|
|
#include <fcntl.h>
|
|
#include <utils/misc.h>
|
|
#include <signal.h>
|
|
|
|
#include <cutils/properties.h>
|
|
|
|
#include <androidfw/AssetManager.h>
|
|
#include <binder/IPCThreadState.h>
|
|
#include <utils/Atomic.h>
|
|
#include <utils/Errors.h>
|
|
#include <utils/Log.h>
|
|
|
|
#include <ui/PixelFormat.h>
|
|
#include <ui/Rect.h>
|
|
#include <ui/Region.h>
|
|
#include <ui/DisplayInfo.h>
|
|
|
|
#include <gui/ISurfaceComposer.h>
|
|
#include <gui/Surface.h>
|
|
#include <gui/SurfaceComposerClient.h>
|
|
|
|
#include <SkBitmap.h>
|
|
#include <SkStream.h>
|
|
#include <SkImageDecoder.h>
|
|
|
|
#include <GLES/gl.h>
|
|
#include <GLES/glext.h>
|
|
#include <EGL/eglext.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <hardware/qemu_pipe.h>
|
|
#include <hardware/qemud.h>
|
|
|
|
#include "BootAnimation.h"
|
|
|
|
#define EXIT_PROP_NAME "service.bootanim.exit"
|
|
|
|
#ifndef D
|
|
# define D(...) do{}while(0)
|
|
#endif
|
|
|
|
extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
|
|
const struct timespec *request,
|
|
struct timespec *remain);
|
|
|
|
namespace android {
|
|
|
|
static const int ANIM_ENTRY_NAME_MAX = 256;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
BootAnimation::BootAnimation() : Thread(false)
|
|
{
|
|
mSession = new SurfaceComposerClient();
|
|
}
|
|
|
|
BootAnimation::~BootAnimation() {
|
|
}
|
|
|
|
void BootAnimation::onFirstRef() {
|
|
status_t err = mSession->linkToComposerDeath(this);
|
|
ALOGE_IF(err, "linkToComposerDeath failed (%s) ", strerror(-err));
|
|
if (err == NO_ERROR) {
|
|
run("BootAnimation", PRIORITY_DISPLAY);
|
|
}
|
|
}
|
|
|
|
sp<SurfaceComposerClient> BootAnimation::session() const {
|
|
return mSession;
|
|
}
|
|
|
|
|
|
void BootAnimation::binderDied(const wp<IBinder>&)
|
|
{
|
|
// woah, surfaceflinger died!
|
|
ALOGD("SurfaceFlinger died, exiting...");
|
|
|
|
// calling requestExit() is not enough here because the Surface code
|
|
// might be blocked on a condition variable that will never be updated.
|
|
kill( getpid(), SIGKILL );
|
|
requestExit();
|
|
}
|
|
|
|
status_t BootAnimation::initTexture(Texture* texture, void* imageData, size_t size)
|
|
{
|
|
SkBitmap bitmap;
|
|
|
|
SkImageDecoder::DecodeMemory(imageData, size,
|
|
&bitmap, kUnknown_SkColorType, SkImageDecoder::kDecodePixels_Mode);
|
|
|
|
// 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.colorType()) {
|
|
case kAlpha_8_SkColorType:
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
|
|
GL_UNSIGNED_BYTE, p);
|
|
break;
|
|
case kARGB_4444_SkColorType:
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
|
|
GL_UNSIGNED_SHORT_4_4_4_4, p);
|
|
break;
|
|
case kN32_SkColorType:
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
|
|
GL_UNSIGNED_BYTE, p);
|
|
break;
|
|
case kRGB_565_SkColorType:
|
|
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();
|
|
|
|
sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
|
|
ISurfaceComposer::eDisplayIdMain));
|
|
DisplayInfo dinfo;
|
|
status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &dinfo);
|
|
if (status)
|
|
return -1;
|
|
|
|
// create the native surface
|
|
sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"),
|
|
dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
|
|
|
|
SurfaceComposerClient::openGlobalTransaction();
|
|
control->setLayer(0x40000000);
|
|
SurfaceComposerClient::closeGlobalTransaction();
|
|
|
|
sp<Surface> s = control->getSurface();
|
|
|
|
// initialize opengl and egl
|
|
const EGLint attribs[] = {
|
|
EGL_RED_SIZE, 8,
|
|
EGL_GREEN_SIZE, 8,
|
|
EGL_BLUE_SIZE, 8,
|
|
EGL_DEPTH_SIZE, 0,
|
|
EGL_NONE
|
|
};
|
|
EGLint w, h, dummy;
|
|
EGLint numConfigs;
|
|
EGLConfig config;
|
|
EGLSurface surface;
|
|
EGLContext context;
|
|
|
|
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
|
|
eglInitialize(display, 0, 0);
|
|
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
|
|
surface = eglCreateWindowSurface(display, config, s.get(), NULL);
|
|
context = eglCreateContext(display, config, NULL, NULL);
|
|
eglQuerySurface(display, surface, EGL_WIDTH, &w);
|
|
eglQuerySurface(display, surface, EGL_HEIGHT, &h);
|
|
|
|
if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
|
|
return NO_INIT;
|
|
|
|
mDisplay = display;
|
|
mContext = context;
|
|
mSurface = surface;
|
|
mWidth = w;
|
|
mHeight = h;
|
|
mFlingerSurfaceControl = control;
|
|
mFlingerSurface = s;
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
bool BootAnimation::threadLoop()
|
|
{
|
|
bool r;
|
|
r = android();
|
|
|
|
eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
|
|
eglDestroyContext(mDisplay, mContext);
|
|
eglDestroySurface(mDisplay, mSurface);
|
|
mFlingerSurface.clear();
|
|
mFlingerSurfaceControl.clear();
|
|
eglTerminate(mDisplay);
|
|
IPCThreadState::self()->stopProcess();
|
|
return r;
|
|
}
|
|
|
|
bool BootAnimation::android()
|
|
{
|
|
int fd = qemu_pipe_open("anbox:bootanimation");
|
|
if(!fd) {
|
|
return false;
|
|
}
|
|
|
|
qemud_channel_send(fd, "retrieve-icon", -1);
|
|
|
|
unsigned long current_size = 0;
|
|
unsigned long bytes_received = 0;
|
|
void *buffer = 0;
|
|
do
|
|
{
|
|
current_size += 4096;
|
|
buffer = realloc(buffer, current_size);
|
|
int t = read(fd, buffer + bytes_received, 4096);
|
|
if (t <= 0)
|
|
break;
|
|
printf("received %d bytes\n", t);
|
|
bytes_received += t;
|
|
} while(1);
|
|
|
|
close(fd);
|
|
|
|
if (bytes_received == 0) {
|
|
return false;
|
|
}
|
|
|
|
initTexture(&mAndroid[0], buffer, bytes_received);
|
|
|
|
// clear screen
|
|
glShadeModel(GL_FLAT);
|
|
glDisable(GL_DITHER);
|
|
glDisable(GL_SCISSOR_TEST);
|
|
glClearColor(0,0,0,1);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
eglSwapBuffers(mDisplay, mSurface);
|
|
|
|
glEnable(GL_TEXTURE_2D);
|
|
glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
|
|
|
const GLint xc = (mWidth - mAndroid[0].w) / 2;
|
|
const GLint yc = (mHeight - mAndroid[0].h) / 2;
|
|
const Rect updateRect(xc, yc, xc + mAndroid[0].w, yc + mAndroid[0].h);
|
|
|
|
glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
|
|
updateRect.height());
|
|
|
|
const nsecs_t startTime = systemTime();
|
|
do {
|
|
nsecs_t now = systemTime();
|
|
double time = now - startTime;
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
glDisable(GL_SCISSOR_TEST);
|
|
glDisable(GL_BLEND);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);
|
|
glDrawTexiOES(xc, yc, 0, mAndroid[0].w, mAndroid[0].h);
|
|
|
|
EGLBoolean res = eglSwapBuffers(mDisplay, mSurface);
|
|
if (res == EGL_FALSE)
|
|
break;
|
|
|
|
// 12fps: don't animate too fast to preserve CPU
|
|
const nsecs_t sleepTime = 83333 - ns2us(systemTime() - now);
|
|
if (sleepTime > 0)
|
|
usleep(sleepTime);
|
|
|
|
checkExit();
|
|
} while (!exitPending());
|
|
|
|
glDeleteTextures(1, &mAndroid[0].name);
|
|
return false;
|
|
}
|
|
|
|
|
|
void BootAnimation::checkExit() {
|
|
// Allow surface flinger to gracefully request shutdown
|
|
char value[PROPERTY_VALUE_MAX];
|
|
property_get(EXIT_PROP_NAME, value, "0");
|
|
int exitnow = atoi(value);
|
|
if (exitnow) {
|
|
requestExit();
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
}
|
|
; // namespace android
|