LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

am 8f709075: am 3f5c9555: Merge "emulator opengl: pool of fixups to the system components."

Browse Source 
* commit '8f709075cbed02f8f660b89f2fd7b6131dad19c4':
  emulator opengl: pool of fixups to the system components.
This commit is contained in:
David Turner
2011-06-21 05:11:50 -07:00
committed by Android Git Automerger
parent 97ae42d718 8f709075cb
commit 7304f16f03
21 changed files with 397 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
tools/emulator/opengl/system/GLESv1/Android.mk
View File

@@ -26,12 +26,12 @@ LOCAL_C_INCLUDES += \
$(call intermediates-dir-for, SHARED_LIBRARIES, libGLESv1_enc)
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE := libGL_emulation
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl
LOCAL_MODULE := libGLESv1_CM_emulation
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
LOCAL_STATIC_LIBRARIES := \
libOpenglSystemCommon \
libOpenglCodecCommon \
libqemu
@@ -39,7 +39,8 @@ LOCAL_SHARED_LIBRARIES := \
libcutils \
libutils \
libdl \
libGLESv1_enc \
libOpenglSystemCommon \
libGLESv1_enc \
lib_renderControl_enc

47
tools/emulator/opengl/system/GLESv1/gl.cpp
View File

@@ -3,6 +3,10 @@
#include "GLEncoder.h"
#include "GLES/gl.h"
#include "GLES/glext.h"
#include "ErrorLog.h"
#include <private/ui/android_natives_priv.h>
#include "gralloc_cb.h"
//XXX: fix this macro to get the context from fast tls path
#define GET_CONTEXT gl_client_context_t * ctx = HostConnection::get()->glEncoder();
@@ -15,6 +19,39 @@
static EGLClient_eglInterface * s_egl = NULL;
static EGLClient_glesInterface * s_gl = NULL;
#define DEFINE_AND_VALIDATE_HOST_CONNECTION(ret) \
HostConnection *hostCon = HostConnection::get(); \
if (!hostCon) { \
LOGE("egl: Failed to get host connection\n"); \
return ret; \
} \
renderControl_encoder_context_t *rcEnc = hostCon->rcEncoder(); \
if (!rcEnc) { \
LOGE("egl: Failed to get renderControl encoder context\n"); \
return ret; \
}
//GL extensions
void glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES image)
{
DBG("glEGLImageTargetTexture2DOES");
//TODO: check error - we don't have a way to set gl error
android_native_buffer_t* native_buffer = (android_native_buffer_t*)image;
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
return;
}
if (native_buffer->common.version != sizeof(android_native_buffer_t)) {
return;
}
DEFINE_AND_VALIDATE_HOST_CONNECTION();
rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
return;
}
void * getProcAddress(const char * procname)
{
// search in GL function table
@@ -31,6 +68,13 @@ void finish()
glFinish();
}
void init()
{
GET_CONTEXT;
ctx->set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES);
}
extern "C" {
EGLClient_glesInterface * init_emul_gles(EGLClient_eglInterface *eglIface)
{
s_egl = eglIface;
@@ -39,8 +83,11 @@ EGLClient_glesInterface * init_emul_gles(EGLClient_eglInterface *eglIface)
s_gl = new EGLClient_glesInterface();
s_gl->getProcAddress = getProcAddress;
s_gl->finish = finish;
s_gl->init = init;
}
return s_gl;
}
} //extern

3
tools/emulator/opengl/system/GLESv1_enc/Android.mk
View File

@@ -19,19 +19,16 @@ LOCAL_PRELINK_MODULE := false
LOCAL_CFLAGS += -DLOG_TAG=\"egl_GLESv1_enc\"
LOCAL_C_INCLUDES += \
$(emulatorOpengl)/shared/OpenglCodecCommon \
$(emulatorOpengl)/system/OpenglSystemCommon \
$(emulatorOpengl)/host/include/libOpenglRender \
$(emulatorOpengl)/system/renderControl_enc \
$(call intermediates-dir-for, SHARED_LIBRARIES, lib_renderControl_enc) \
$(glesv1_intermediates)
LOCAL_STATIC_LIBRARIES := \
libOpenglSystemCommon \
libOpenglCodecCommon \
libqemu
LOCAL_SHARED_LIBRARIES := \
lib_renderControl_enc \
libcutils
EMUGEN := $(HOST_OUT_EXECUTABLES)/emugen

26
tools/emulator/opengl/system/GLESv1_enc/GLEncoder.cpp
View File

@@ -16,10 +16,6 @@
#include "GLEncoder.h"
#include "glUtils.h"
#include "FixedBuffer.h"
#include "HostConnection.h"
#include <private/ui/android_natives_priv.h>
#include "gralloc_cb.h"
#include <cutils/log.h>
#include <assert.h>
@@ -154,7 +150,7 @@ void GLEncoder::s_glPixelStorei(void *self, GLenum param, GLint value)
{
GLEncoder *ctx = (GLEncoder *)self;
ctx->m_glPixelStorei_enc(ctx, param, value);
assert(ctx->m_state != NULL);
LOG_ASSERT(ctx->m_state, "GLEncoder::s_glPixelStorei");
ctx->m_state->setPixelStore(param, value);
}
@@ -455,6 +451,7 @@ void GLEncoder::s_glDrawElements(void *self, GLenum mode, GLsizei count, GLenum
GLEncoder::GLEncoder(IOStream *stream) : gl_encoder_context_t(stream)
{
m_initialized = false;
m_state = NULL;
m_compressedTextureFormats = NULL;
// overrides;
@@ -483,7 +480,6 @@ GLEncoder::GLEncoder(IOStream *stream) : gl_encoder_context_t(stream)
m_glDrawElements_enc = set_glDrawElements(s_glDrawElements);
set_glGetString(s_glGetString);
set_glFinish(s_glFinish);
set_glEGLImageTargetTexture2DOES(s_glEGLImageTargetTexture2DOES);
}
@@ -504,21 +500,3 @@ void GLEncoder::s_glFinish(void *self)
ctx->glFinishRoundTrip(self);
}
void GLEncoder::s_glEGLImageTargetTexture2DOES(void * self, GLenum target, GLeglImageOES image)
{
//TODO: check error - we don't have a way to set gl error
android_native_buffer_t* native_buffer = (android_native_buffer_t*)image;
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) {
return;
}
if (native_buffer->common.version != sizeof(android_native_buffer_t)) {
return;
}
DEFINE_AND_VALIDATE_HOST_CONNECTION();
rcEnc->rcBindTexture(rcEnc, ((cb_handle_t *)(native_buffer->handle))->hostHandle);
return;
}

