/*
* 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 "EGLBitmapRender"
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <math.h>
#include <fcntl.h>
#include <utils/misc.h>
#include <signal.h>
#include <time.h>
#include <unistd.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>
// TODO: Fix Skia.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include <SkBitmap.h>
#include <SkStream.h>
#include <SkImageDecoder.h>
#pragma GCC diagnostic pop
#include <GLES/gl.h>
#include <GLES/glext.h>
#include <EGL/eglext.h>
#include "EGLBitmapRender.h"
namespace android {
// ---------------------------------------------------------------------------
static status_t openFile(const char *file, unsigned char** buf, size_t *len) {
int fd;
fd = open(file, O_RDONLY | /*O_BINARY*/0x0);
if (fd < 0)
return -1;
*len = lseek64(fd, 0, SEEK_END);
lseek64(fd, 0, SEEK_SET);
*buf = new unsigned char[*len];
read(fd, *buf, *len);
return 0;
}
EGLBitmapRender::EGLBitmapRender(char *name, int px, int py, int w, int h) : Thread(false), mBitmapRect(px,py,px+w,py+h)
{
mBitmapFile = name;
mSession = new SurfaceComposerClient();
}
EGLBitmapRender::~EGLBitmapRender() {
requestExit();
}
sp<SurfaceComposerClient> EGLBitmapRender::session() const {
return mSession;
}
void EGLBitmapRender::onFirstRef() {
run("EGLBitmapRender", PRIORITY_DISPLAY);
}
status_t EGLBitmapRender::initTexture(Texture* texture,/* AssetManager& assets,*/
const char* name) {
//Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
//if (asset == NULL)
// return NO_INIT;
unsigned char *buf;
size_t len;
if (openFile(name, &buf, &len) < 0) return NO_INIT;
ALOGD("open %s success", name);
SkBitmap bitmap;
SkImageDecoder::DecodeMemory(buf, len,
&bitmap, kN32_SkColorType, SkImageDecoder::kDecodePixels_Mode);
//asset->close();
//delete asset;
delete buf;
// 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();
mBitmapW = w;
mBitmapH = h;
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 EGLBitmapRender::readyToRun() {
//mAssets.addDefaultAssets();
//mAssets.addAssetPath(String8("/data/resource/assets"), 0);
ALOGD("readyToRun ..");
sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
ISurfaceComposer::eDisplayIdMain));
DisplayInfo dinfo;
status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &dinfo);
ALOGD("getDisplayInfo ..status = %d", status);
if (status)
return -1;
// create the native surface
sp<SurfaceControl> control = session()->createSurface(String8("EGLBitmapRender"),
mBitmapRect.width(), mBitmapRect.height(), PIXEL_FORMAT_RGB_565);
SurfaceComposerClient::openGlobalTransaction();
control->setLayer(0x40000000);
control->setPosition(mBitmapRect.leftTop().x, mBitmapRect.leftTop().y);
control->hide();
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;
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;
ALOGD("readyToRun ..eglMakeCurrent ..");
mDisplay = display;
mContext = context;
mSurface = surface;
mWidth = w;
mHeight = h;
mFlingerSurfaceControl = control;
mFlingerSurface = s;
return NO_ERROR;
}
status_t EGLBitmapRender::show() {
SurfaceComposerClient::openGlobalTransaction();
status_t r = mFlingerSurfaceControl->show();
SurfaceComposerClient::closeGlobalTransaction();
return r;
}
status_t EGLBitmapRender::hide() {
SurfaceComposerClient::openGlobalTransaction();
status_t r = mFlingerSurfaceControl->hide();
SurfaceComposerClient::closeGlobalTransaction();
return r;
}
bool EGLBitmapRender::threadLoop()
{
bool r;
r = drawLoop();
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 EGLBitmapRender::drawLoop()
{
initTexture(&mTexture[0],/* mAssets,*/ mBitmapFile);
//initTexture(&mTexture[1], mAssets, "images/android-logo-shine.png");
// 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 - mTexture[0].w) / 2;
const GLint yc = (mHeight - mTexture[0].h) / 2;
const Rect updateRect(xc, yc, xc + mTexture[0].w, yc + mTexture[0].h);
glScissor(updateRect.left, mHeight - updateRect.bottom, up