5
tools/emulator/opengl/system/GLESv1_enc/GLEncoder.h
View File

@@ -30,8 +30,13 @@ public:
}
void flush() { m_stream->flush(); }
size_t pixelDataSize(GLsizei width, GLsizei height, GLenum format, GLenum type, int pack);
void setInitialized(){ m_initialized = true; };
bool isInitialized(){ return m_initialized; };
private:
bool m_initialized;
GLClientState *m_state;
FixedBuffer m_fixedBuffer;
GLint *m_compressedTextureFormats;

14
tools/emulator/opengl/system/OpenglSystemCommon/Android.mk
View File

@@ -23,7 +23,19 @@ LOCAL_C_INCLUDES += \
$(call intermediates-dir-for, SHARED_LIBRARIES, lib_renderControl_enc) \
$(call intermediates-dir-for, SHARED_LIBRARIES, libGLESv1_enc)
LOCAL_STATIC_LIBRARIES := \
libOpenglCodecCommon \
libqemu
LOCAL_SHARED_LIBRARIES := \
lib_renderControl_enc \
libGLESv1_enc \
libcutils \
libutils
LOCAL_PRELINK_MODULE := false
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE := libOpenglSystemCommon
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
include $(BUILD_STATIC_LIBRARY)
include $(BUILD_SHARED_LIBRARY)

1
tools/emulator/opengl/system/OpenglSystemCommon/EGLClientIface.h
View File

@@ -9,6 +9,7 @@ typedef struct {
typedef struct {
void* (*getProcAddress)(const char *funcName);
void (*init)();
void (*finish)();
} EGLClient_glesInterface;

25
tools/emulator/opengl/system/OpenglSystemCommon/HostConnection.cpp
View File

@@ -20,7 +20,7 @@
#include <cutils/log.h>
#define STREAM_BUFFER_SIZE 4*1024*1024
#define STREAM_PORT_NUM 4141
#define STREAM_PORT_NUM 22468
/* Set to 1 to use a QEMU pipe, or 0 for a TCP connection */
#define USE_QEMU_PIPE 1
@@ -56,6 +56,22 @@ HostConnection *HostConnection::get()
return NULL;
}
#if 0
TcpStream *stream = new TcpStream(STREAM_BUFFER_SIZE);
if (stream) {
if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
LOGE("Failed to connect to host (TcpStream)!!!\n");
delete stream;
stream = NULL;
}
else {
con->m_stream = stream;
LOGE("Established TCP connection with HOST\n");
}
}
if (!stream)
#endif
if (useQemuPipe) {
QemuPipeStream *stream = new QemuPipeStream(STREAM_BUFFER_SIZE);
if (!stream) {
@@ -64,7 +80,7 @@ HostConnection *HostConnection::get()
return NULL;
}
if (stream->connect() < 0) {
LOGE("Failed to connect to host !!!\n");
LOGE("Failed to connect to host (QemuPipeStream)!!!\n");
delete con;
return NULL;
}
@@ -80,13 +96,13 @@ HostConnection *HostConnection::get()
}
if (stream->connect("10.0.2.2", STREAM_PORT_NUM) < 0) {
LOGE("Failed to connect to host !!!\n");
LOGE("Failed to connect to host (TcpStream)!!!\n");
delete con;
return NULL;
}
con->m_stream = stream;
}
LOGD("Host Connection established \n");
LOGD("HostConnection::get() New Host Connection established %p, tid %d\n", con, gettid());
tinfo->hostConn = con;
}
@@ -97,6 +113,7 @@ GLEncoder *HostConnection::glEncoder()
{
if (!m_glEnc) {
m_glEnc = new GLEncoder(m_stream);
DBG("HostConnection::glEncoder new encoder %p, tid %d", m_glEnc, gettid());
m_glEnc->setContextAccessor(s_getGLContext);
}
return m_glEnc;

6
tools/emulator/opengl/system/OpenglSystemCommon/QemuPipeStream.cpp
View File

@@ -84,6 +84,7 @@ int QemuPipeStream::commitBuffer(size_t size)
int QemuPipeStream::writeFully(const void *buf, size_t len)
{
//DBG(">> QemuPipeStream::writeFully %d\n", len);
if (!valid()) return -1;
size_t res = len;
@@ -107,11 +108,13 @@ int QemuPipeStream::writeFully(const void *buf, size_t len)
ERR("QemuPipeStream::writeFully failed: %s\n", strerror(errno));
break;
}
//DBG("<< QemuPipeStream::writeFully %d\n", len );
return retval;
}
const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
{
//DBG(">> QemuPipeStream::readFully %d\n", len);
if (!valid()) return NULL;
if (!buf) {
ERR("QemuPipeStream::readFully failed, buf=NULL");
@@ -135,11 +138,13 @@ const unsigned char *QemuPipeStream::readFully(void *buf, size_t len)
res -= stat;
}
}
//DBG("<< QemuPipeStream::readFully %d\n", len);
return (const unsigned char *)buf;
}
const unsigned char *QemuPipeStream::read( void *buf, size_t *inout_len)
{
//DBG(">> QemuPipeStream::read %d\n", *inout_len);
if (!valid()) return NULL;
if (!buf) {
ERR("QemuPipeStream::read failed, buf=NULL");
@@ -153,6 +158,7 @@ const unsigned char *QemuPipeStream::read( void *buf, size_t *inout_len)
return (const unsigned char *)buf;
}
//DBG("<< QemuPipeStream::read %d\n", *inout_len);
return NULL;
}

18
tools/emulator/opengl/system/OpenglSystemCommon/gralloc_cb.h
View File

@@ -6,7 +6,7 @@
#include <cutils/native_handle.h>
#define BUFFER_HANDLE_MAGIC ((int)0xabfabfab)
#define CB_HANDLE_NUM_INTS(nfds) ((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int))
#define CB_HANDLE_NUM_INTS(nfds) (int)((sizeof(cb_handle_t) - (nfds)*sizeof(int)) / sizeof(int))
//
// Our buffer handle structure
@@ -32,7 +32,7 @@ struct cb_handle_t : public native_handle {
hostHandle(0)
{
version = sizeof(native_handle);
numFds = 1;
numFds = 0;
numInts = CB_HANDLE_NUM_INTS(numFds);
}
@@ -40,11 +40,21 @@ struct cb_handle_t : public native_handle {
magic = 0;
}
void setFd(int p_fd) {
if (p_fd >= 0) {
numFds = 1;
}
else {
numFds = 0;
}
fd = p_fd;
numInts = CB_HANDLE_NUM_INTS(numFds);
}
bool validate() const {
return (version == sizeof(native_handle) &&
magic == BUFFER_HANDLE_MAGIC &&
numInts == CB_HANDLE_NUM_INTS(1) &&
numFds == 1);
numInts == CB_HANDLE_NUM_INTS(numFds));
}
bool canBePosted() {

26
tools/emulator/opengl/system/egl/Android.mk
View File

@@ -29,13 +29,13 @@ LOCAL_C_INCLUDES += \
$(call intermediates-dir-for, SHARED_LIBRARIES, libGLESv1_enc)
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl
LOCAL_MODULE := libEGL_emulation
LOCAL_MODULE_CLASS := SHARED_LIBRARIES
LOCAL_PRELINK_MODULE := false
LOCAL_STATIC_LIBRARIES := \
libOpenglSystemCommon \
libOpenglCodecCommon \
libOpenglCodecCommon \
libqemu
LOCAL_SHARED_LIBRARIES := \
@@ -43,9 +43,29 @@ LOCAL_SHARED_LIBRARIES := \
libutils \
libdl \
libGLESv1_enc \
libOpenglSystemCommon \
lib_renderControl_enc
include $(BUILD_SHARED_LIBRARY)
#### egl.cfg ####
# Ensure that this file is only copied to emulator-specific builds.
# Other builds are device-specific and will provide their own
# version of this file to point to the appropriate HW EGL libraries.
#
ifneq (,$(filter full full_x86 sdk sdk_x86,$(TARGET_PRODUCT)))
include $(CLEAR_VARS)
LOCAL_MODULE := egl.cfg
LOCAL_SRC_FILES := $(LOCAL_MODULE)
LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_CLASS := ETC
include $(BUILD_PREBUILT)
endif # TARGET_PRODUCT in 'full sdk full_x86 sdk_x86'
endif # of ifneq (,$(BUILD_EMULATOR_OPENGL_DRIVER))

1
tools/emulator/opengl/system/egl/egl.cfg Normal file
View File

@@ -0,0 +1 @@
0 0 emulation

196
tools/emulator/opengl/system/egl/egl.cpp
View File

@@ -19,19 +19,63 @@
#include "egl_ftable.h"
#include <cutils/log.h>
#include "gralloc_cb.h"
#include "GLClientState.h"
#include <private/ui/android_natives_priv.h>
template<typename T>
static T setError(GLint error, T returnValue) {
static T setErrorFunc(GLint error, T returnValue) {
getEGLThreadInfo()->eglError = error;
return returnValue;
}
const char * eglStrError(EGLint err)
{
switch (err){
case EGL_SUCCESS: return "EGL_SUCCESS";
case EGL_NOT_INITIALIZED: return "EGL_NOT_INITIALIZED";
case EGL_BAD_ACCESS: return "EGL_BAD_ACCESS";
case EGL_BAD_ALLOC: return "EGL_BAD_ALLOC";
case EGL_BAD_ATTRIBUTE: return "EGL_BAD_ATTRIBUTE";
case EGL_BAD_CONFIG: return "EGL_BAD_CONFIG";
case EGL_BAD_CONTEXT: return "EGL_BAD_CONTEXT";
case EGL_BAD_CURRENT_SURFACE: return "EGL_BAD_CURRENT_SURFACE";
case EGL_BAD_DISPLAY: return "EGL_BAD_DISPLAY";
case EGL_BAD_MATCH: return "EGL_BAD_MATCH";
case EGL_BAD_NATIVE_PIXMAP: return "EGL_BAD_NATIVE_PIXMAP";
case EGL_BAD_NATIVE_WINDOW: return "EGL_BAD_NATIVE_WINDOW";
case EGL_BAD_PARAMETER: return "EGL_BAD_PARAMETER";
case EGL_BAD_SURFACE: return "EGL_BAD_SURFACE";
case EGL_CONTEXT_LOST: return "EGL_CONTEXT_LOST";
default: return "UNKNOWN";
}
}
#define LOG_EGL_ERRORS 1
#ifdef LOG_EGL_ERRORS
#define setErrorReturn(error, retVal) \
{ \
LOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, error, eglStrError(error)); \
return setErrorFunc(error, retVal); \
}
#define RETURN_ERROR(ret,err) \
LOGE("tid %d: %s(%d): error 0x%x (%s)", gettid(), __FUNCTION__, __LINE__, err, eglStrError(err)); \
getEGLThreadInfo()->eglError = err; \
return ret;
#else //!LOG_EGL_ERRORS
#define setErrorReturn(error, retVal) return setErrorFunc(error, retVal);
#define RETURN_ERROR(ret,err) \
getEGLThreadInfo()->eglError = err; \
return ret;
#endif //LOG_EGL_ERRORS
#define VALIDATE_CONFIG(cfg,ret) \
if(((int)cfg<0)||((int)cfg>s_display.getNumConfigs())) { \
RETURN_ERROR(ret,EGL_BAD_CONFIG); \
@@ -39,15 +83,13 @@ static T setError(GLint error, T returnValue) {
#define VALIDATE_DISPLAY(dpy,ret) \
if ((dpy) != (EGLDisplay)&s_display) { \
getEGLThreadInfo()->eglError = EGL_BAD_DISPLAY; \
return ret; \
RETURN_ERROR(ret, EGL_BAD_DISPLAY); \
}
#define VALIDATE_DISPLAY_INIT(dpy,ret) \
VALIDATE_DISPLAY(dpy, ret) \
if (!s_display.initialized()) { \
getEGLThreadInfo()->eglError = EGL_NOT_INITIALIZED; \
return ret; \
RETURN_ERROR(ret, EGL_NOT_INITIALIZED); \
}
#define DEFINE_HOST_CONNECTION \
@@ -75,9 +117,9 @@ static T setError(GLint error, T returnValue) {
if (surface != EGL_NO_SURFACE) { \
egl_surface_t* s( static_cast<egl_surface_t*>(surface) ); \
if (!s->isValid()) \
return setError(EGL_BAD_SURFACE, EGL_FALSE); \
setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE); \
if (s->dpy != (EGLDisplay)&s_display) \
return setError(EGL_BAD_DISPLAY, EGL_FALSE); \
setErrorReturn(EGL_BAD_DISPLAY, EGL_FALSE); \
}
@@ -91,13 +133,8 @@ struct EGLContext_t {
NEVER_CURRENT = 0x00020000
};
EGLContext_t(EGLDisplay dpy, EGLConfig config) : dpy(dpy), config(config),
read(EGL_NO_SURFACE), draw(EGL_NO_SURFACE),
rcContext(0) {
flags = 0;
version = 1;
};
~EGLContext_t(){};
EGLContext_t(EGLDisplay dpy, EGLConfig config);
~EGLContext_t();
uint32_t flags;
EGLDisplay dpy;
EGLConfig config;
@@ -105,8 +142,24 @@ struct EGLContext_t {
EGLSurface draw;
EGLint version;
uint32_t rcContext;
GLClientState * getClientState(){ return clientState; }
private:
GLClientState * clientState;
};
EGLContext_t::EGLContext_t(EGLDisplay dpy, EGLConfig config) : dpy(dpy), config(config),
read(EGL_NO_SURFACE), draw(EGL_NO_SURFACE), rcContext(0)
{
flags = 0;
version = 1;
clientState = new GLClientState();
};
EGLContext_t::~EGLContext_t()
{
if (clientState) delete clientState;
}
// ----------------------------------------------------------------------------
//egl_surface_t
@@ -127,6 +180,7 @@ struct egl_surface_t {
virtual EGLBoolean connect() { return EGL_TRUE; }
virtual void disconnect() {}
virtual EGLBoolean swapBuffers() { return EGL_TRUE; }
virtual EGLint getSwapBehavior() const;
void setRcSurface(uint32_t handle){ rcSurface = handle; }
uint32_t getRcSurface(){ return rcSurface; }
@@ -169,6 +223,10 @@ egl_surface_t::egl_surface_t(EGLDisplay dpy, EGLConfig config, EGLint surfaceTyp
texTarget = EGL_NO_TEXTURE;
}
EGLint egl_surface_t::getSwapBehavior() const {
return EGL_BUFFER_PRESERVED;
}
egl_surface_t::~egl_surface_t()
{
}
@@ -221,7 +279,7 @@ egl_window_surface_t::~egl_window_surface_t() {
EGLBoolean egl_window_surface_t::rcCreate()
{
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
uint32_t rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uint32_t)config, getWidth(), getHeight());
rcSurface = rcEnc->rcCreateWindowSurface(rcEnc, (uint32_t)config, getWidth(), getHeight());
if (!rcSurface) {
LOGE("rcCreateWindowSurface returned 0");
return EGL_FALSE;
@@ -248,7 +306,7 @@ EGLBoolean egl_window_surface_t::connect()
{
// dequeue a buffer
if (nativeWindow->dequeueBuffer(nativeWindow, &buffer) != NO_ERROR) {
return setError(EGL_BAD_ALLOC, EGL_FALSE);
setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE);
}
buffer->common.incRef(&buffer->common);
@@ -270,17 +328,19 @@ void egl_window_surface_t::disconnect()
EGLBoolean egl_window_surface_t::swapBuffers()
{
if (!buffer) {
return setError(EGL_BAD_ACCESS, EGL_FALSE);
setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE);
}
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
rcEnc->rcFlushWindowColorBuffer(rcEnc, rcSurface);
//post the back buffer
nativeWindow->queueBuffer(nativeWindow, buffer);
// dequeue a new buffer
if (nativeWindow->dequeueBuffer(nativeWindow, &buffer)) {
return setError(EGL_BAD_ALLOC, EGL_FALSE);
setErrorReturn(EGL_BAD_ALLOC, EGL_FALSE);
}
rcEnc->rcSetWindowColorBuffer(rcEnc, rcSurface, ((cb_handle_t *)(buffer->handle))->hostHandle);
@@ -374,6 +434,8 @@ static eglDisplay s_display;
static EGLClient_eglInterface s_eglIface = {
getThreadInfo: getEGLThreadInfo
};
#define DBG_FUNC DBG("%s\n", __FUNCTION__)
EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id)
{
//
@@ -492,7 +554,7 @@ EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig
}
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
*num_config = rcEnc->rcChooseConfig(rcEnc, (EGLint*)attrib_list, attribs_size, (uint32_t*)configs, config_size);
*num_config = rcEnc->rcChooseConfig(rcEnc, (EGLint*)attrib_list, attribs_size * sizeof(EGLint), (uint32_t*)configs, config_size*sizeof(EGLint));
return EGL_TRUE;
}
@@ -517,27 +579,27 @@ EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWin
VALIDATE_DISPLAY_INIT(dpy, NULL);
VALIDATE_CONFIG(config, EGL_FALSE);
if (win == 0) {
return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE);
}
EGLint surfaceType;
if (s_display.getConfigAttrib(config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) return EGL_FALSE;
if (!(surfaceType & EGL_WINDOW_BIT)) {
return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE);
}
if (static_cast<ANativeWindow*>(win)->common.magic != ANDROID_NATIVE_WINDOW_MAGIC) {
return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE);
}
egl_surface_t* surface;
surface = new egl_window_surface_t(&s_display, config, surfaceType, static_cast<ANativeWindow*>(win));
if (!surface)
return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE);
if (!surface->rcCreate()) {
delete surface;
return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
return surface;
@@ -552,7 +614,7 @@ EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLin
if (s_display.getConfigAttrib(config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) return EGL_FALSE;
if (!(surfaceType & EGL_PBUFFER_BIT)) {
return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE);
}
int32_t w = 0;
@@ -580,20 +642,20 @@ EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLin
}
if (((texFormat == EGL_NO_TEXTURE)&&(texTarget != EGL_NO_TEXTURE)) ||
((texFormat != EGL_NO_TEXTURE)&&(texTarget == EGL_NO_TEXTURE))) {
return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE);
}
// TODO: check EGL_TEXTURE_FORMAT - need to support eglBindTexImage
GLenum pixelFormat;
if (s_display.getConfigPixelFormat(config, &pixelFormat) == EGL_FALSE)
return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
if (s_display.getConfigGLPixelFormat(config, &pixelFormat) == EGL_FALSE)
setErrorReturn(EGL_BAD_MATCH, EGL_NO_SURFACE);
egl_surface_t* surface = new egl_pbuffer_surface_t(dpy, config, surfaceType, w, h, pixelFormat);
if (!surface)
return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE);
if (!surface->rcCreate()) {
delete surface;
return setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_SURFACE);
}
//setup attributes
@@ -650,9 +712,13 @@ EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface eglSurface, EGLint attribu
case EGL_TEXTURE_TARGET:
*value = surface->getTextureTarget();
break;
case EGL_SWAP_BEHAVIOR:
*value = surface->getSwapBehavior();
break;
//TODO: complete other attributes
default:
ret = setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
LOGE("eglQuerySurface %x EGL_BAD_ATTRIBUTE", attribute);
ret = setErrorFunc(EGL_BAD_ATTRIBUTE, EGL_FALSE);
break;
}
@@ -662,7 +728,7 @@ EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface eglSurface, EGLint attribu
EGLBoolean eglBindAPI(EGLenum api)
{
if (api != EGL_OPENGL_ES_API)
return setError(EGL_BAD_PARAMETER, EGL_FALSE);
setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
return EGL_TRUE;
}
@@ -704,21 +770,21 @@ EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface eglSurface, EGLint buffer)
VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE);
VALIDATE_SURFACE_RETURN(eglSurface, EGL_FALSE);
if (eglSurface == EGL_NO_SURFACE) {
return setError(EGL_BAD_SURFACE, EGL_FALSE);
setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE);
}
if (buffer != EGL_BACK_BUFFER) {
return setError(EGL_BAD_PARAMETER, EGL_FALSE);
setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
}
egl_surface_t* surface( static_cast<egl_surface_t*>(eglSurface) );
if (surface->getTextureFormat() == EGL_NO_TEXTURE) {
return setError(EGL_BAD_MATCH, EGL_FALSE);
setErrorReturn(EGL_BAD_MATCH, EGL_FALSE);
}
if (!(surface->getSurfaceType() & EGL_PBUFFER_BIT)) {
return setError(EGL_BAD_SURFACE, EGL_FALSE);
setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE);
}
//It's now safe to cast to pbuffer surface
@@ -752,7 +818,7 @@ EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_c
VALIDATE_CONFIG(config, EGL_NO_CONTEXT);
EGLint version = 1; //default
while (attrib_list[0]) {
while (attrib_list && attrib_list[0]) {
if (attrib_list[0] == EGL_CONTEXT_CLIENT_VERSION) version = attrib_list[1];
attrib_list+=2;
}
@@ -762,19 +828,19 @@ EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_c
EGLContext_t * shareCtx = static_cast<EGLContext_t*>(share_context);
rcShareCtx = shareCtx->rcContext;
if (shareCtx->dpy != dpy)
return setError(EGL_BAD_MATCH, EGL_NO_CONTEXT);
setErrorReturn(EGL_BAD_MATCH, EGL_NO_CONTEXT);
}
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_NO_CONTEXT);
uint32_t rcContext = rcEnc->rcCreateContext(rcEnc, (uint32_t)config, rcShareCtx, version);
if (!rcContext) {
LOGE("rcCreateContext returned 0");
return setError(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
}
EGLContext_t * context = new EGLContext_t(dpy, config);
if (!context)
return setError(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
setErrorReturn(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
context->version = version;
context->rcContext = rcContext;
@@ -812,9 +878,9 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
VALIDATE_SURFACE_RETURN(read, EGL_FALSE);
if ((read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE) && (ctx != EGL_NO_CONTEXT))
return setError(EGL_BAD_MATCH, EGL_FALSE);
setErrorReturn(EGL_BAD_MATCH, EGL_FALSE);
if ((read != EGL_NO_SURFACE || draw != EGL_NO_SURFACE) && (ctx == EGL_NO_CONTEXT))
return setError(EGL_BAD_MATCH, EGL_FALSE);
setErrorReturn(EGL_BAD_MATCH, EGL_FALSE);
EGLContext_t * context = static_cast<EGLContext_t*>(ctx);
uint32_t ctxHandle = (context) ? context->rcContext : 0;
@@ -836,13 +902,13 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
if (context && (context->flags & EGLContext_t::IS_CURRENT) && (context != tInfo->currentContext)) {
//context is current to another thread
return setError(EGL_BAD_ACCESS, EGL_FALSE);
setErrorReturn(EGL_BAD_ACCESS, EGL_FALSE);
}
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
if (rcEnc->rcMakeCurrent(rcEnc, ctxHandle, drawHandle, readHandle) == EGL_FALSE) {
LOGE("rcMakeCurrent returned EGL_FALSE");
return setError(EGL_BAD_CONTEXT, EGL_FALSE);
setErrorReturn(EGL_BAD_CONTEXT, EGL_FALSE);
}
//
@@ -858,15 +924,29 @@ EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLC
context->draw = draw;
context->read = read;
context->flags |= EGLContext_t::IS_CURRENT;
//set the client state
hostCon->glEncoder()->setClientState(context->getClientState());
}
if (tInfo->currentContext)
tInfo->currentContext->flags &= ~EGLContext_t::IS_CURRENT;
//Check maybe we need to init the encoder, if it's first eglMakeCurrent
if (tInfo->currentContext) {
if (!hostCon->glEncoder()->isInitialized()) {
if (tInfo->currentContext->version == 2) {
s_display.gles2_iface()->init();
}
else {
s_display.gles_iface()->init();
}
hostCon->glEncoder()->setInitialized();
}
}
//Now make current
tInfo->currentContext = context;
//connect the color buffer
if (drawSurf)
drawSurf->connect();
@@ -891,7 +971,7 @@ EGLSurface eglGetCurrentSurface(EGLint readdraw)
case EGL_DRAW:
return context->draw;
default:
return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_SURFACE);
}
}
@@ -929,7 +1009,9 @@ EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGL
*value = EGL_BACK_BUFFER; //single buffer not supported
break;
default:
return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE);
LOGE("eglQueryContext %x EGL_BAD_ATTRIBUTE", attribute);
setErrorReturn(EGL_BAD_ATTRIBUTE, EGL_FALSE);
break;
}
return ret;
@@ -961,15 +1043,15 @@ EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface eglSurface)
{
VALIDATE_DISPLAY_INIT(dpy, EGL_FALSE);
if (eglSurface == EGL_NO_SURFACE)
return setError(EGL_BAD_SURFACE, EGL_FALSE);
setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE);
DEFINE_AND_VALIDATE_HOST_CONNECTION(EGL_FALSE);
egl_surface_t* d = static_cast<egl_surface_t*>(eglSurface);
if (!d->isValid())
return setError(EGL_BAD_SURFACE, EGL_FALSE);
setErrorReturn(EGL_BAD_SURFACE, EGL_FALSE);
if (d->dpy != dpy)
return setError(EGL_BAD_DISPLAY, EGL_FALSE);
setErrorReturn(EGL_BAD_DISPLAY, EGL_FALSE);
// post the surface
d->swapBuffers();
@@ -1001,19 +1083,19 @@ EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EG
VALIDATE_DISPLAY_INIT(dpy, EGL_NO_IMAGE_KHR);
if (ctx != EGL_NO_CONTEXT) {
return setError(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
setErrorReturn(EGL_BAD_CONTEXT, EGL_NO_IMAGE_KHR);
}
if (target != EGL_NATIVE_BUFFER_ANDROID) {
return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
android_native_buffer_t* native_buffer = (android_native_buffer_t*)buffer;
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC)
return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
if (native_buffer->common.version != sizeof(android_native_buffer_t))
return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
switch (native_buffer->format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
@@ -1025,7 +1107,7 @@ EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EG
case HAL_PIXEL_FORMAT_RGBA_4444:
break;
default:
return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
setErrorReturn(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR);
}
native_buffer->common.incRef(&native_buffer->common);
@@ -1039,10 +1121,10 @@ EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img)
android_native_buffer_t* native_buffer = (android_native_buffer_t*)img;
if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC)
return setError(EGL_BAD_PARAMETER, EGL_FALSE);
setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
if (native_buffer->common.version != sizeof(android_native_buffer_t))
return setError(EGL_BAD_PARAMETER, EGL_FALSE);
setErrorReturn(EGL_BAD_PARAMETER, EGL_FALSE);
native_buffer->common.decRef(&native_buffer->common);

98
tools/emulator/opengl/system/egl/eglDisplay.cpp
View File

@@ -83,6 +83,7 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
&s_gles_lib);
if (!m_gles_iface) {
pthread_mutex_unlock(&m_lock);
LOGE("Failed to load gles1 iface");
return false;
}
@@ -100,6 +101,7 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
HostConnection *hcon = HostConnection::get();
if (!hcon) {
pthread_mutex_unlock(&m_lock);
LOGE("Failed to establish connection with the host\n");
return false;
}
@@ -109,6 +111,7 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
renderControl_encoder_context_t *rcEnc = hcon->rcEncoder();
if (!rcEnc) {
pthread_mutex_unlock(&m_lock);
LOGE("Failed to get renderControl encoder instance");
return false;
}
@@ -147,7 +150,7 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
uint32_t nInts = m_numConfigAttribs * (m_numConfigs + 1);
EGLint tmp_buf[nInts];
m_configs = new EGLint[nInts-1];
m_configs = new EGLint[nInts-m_numConfigAttribs];
if (!m_configs) {
pthread_mutex_unlock(&m_lock);
return false;
@@ -162,21 +165,34 @@ bool eglDisplay::initialize(EGLClient_eglInterface *eglIface)
//Fill the attributes vector.
//The first m_numConfigAttribs values of tmp_buf are the actual attributes enums.
for (int i=0; i<m_numConfigAttribs; i++)
{
for (int i=0; i<m_numConfigAttribs; i++) {
m_attribs.add(tmp_buf[i], i);
}
//Copy the actual configs data to m_configs
memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*sizeof(EGLint));
memcpy(m_configs, tmp_buf + m_numConfigAttribs, m_numConfigs*m_numConfigAttribs*sizeof(EGLint));
m_initialized = true;
}
pthread_mutex_unlock(&m_lock);
processConfigs();
return true;
}
void eglDisplay::processConfigs()
{
for (int i=0; i<m_numConfigs; i++) {
EGLConfig config = (EGLConfig)i;
//Setup the EGL_NATIVE_VISUAL_ID attribute
PixelFormat format;
if (getConfigNativePixelFormat(config, &format)) {
setConfigAttrib(config, EGL_NATIVE_VISUAL_ID, format);
}
}
}
void eglDisplay::terminate()
{
pthread_mutex_lock(&m_lock);
@@ -207,12 +223,14 @@ EGLClient_glesInterface *eglDisplay::loadGLESClientAPI(const char *libName,
{
void *lib = dlopen(libName, RTLD_NOW);
if (!lib) {
LOGE("Failed to dlopen %s", libName);
return NULL;
}
init_emul_gles_t init_gles_func = (init_emul_gles_t)dlsym(lib,"init_emul_gles");
if (!init_gles_func) {
dlclose((void*)libName);
LOGE("Failed to find init_emul_gles");
dlclose((void*)lib);
return NULL;
}
@@ -390,7 +408,41 @@ EGLBoolean eglDisplay::getConfigAttrib(EGLConfig config, EGLint attrib, EGLint *
return ret;
}
EGLBoolean eglDisplay::getConfigPixelFormat(EGLConfig config, GLenum * format)
void eglDisplay::dumpConfig(EGLConfig config)
{
EGLint value = 0;
DBG("^^^^^^^^^^ dumpConfig %d ^^^^^^^^^^^^^^^^^^", (int)config);
for (int i=0; i<m_numConfigAttribs; i++) {
getAttribValue(config, i, &value);
DBG("{%d}[%d] %d\n", (int)config, i, value);
}
}
/* To set the value of attribute <a> of config <c> use the following formula:
* *(m_configs + (int)c*m_numConfigAttribs + a) = value;
*/
EGLBoolean eglDisplay::setAttribValue(EGLConfig config, EGLint attribIdx, EGLint value)
{
if (attribIdx == ATTRIBUTE_NONE)
{
LOGE("[%s] Bad attribute idx\n", __FUNCTION__);
return EGL_FALSE;
}
*(m_configs + (int)config*m_numConfigAttribs + attribIdx) = value;
return EGL_TRUE;
}
EGLBoolean eglDisplay::setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value)
{
//Though it seems that valueFor() is thread-safe, we don't take chanses
pthread_mutex_lock(&m_lock);
EGLBoolean ret = setAttribValue(config, m_attribs.valueFor(attrib), value);
pthread_mutex_unlock(&m_lock);
return ret;
}
EGLBoolean eglDisplay::getConfigNativePixelFormat(EGLConfig config, PixelFormat * format)
{
EGLint redSize, blueSize, greenSize, alphaSize;
@@ -404,11 +456,35 @@ EGLBoolean eglDisplay::getConfigPixelFormat(EGLConfig config, GLenum * format)
}
//calculate the GL internal format
if ((redSize==8)&&(blueSize==8)&&(greenSize==8)&&(alphaSize==8)) *format = GL_RGBA;
else if ((redSize==8)&&(blueSize==8)&&(greenSize==8)&&(alphaSize==0)) *format = GL_RGB;
else if ((redSize==5)&&(blueSize==6)&&(greenSize==5)&&(alphaSize==0)) *format = GL_RGB565_OES;
else if ((redSize==5)&&(blueSize==5)&&(greenSize==5)&&(alphaSize==1)) *format = GL_RGB5_A1_OES;
else if ((redSize==4)&&(blueSize==4)&&(greenSize==4)&&(alphaSize==4)) *format = GL_RGBA4_OES;
if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==8)) *format = PIXEL_FORMAT_RGBA_8888; //XXX: BGR?
else if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGBX_8888; //XXX or PIXEL_FORMAT_RGB_888
else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = PIXEL_FORMAT_RGB_565;
else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = PIXEL_FORMAT_RGBA_5551;
else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = PIXEL_FORMAT_RGBA_4444;
else {
return EGL_FALSE;
}
return EGL_TRUE;
}
EGLBoolean eglDisplay::getConfigGLPixelFormat(EGLConfig config, GLenum * format)
{
EGLint redSize, blueSize, greenSize, alphaSize;
if ( !(getAttribValue(config, m_attribs.valueFor(EGL_RED_SIZE), &redSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_BLUE_SIZE), &blueSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_GREEN_SIZE), &greenSize) &&
getAttribValue(config, m_attribs.valueFor(EGL_ALPHA_SIZE), &alphaSize)) )
{
LOGE("Couldn't find value for one of the pixel format attributes");
return EGL_FALSE;
}
//calculate the GL internal format
if ((redSize==8)&&(blueSize==8)&&(blueSize==8)&&(alphaSize==8)) *format = GL_RGBA;
else if ((redSize==8)&&(greenSize==8)&&(blueSize==8)&&(alphaSize==0)) *format = GL_RGB;
else if ((redSize==5)&&(greenSize==6)&&(blueSize==5)&&(alphaSize==0)) *format = GL_RGB565_OES;
else if ((redSize==5)&&(greenSize==5)&&(blueSize==5)&&(alphaSize==1)) *format = GL_RGB5_A1_OES;
else if ((redSize==4)&&(greenSize==4)&&(blueSize==4)&&(alphaSize==4)) *format = GL_RGBA4_OES;
else return EGL_FALSE;
return EGL_TRUE;

9
tools/emulator/opengl/system/egl/eglDisplay.h
View File

@@ -23,6 +23,8 @@
#include "EGLClientIface.h"
#include <utils/KeyedVector.h>
#include <ui/PixelFormat.h>
#define ATTRIBUTE_NONE -1
//FIXME: are we in this namespace?
using namespace android;
@@ -46,13 +48,18 @@ public:
int getNumConfigs(){ return m_numConfigs; }
EGLBoolean getConfigAttrib(EGLConfig config, EGLint attrib, EGLint * value);
EGLBoolean getConfigPixelFormat(EGLConfig config, GLenum * format);
EGLBoolean setConfigAttrib(EGLConfig config, EGLint attrib, EGLint value);
EGLBoolean getConfigGLPixelFormat(EGLConfig config, GLenum * format);
EGLBoolean getConfigNativePixelFormat(EGLConfig config, PixelFormat * format);
void dumpConfig(EGLConfig config);
private:
EGLClient_glesInterface *loadGLESClientAPI(const char *libName,
EGLClient_eglInterface *eglIface,
void **libHandle);
EGLBoolean getAttribValue(EGLConfig config, EGLint attribIdxi, EGLint * value);
EGLBoolean setAttribValue(EGLConfig config, EGLint attribIdxi, EGLint value);
void processConfigs();
private:
pthread_mutex_t m_lock;

2
tools/emulator/opengl/system/gralloc/Android.mk
View File

@@ -31,12 +31,12 @@ LOCAL_MODULE_PATH = $(TARGET_OUT_SHARED_LIBRARIES)/hw
LOCAL_MODULE := gralloc.goldfish
LOCAL_STATIC_LIBRARIES := \
libOpenglSystemCommon \
libOpenglCodecCommon \
libqemu
LOCAL_SHARED_LIBRARIES := \
libcutils \
libOpenglSystemCommon \
libGLESv1_enc \
lib_renderControl_enc

15
tools/emulator/opengl/system/gralloc/gralloc.cpp
View File

@@ -29,6 +29,7 @@
#include <cutils/log.h>
#define DBG_FUNC DBG("%s\n", __FUNCTION__)
//
// our private gralloc module structure
//
@@ -163,7 +164,7 @@ static int gralloc_alloc(alloc_device_t* dev,
*pStride = bpr / bpp;
}
LOGD("gralloc_alloc ashmem_size=%d\n", ashmem_size);
LOGD("gralloc_alloc ashmem_size=%d, tid %d\n", ashmem_size, gettid());
//
// Allocate space in ashmem if needed
@@ -193,6 +194,8 @@ static int gralloc_alloc(alloc_device_t* dev,
delete cb;
return err;
}
cb->setFd(fd);
}
//
@@ -299,6 +302,12 @@ static int gralloc_device_close(struct hw_device_t *dev)
return 0;
}
static int fb_compositionComplete(struct framebuffer_device_t* dev)
{
LOGI("fb_compositionComplete");
return 0;
}
//
// Framebuffer device functions
//
@@ -650,6 +659,7 @@ static int gralloc_device_open(const hw_module_t* module,
if (NULL == dev) {
return -ENOMEM;
}
memset(dev, 0, sizeof(fb_device_t));
// Initialize our device structure
//
@@ -659,7 +669,8 @@ static int gralloc_device_open(const hw_module_t* module,
dev->device.common.close = fb_close;
dev->device.setSwapInterval = fb_setSwapInterval;
dev->device.post = fb_post;
dev->device.setUpdateRect = 0; //XXX: fb_setUpdateRect;
dev->device.setUpdateRect = fb_setUpdateRect;
dev->device.compositionComplete = fb_compositionComplete; //XXX: this is a dummy
const_cast<uint32_t&>(dev->device.flags) = 0;
const_cast<uint32_t&>(dev->device.width) = width;

2
tools/emulator/opengl/system/renderControl_enc/Android.mk
View File

@@ -20,6 +20,8 @@ LOCAL_STATIC_LIBRARIES := \
libOpenglCodecCommon
LOCAL_SHARED_LIBRARIES := libcutils
LOCAL_CFLAGS += -DDEBUG_PRINTOUT -O0 -g
RC_GEN := \
$(rc_intermediates)/renderControl_enc.cpp \
$(rc_intermediates)/renderControl_enc.h

3
tools/emulator/opengl/system/renderControl_enc/README
View File

@@ -81,6 +81,9 @@ uint32_t rcCreateColorBuffer(uint32_t width, uint32_t height, GLenum internalFor
void rcDestroyColorBuffer(uint32_t colorbuffer);
destroyes a colorBuffer object.
void rcFlushWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer);
This flushes the current window color buffer
void rcSetWindowColorBuffer(uint32_t windowSurface, uint32_t colorBuffer);
This set the target color buffer for a windowSurface, when set the
previous target colorBuffer gets updated before switching to the new

1
tools/emulator/opengl/system/renderControl_enc/renderControl.in
View File

@@ -12,6 +12,7 @@ GL_ENTRY(void, rcDestroyWindowSurface, uint32_t windowSurface)
GL_ENTRY(uint32_t, rcCreateColorBuffer, uint32_t width, uint32_t height, GLenum internalFormat)
GL_ENTRY(void, rcDestroyColorBuffer, uint32_t colorbuffer)
GL_ENTRY(void, rcSetWindowColorBuffer, uint32_t windowSurface, uint32_t colorBuffer)
GL_ENTRY(void, rcFlushWindowColorBuffer, uint32_t windowSurface)
GL_ENTRY(EGLint, rcMakeCurrent, uint32_t context, uint32_t drawSurf, uint32_t readSurf)
GL_ENTRY(void, rcFBPost, uint32_t colorBuffer)
GL_ENTRY(void, rcFBSetSwapInterval, EGLint interval)

8
tools/emulator/opengl/tests/gles_android_wrapper/Android.mk
View File

@@ -127,8 +127,10 @@ LOCAL_SHARED_LIBRARIES := libdl \
libcutils \
libGLESv1_enc \
libGLESv2_enc \
libut_rendercontrol_enc
LOCAL_STATIC_LIBRARIES := libOpenglCodecCommon libOpenglSystemCommon libqemu
libut_rendercontrol_enc \
libOpenglSystemCommon
LOCAL_STATIC_LIBRARIES := libOpenglCodecCommon libqemu
include $(BUILD_SHARED_LIBRARY)
@@ -139,6 +141,7 @@ include $(BUILD_SHARED_LIBRARY)
# version of this file to point to the appropriate HW EGL libraries.
#
ifneq (,$(filter full full_x86 sdk sdk_x86,$(TARGET_PRODUCT)))
ifeq (,$(BUILD_EMULATOR_OPENGL_DRIVER))
include $(CLEAR_VARS)
LOCAL_MODULE := egl.cfg
@@ -149,6 +152,7 @@ LOCAL_MODULE_TAGS := debug
LOCAL_MODULE_CLASS := ETC
include $(BUILD_PREBUILT)
endif # building 'real' driver BUILD_EMULATOR_OPENGL_DRIVER
endif # TARGET_PRODUCT in 'full sdk full_x86 sdk_x86'
#### gles_emul.cfg ####